← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/parser.cc

  • Committer: Brian Aker
  • Date: 2011-01-25 07:24:41 UTC
  • mfrom: (2104.3.14 alter-table)
  • Revision ID: brian@tangent.org-20110125072441-gf9f14lkxjhvvku9
Merge in alter/parser

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/parser.cc
125
125
  }
126
126
  if (lex->current_select->linkage == GLOBAL_OPTIONS_TYPE)
127
127
  {
128
 
    parser::error_t pass= { ER(ER_SYNTAX_ERROR), session };
129
 
    my_parse_error(pass);
 
128
    my_parse_error(session->m_lip);
130
129
    return true;
131
130
  }
132
131
  /* This counter shouldn't be incremented for UNION parts */
153
152
  Select_Lex * sel= lex->current_select;
154
153
  if (sel->set_braces(1))
155
154
  {
156
 
    parser::error_t pass= { ER(ER_SYNTAX_ERROR), session };
157
 
    my_parse_error(pass);
 
155
    my_parse_error(session->m_lip);
158
156
    return true;
159
157
  }
160
158
  if (sel->linkage == UNION_TYPE &&
162
160
      sel->master_unit()->first_select()->linkage ==
163
161
      UNION_TYPE)
164
162
  {
165
 
    parser::error_t pass= { ER(ER_SYNTAX_ERROR), session };
166
 
    my_parse_error(pass);
 
163
    my_parse_error(session->m_lip);
167
164
    return true;
168
165
  }
169
166
  if (sel->linkage == UNION_TYPE &&
205
202
  a parse error is discovered internally by the Bison generated
206
203
  parser.
207
204
*/
208
 
void my_parse_error(parser::error_t &arg)
 
205
void my_parse_error(Lex_input_stream *lip)
209
206
{
210
 
  Lex_input_stream *lip= arg.session->m_lip;
 
207
  assert(lip);
211
208
 
212
209
  const char *yytext= lip->get_tok_start();
213
210
  /* Push an error into the error stack */
214
 
  my_printf_error(ER_PARSE_ERROR,  ER(ER_PARSE_ERROR), MYF(0), arg.s,
 
211
  my_printf_error(ER_PARSE_ERROR,  ER(ER_PARSE_ERROR), MYF(0), ER(ER_SYNTAX_ERROR),
215
212
                  (yytext ? yytext : ""),
216
213
                  lip->yylineno);
217
214
}
218
215
 
 
216
void my_parse_error(const char *message)
 
217
{
 
218
  my_printf_error(ER_PARSE_ERROR_UNKNOWN, ER(ER_PARSE_ERROR_UNKNOWN), MYF(0), message);
 
219
}
 
220
 
219
221
bool check_reserved_words(LEX_STRING *name)
220
222
{
221
223
  if (!my_strcasecmp(system_charset_info, name->str, "GLOBAL") ||
227
229
}
228
230
 
229
231
 
 
232
/**
 
233
  @brief Bison callback to report a syntax/OOM error
 
234
 
 
235
  This function is invoked by the bison-generated parser
 
236
  when a syntax error, a parse error or an out-of-memory
 
237
  condition occurs. This function is not invoked when the
 
238
  parser is requested to abort by semantic action code
 
239
  by means of YYABORT or YYACCEPT macros. This is why these
 
240
  macros should not be used (use DRIZZLE_YYABORT/DRIZZLE_YYACCEPT
 
241
  instead).
 
242
 
 
243
  The parser will abort immediately after invoking this callback.
 
244
 
 
245
  This function is not for use in semantic actions and is internal to
 
246
  the parser, as it performs some pre-return cleanup.
 
247
  In semantic actions, please use parser::my_parse_error or my_error to
 
248
  push an error into the error stack and DRIZZLE_YYABORT
 
249
  to abort from the parser.
 
250
*/
 
251
void errorOn(const char *s)
 
252
{
 
253
  Session *session= current_session;
 
254
 
 
255
  /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */
 
256
  if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0)
 
257
  {
 
258
    parser::my_parse_error(session->m_lip);
 
259
  }
 
260
  else
 
261
  {
 
262
    parser::my_parse_error(s);
 
263
  }
 
264
}
 
265
 
 
266
bool buildOrderBy(Session *session)
 
267
{
 
268
  Select_Lex *sel= session->getLex()->current_select;
 
269
  Select_Lex_Unit *unit= sel-> master_unit();
 
270
 
 
271
  if (sel->linkage != GLOBAL_OPTIONS_TYPE &&
 
272
      sel->olap != UNSPECIFIED_OLAP_TYPE &&
 
273
      (sel->linkage != UNION_TYPE || sel->braces))
 
274
  {
 
275
    my_error(ER_WRONG_USAGE, MYF(0),
 
276
             "CUBE/ROLLUP", "ORDER BY");
 
277
    return false;
 
278
  }
 
279
 
 
280
  if (session->getLex()->sql_command != SQLCOM_ALTER_TABLE && !unit->fake_select_lex)
 
281
  {
 
282
    /*
 
283
      A query of the of the form (SELECT ...) ORDER BY order_list is
 
284
      executed in the same way as the query
 
285
      SELECT ... ORDER BY order_list
 
286
      unless the SELECT construct contains ORDER BY or LIMIT clauses.
 
287
      Otherwise we create a fake Select_Lex if it has not been created
 
288
      yet.
 
289
    */
 
290
    Select_Lex *first_sl= unit->first_select();
 
291
    if (!unit->is_union() &&
 
292
        (first_sl->order_list.elements ||
 
293
         first_sl->select_limit) &&           
 
294
        unit->add_fake_select_lex(session->getLex()->session))
 
295
    {
 
296
      return false;
 
297
    }
 
298
  }
 
299
 
 
300
  return true;
 
301
}
230
302
 
231
303
} // namespace parser
232
304
} // namespace drizzled