%{
/*-------------------------------------------------------------------------
*
- * gram.y - Parser for the PL/pgSQL
- * procedural language
+ * gram.y - Parser for the PL/pgSQL procedural language
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/pl/plpgsql/src/gram.y,v 1.132 2009/11/07 00:52:26 tgl Exp $
+ * $PostgreSQL: pgsql/src/pl/plpgsql/src/gram.y,v 1.133 2009/11/09 00:26:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "plpgsql.h"
#include "catalog/pg_type.h"
-#include "lib/stringinfo.h"
#include "parser/parser.h"
+#include "parser/parse_type.h"
+#include "parser/scansup.h"
/*
+ * We track token locations in terms of byte offsets from the start of the
+ * source string, not the column number/line number representation that
+ * bison uses by default. Also, to minimize overhead we track only one
+ * location (usually the first token location) for each construct, not
+ * the beginning and ending locations as bison does by default. It's
+ * therefore sufficient to make YYLTYPE an int.
+ */
+#define YYLTYPE int
+
+/* Location tracking support --- simpler than bison's default */
+#define YYLLOC_DEFAULT(Current, Rhs, N) \
+ do { \
+ if (N) \
+ (Current) = (Rhs)[1]; \
+ else \
+ (Current) = (Rhs)[0]; \
+ } while (0)
+
+/*
* Bison doesn't allocate anything that needs to live across parser calls,
* so we can easily have it use palloc instead of malloc. This prevents
* memory leaks if we error out during parsing. Note this only works with
#define YYFREE pfree
+typedef struct
+{
+ int location;
+ int leaderlen;
+} sql_error_callback_arg;
+
+#define parser_errposition(pos) plpgsql_scanner_errposition(pos)
+
static PLpgSQL_expr *read_sql_construct(int until,
int until2,
int until3,
const char *sqlstart,
bool isexpression,
bool valid_sql,
+ int *startloc,
int *endtoken);
static PLpgSQL_expr *read_sql_expression2(int until, int until2,
const char *expected,
int *endtoken);
static PLpgSQL_expr *read_sql_stmt(const char *sqlstart);
static PLpgSQL_type *read_datatype(int tok);
-static PLpgSQL_stmt *make_execsql_stmt(const char *sqlstart, int lineno);
+static PLpgSQL_stmt *make_execsql_stmt(int firsttoken, int location);
static PLpgSQL_stmt_fetch *read_fetch_direction(void);
static void complete_direction(PLpgSQL_stmt_fetch *fetch,
bool *check_FROM);
-static PLpgSQL_stmt *make_return_stmt(int lineno);
-static PLpgSQL_stmt *make_return_next_stmt(int lineno);
-static PLpgSQL_stmt *make_return_query_stmt(int lineno);
-static PLpgSQL_stmt *make_case(int lineno, PLpgSQL_expr *t_expr,
+static PLpgSQL_stmt *make_return_stmt(int location);
+static PLpgSQL_stmt *make_return_next_stmt(int location);
+static PLpgSQL_stmt *make_return_query_stmt(int location);
+static PLpgSQL_stmt *make_case(int location, PLpgSQL_expr *t_expr,
List *case_when_list, List *else_stmts);
-static void check_assignable(PLpgSQL_datum *datum);
+static void check_assignable(PLpgSQL_datum *datum, int location);
static void read_into_target(PLpgSQL_rec **rec, PLpgSQL_row **row,
bool *strict);
static PLpgSQL_row *read_into_scalar_list(const char *initial_name,
- PLpgSQL_datum *initial_datum);
+ PLpgSQL_datum *initial_datum,
+ int initial_location);
static PLpgSQL_row *make_scalar_list1(const char *initial_name,
PLpgSQL_datum *initial_datum,
- int lineno);
-static void check_sql_expr(const char *stmt);
+ int lineno, int location);
+static void check_sql_expr(const char *stmt, int location,
+ int leaderlen);
static void plpgsql_sql_error_callback(void *arg);
-static char *parse_string_token(const char *token);
-static void plpgsql_string_error_callback(void *arg);
+static PLpgSQL_type *parse_datatype(const char *string, int location);
+static char *parse_string_token(const char *token, int location);
static char *check_label(const char *yytxt);
static void check_labels(const char *start_label,
- const char *end_label);
+ const char *end_label,
+ int end_location);
static PLpgSQL_expr *read_cursor_args(PLpgSQL_var *cursor,
int until, const char *expected);
static List *read_raise_options(void);
%expect 0
%name-prefix="plpgsql_yy"
+%locations
%union {
int32 ival;
} declhdr;
struct
{
- char *end_label;
List *stmts;
+ char *end_label;
+ int end_label_location;
} loop_body;
List *list;
PLpgSQL_type *dtype;
%type <stmt> for_control
%type <str> any_identifier any_name opt_block_label opt_label
-%type <str> execsql_start
%type <list> proc_sect proc_stmts stmt_else
%type <loop_body> loop_body
%type <ival> opt_scrollable
%type <fetch> opt_fetch_direction
-%type <ival> lno
-
/*
* Keyword tokens
*/
| ';'
;
-pl_block : decl_sect K_BEGIN lno proc_sect exception_sect K_END opt_label
+pl_block : decl_sect K_BEGIN proc_sect exception_sect K_END opt_label
{
PLpgSQL_stmt_block *new;
new = palloc0(sizeof(PLpgSQL_stmt_block));
new->cmd_type = PLPGSQL_STMT_BLOCK;
- new->lineno = $3;
+ new->lineno = plpgsql_location_to_lineno(@2);
new->label = $1.label;
new->n_initvars = $1.n_initvars;
new->initvarnos = $1.initvarnos;
- new->body = $4;
- new->exceptions = $5;
+ new->body = $3;
+ new->exceptions = $4;
- check_labels($1.label, $7);
+ check_labels($1.label, $6, @6);
plpgsql_ns_pop();
$$ = (PLpgSQL_stmt *)new;
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row or record variable cannot be CONSTANT")));
+ errmsg("row or record variable cannot be CONSTANT"),
+ parser_errposition(@2)));
}
if ($4)
{
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row or record variable cannot be NOT NULL")));
+ errmsg("row or record variable cannot be NOT NULL"),
+ parser_errposition(@4)));
+
}
if ($5 != NULL)
{
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("default value for row or record variable is not supported")));
+ errmsg("default value for row or record variable is not supported"),
+ parser_errposition(@5)));
}
}
| decl_varname K_ALIAS K_FOR decl_aliasitem ';'
*cp2++ = *cp1;
*cp2++ = *cp1++;
}
- strcpy(cp2, "'::refcursor");
+ strcpy(cp2, "'::pg_catalog.refcursor");
curname_def->query = pstrdup(buf);
new->default_val = curname_def;
new = palloc0(sizeof(PLpgSQL_row));
new->dtype = PLPGSQL_DTYPE_ROW;
- new->lineno = plpgsql_scanner_lineno();
+ new->lineno = plpgsql_location_to_lineno(@1);
new->rowtupdesc = NULL;
new->nfields = list_length($2);
new->fieldnames = palloc(new->nfields * sizeof(char *));
name[0], NULL, NULL,
NULL);
if (nsi == NULL)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("variable \"%s\" does not exist",
- name[0])));
- }
+ name[0]),
+ parser_errposition(@1)));
pfree(name[0]);
name[0], name[1], NULL,
NULL);
if (nsi == NULL)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("variable \"%s.%s\" does not exist",
- name[0], name[1])));
- }
+ name[0], name[1]),
+ parser_errposition(@1)));
pfree(name[0]);
pfree(name[1]);
plpgsql_convert_ident(yytext, &name, 1);
$$.name = name;
- $$.lineno = plpgsql_scanner_lineno();
+ $$.lineno = plpgsql_location_to_lineno(@1);
/*
* Check to make sure name isn't already declared
* in the current block.
{ $$ = $1; }
;
-stmt_perform : K_PERFORM lno expr_until_semi
+stmt_perform : K_PERFORM expr_until_semi
{
PLpgSQL_stmt_perform *new;
new = palloc0(sizeof(PLpgSQL_stmt_perform));
new->cmd_type = PLPGSQL_STMT_PERFORM;
- new->lineno = $2;
- new->expr = $3;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->expr = $2;
$$ = (PLpgSQL_stmt *)new;
}
;
-stmt_assign : assign_var lno K_ASSIGN expr_until_semi
+stmt_assign : assign_var K_ASSIGN expr_until_semi
{
PLpgSQL_stmt_assign *new;
new = palloc0(sizeof(PLpgSQL_stmt_assign));
new->cmd_type = PLPGSQL_STMT_ASSIGN;
- new->lineno = $2;
+ new->lineno = plpgsql_location_to_lineno(@1);
new->varno = $1;
- new->expr = $4;
+ new->expr = $3;
$$ = (PLpgSQL_stmt *)new;
}
;
-stmt_getdiag : K_GET K_DIAGNOSTICS lno getdiag_list ';'
+stmt_getdiag : K_GET K_DIAGNOSTICS getdiag_list ';'
{
PLpgSQL_stmt_getdiag *new;
new = palloc0(sizeof(PLpgSQL_stmt_getdiag));
new->cmd_type = PLPGSQL_STMT_GETDIAG;
- new->lineno = $3;
- new->diag_items = $4;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->diag_items = $3;
$$ = (PLpgSQL_stmt *)new;
}
getdiag_target : T_DATUM
{
- check_assignable(yylval.datum);
+ check_assignable(yylval.datum, @1);
if (yylval.datum->dtype == PLPGSQL_DTYPE_ROW ||
yylval.datum->dtype == PLPGSQL_DTYPE_REC)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a scalar variable",
- yytext)));
+ yytext),
+ parser_errposition(@1)));
$$ = yylval.datum->dno;
}
| T_WORD
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a known variable",
- yytext)));
+ yytext),
+ parser_errposition(@1)));
}
;
assign_var : T_DATUM
{
- check_assignable(yylval.datum);
+ check_assignable(yylval.datum, @1);
$$ = yylval.datum->dno;
}
| assign_var '[' expr_until_rightbracket
}
;
-stmt_if : K_IF lno expr_until_then proc_sect stmt_else K_END K_IF ';'
+stmt_if : K_IF expr_until_then proc_sect stmt_else K_END K_IF ';'
{
PLpgSQL_stmt_if *new;
new = palloc0(sizeof(PLpgSQL_stmt_if));
new->cmd_type = PLPGSQL_STMT_IF;
- new->lineno = $2;
- new->cond = $3;
- new->true_body = $4;
- new->false_body = $5;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->cond = $2;
+ new->true_body = $3;
+ new->false_body = $4;
$$ = (PLpgSQL_stmt *)new;
}
{
$$ = NIL;
}
- | K_ELSIF lno expr_until_then proc_sect stmt_else
+ | K_ELSIF expr_until_then proc_sect stmt_else
{
- /*
+ /*----------
* Translate the structure: into:
*
* IF c1 THEN IF c1 THEN
* ... ...
* END IF END IF
* END IF
+ *----------
*/
PLpgSQL_stmt_if *new_if;
/* first create a new if-statement */
new_if = palloc0(sizeof(PLpgSQL_stmt_if));
new_if->cmd_type = PLPGSQL_STMT_IF;
- new_if->lineno = $2;
- new_if->cond = $3;
- new_if->true_body = $4;
- new_if->false_body = $5;
+ new_if->lineno = plpgsql_location_to_lineno(@1);
+ new_if->cond = $2;
+ new_if->true_body = $3;
+ new_if->false_body = $4;
/* wrap the if-statement in a "container" list */
$$ = list_make1(new_if);
}
;
-stmt_case : K_CASE lno opt_expr_until_when case_when_list opt_case_else K_END K_CASE ';'
+stmt_case : K_CASE opt_expr_until_when case_when_list opt_case_else K_END K_CASE ';'
{
- $$ = make_case($2, $3, $4, $5);
+ $$ = make_case(@1, $2, $3, $4);
}
;
}
;
-case_when : K_WHEN lno expr_until_then proc_sect
+case_when : K_WHEN expr_until_then proc_sect
{
PLpgSQL_case_when *new = palloc(sizeof(PLpgSQL_case_when));
- new->lineno = $2;
- new->expr = $3;
- new->stmts = $4;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->expr = $2;
+ new->stmts = $3;
$$ = new;
}
;
}
;
-stmt_loop : opt_block_label K_LOOP lno loop_body
+stmt_loop : opt_block_label K_LOOP loop_body
{
PLpgSQL_stmt_loop *new;
new = palloc0(sizeof(PLpgSQL_stmt_loop));
new->cmd_type = PLPGSQL_STMT_LOOP;
- new->lineno = $3;
+ new->lineno = plpgsql_location_to_lineno(@2);
new->label = $1;
- new->body = $4.stmts;
+ new->body = $3.stmts;
- check_labels($1, $4.end_label);
+ check_labels($1, $3.end_label, $3.end_label_location);
plpgsql_ns_pop();
$$ = (PLpgSQL_stmt *)new;
}
;
-stmt_while : opt_block_label K_WHILE lno expr_until_loop loop_body
+stmt_while : opt_block_label K_WHILE expr_until_loop loop_body
{
PLpgSQL_stmt_while *new;
new = palloc0(sizeof(PLpgSQL_stmt_while));
new->cmd_type = PLPGSQL_STMT_WHILE;
- new->lineno = $3;
+ new->lineno = plpgsql_location_to_lineno(@2);
new->label = $1;
- new->cond = $4;
- new->body = $5.stmts;
+ new->cond = $3;
+ new->body = $4.stmts;
- check_labels($1, $5.end_label);
+ check_labels($1, $4.end_label, $4.end_label_location);
plpgsql_ns_pop();
$$ = (PLpgSQL_stmt *)new;
PLpgSQL_stmt_fori *new;
new = (PLpgSQL_stmt_fori *) $3;
+ new->lineno = plpgsql_location_to_lineno(@2);
new->label = $1;
new->body = $4.stmts;
$$ = (PLpgSQL_stmt *) new;
$3->cmd_type == PLPGSQL_STMT_DYNFORS);
/* forq is the common supertype of all three */
new = (PLpgSQL_stmt_forq *) $3;
+ new->lineno = plpgsql_location_to_lineno(@2);
new->label = $1;
new->body = $4.stmts;
$$ = (PLpgSQL_stmt *) new;
}
- check_labels($1, $4.end_label);
+ check_labels($1, $4.end_label, $4.end_label_location);
/* close namespace started in opt_block_label */
plpgsql_ns_pop();
}
;
-for_control :
- lno for_variable K_IN
+for_control : for_variable K_IN
{
int tok = yylex();
+ int tokloc = yylloc;
if (tok == K_EXECUTE)
{
new = palloc0(sizeof(PLpgSQL_stmt_dynfors));
new->cmd_type = PLPGSQL_STMT_DYNFORS;
- new->lineno = $1;
- if ($2.rec)
+ if ($1.rec)
{
- new->rec = $2.rec;
- check_assignable((PLpgSQL_datum *) new->rec);
+ new->rec = $1.rec;
+ check_assignable((PLpgSQL_datum *) new->rec, @1);
}
- else if ($2.row)
+ else if ($1.row)
{
- new->row = $2.row;
- check_assignable((PLpgSQL_datum *) new->row);
+ new->row = $1.row;
+ check_assignable((PLpgSQL_datum *) new->row, @1);
}
- else if ($2.scalar)
+ else if ($1.scalar)
{
/* convert single scalar to list */
- new->row = make_scalar_list1($2.name, $2.scalar, $2.lineno);
+ new->row = make_scalar_list1($1.name, $1.scalar,
+ $1.lineno, @1);
/* no need for check_assignable */
}
else
{
- plpgsql_error_lineno = $2.lineno;
- yyerror("loop variable of loop over rows must be a record or row variable or list of scalar variables");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("loop variable of loop over rows must be a record or row variable or list of scalar variables"),
+ parser_errposition(@1)));
}
new->query = expr;
new = (PLpgSQL_stmt_forc *) palloc0(sizeof(PLpgSQL_stmt_forc));
new->cmd_type = PLPGSQL_STMT_FORC;
- new->lineno = $1;
-
new->curvar = cursor->dno;
/* Should have had a single variable name */
- plpgsql_error_lineno = $2.lineno;
- if ($2.scalar && $2.row)
+ if ($1.scalar && $1.row)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("cursor FOR loop must have only one target variable")));
+ errmsg("cursor FOR loop must have only one target variable"),
+ parser_errposition(@1)));
/* can't use an unbound cursor this way */
if (cursor->cursor_explicit_expr == NULL)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("cursor FOR loop must use a bound cursor variable")));
+ errmsg("cursor FOR loop must use a bound cursor variable"),
+ parser_errposition(tokloc)));
/* collect cursor's parameters if any */
new->argquery = read_cursor_args(cursor,
"LOOP");
/* create loop's private RECORD variable */
- plpgsql_convert_ident($2.name, &varname, 1);
+ plpgsql_convert_ident($1.name, &varname, 1);
new->rec = plpgsql_build_record(varname,
- $2.lineno,
+ $1.lineno,
true);
$$ = (PLpgSQL_stmt *) new;
else
{
PLpgSQL_expr *expr1;
- bool reverse = false;
+ int expr1loc;
+ bool reverse = false;
/*
* We have to distinguish between two
"SELECT ",
true,
false,
+ &expr1loc,
&tok);
if (tok == K_DOTDOT)
char *varname;
/* Check first expression is well-formed */
- check_sql_expr(expr1->query);
+ check_sql_expr(expr1->query, expr1loc, 7);
/* Read and check the second one */
expr2 = read_sql_expression2(K_LOOP, K_BY,
expr_by = NULL;
/* Should have had a single variable name */
- plpgsql_error_lineno = $2.lineno;
- if ($2.scalar && $2.row)
+ if ($1.scalar && $1.row)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("integer FOR loop must have only one target variable")));
+ errmsg("integer FOR loop must have only one target variable"),
+ parser_errposition(@1)));
/* create loop's private variable */
- plpgsql_convert_ident($2.name, &varname, 1);
+ plpgsql_convert_ident($1.name, &varname, 1);
fvar = (PLpgSQL_var *)
plpgsql_build_variable(varname,
- $2.lineno,
+ $1.lineno,
plpgsql_build_datatype(INT4OID,
-1),
true);
new = palloc0(sizeof(PLpgSQL_stmt_fori));
new->cmd_type = PLPGSQL_STMT_FORI;
- new->lineno = $1;
new->var = fvar;
new->reverse = reverse;
new->lower = expr1;
PLpgSQL_stmt_fors *new;
if (reverse)
- yyerror("cannot specify REVERSE in query FOR loop");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("cannot specify REVERSE in query FOR loop"),
+ parser_errposition(tokloc)));
Assert(strncmp(expr1->query, "SELECT ", 7) == 0);
tmp_query = pstrdup(expr1->query + 7);
pfree(expr1->query);
expr1->query = tmp_query;
- check_sql_expr(expr1->query);
+ check_sql_expr(expr1->query, expr1loc, 0);
new = palloc0(sizeof(PLpgSQL_stmt_fors));
new->cmd_type = PLPGSQL_STMT_FORS;
- new->lineno = $1;
- if ($2.rec)
+ if ($1.rec)
{
- new->rec = $2.rec;
- check_assignable((PLpgSQL_datum *) new->rec);
+ new->rec = $1.rec;
+ check_assignable((PLpgSQL_datum *) new->rec, @1);
}
- else if ($2.row)
+ else if ($1.row)
{
- new->row = $2.row;
- check_assignable((PLpgSQL_datum *) new->row);
+ new->row = $1.row;
+ check_assignable((PLpgSQL_datum *) new->row, @1);
}
- else if ($2.scalar)
+ else if ($1.scalar)
{
/* convert single scalar to list */
- new->row = make_scalar_list1($2.name, $2.scalar, $2.lineno);
+ new->row = make_scalar_list1($1.name, $1.scalar,
+ $1.lineno, @1);
/* no need for check_assignable */
}
else
{
- plpgsql_error_lineno = $2.lineno;
- yyerror("loop variable of loop over rows must be a record or row variable or list of scalar variables");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("loop variable of loop over rows must be a record or row variable or list of scalar variables"),
+ parser_errposition(@1)));
}
new->query = expr1;
for_variable : T_DATUM
{
$$.name = pstrdup(yytext);
- $$.lineno = plpgsql_scanner_lineno();
+ $$.lineno = plpgsql_location_to_lineno(@1);
if (yylval.datum->dtype == PLPGSQL_DTYPE_ROW)
{
$$.scalar = NULL;
plpgsql_push_back_token(tok);
if (tok == ',')
$$.row = read_into_scalar_list($$.name,
- $$.scalar);
+ $$.scalar,
+ @1);
}
}
| T_WORD
int tok;
$$.name = pstrdup(yytext);
- $$.lineno = plpgsql_scanner_lineno();
+ $$.lineno = plpgsql_location_to_lineno(@1);
$$.scalar = NULL;
$$.rec = NULL;
$$.row = NULL;
tok = yylex();
plpgsql_push_back_token(tok);
if (tok == ',')
- {
- plpgsql_error_lineno = $$.lineno;
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a known variable",
- $$.name)));
- }
+ $$.name),
+ parser_errposition(@1)));
}
;
-stmt_exit : exit_type lno opt_label opt_exitcond
+stmt_exit : exit_type opt_label opt_exitcond
{
PLpgSQL_stmt_exit *new;
new = palloc0(sizeof(PLpgSQL_stmt_exit));
new->cmd_type = PLPGSQL_STMT_EXIT;
new->is_exit = $1;
- new->lineno = $2;
- new->label = $3;
- new->cond = $4;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->label = $2;
+ new->cond = $3;
$$ = (PLpgSQL_stmt *)new;
}
}
;
-stmt_return : K_RETURN lno
+stmt_return : K_RETURN
{
int tok;
*/
if (pg_strcasecmp(yytext, "next") == 0)
{
- $$ = make_return_next_stmt($2);
+ $$ = make_return_next_stmt(@1);
}
else if (pg_strcasecmp(yytext, "query") == 0)
{
- $$ = make_return_query_stmt($2);
+ $$ = make_return_query_stmt(@1);
}
else
{
plpgsql_push_back_token(tok);
- $$ = make_return_stmt($2);
+ $$ = make_return_stmt(@1);
}
}
;
-stmt_raise : K_RAISE lno
+stmt_raise : K_RAISE
{
PLpgSQL_stmt_raise *new;
int tok;
new = palloc(sizeof(PLpgSQL_stmt_raise));
new->cmd_type = PLPGSQL_STMT_RAISE;
- new->lineno = $2;
+ new->lineno = plpgsql_location_to_lineno(@1);
new->elog_level = ERROR; /* default */
new->condname = NULL;
new->message = NULL;
if (tok == T_STRING)
{
/* old style message and parameters */
- new->message = parse_string_token(yytext);
+ new->message = parse_string_token(yytext, yylloc);
/*
* We expect either a semi-colon, which
* indicates no parameters, or a comma that
expr = read_sql_construct(',', ';', K_USING,
", or ; or USING",
"SELECT ",
- true, true, &tok);
+ true, true,
+ NULL, &tok);
new->params = lappend(new->params, expr);
}
}
if (yylex() != T_STRING)
yyerror("syntax error");
- sqlstatestr = parse_string_token(yytext);
+ sqlstatestr = parse_string_token(yytext, yylloc);
if (strlen(sqlstatestr) != 5)
yyerror("invalid SQLSTATE code");
{
$$.stmts = $1;
$$.end_label = $4;
- }
- ;
-
-stmt_execsql : execsql_start lno
- {
- $$ = make_execsql_stmt($1, $2);
+ $$.end_label_location = @4;
}
;
* known plpgsql variable. The latter two cases are probably syntax errors,
* but we'll let the core parser decide that.
*/
-execsql_start : K_INSERT
- { $$ = pstrdup(yytext); }
+stmt_execsql : K_INSERT
+ { $$ = make_execsql_stmt(K_INSERT, @1); }
| T_WORD
- { $$ = pstrdup(yytext); }
+ { $$ = make_execsql_stmt(T_WORD, @1); }
| T_DBLWORD
- { $$ = pstrdup(yytext); }
+ { $$ = make_execsql_stmt(T_DBLWORD, @1); }
| T_TRIPWORD
- { $$ = pstrdup(yytext); }
+ { $$ = make_execsql_stmt(T_TRIPWORD, @1); }
;
-stmt_dynexecute : K_EXECUTE lno
+stmt_dynexecute : K_EXECUTE
{
PLpgSQL_stmt_dynexecute *new;
PLpgSQL_expr *expr;
expr = read_sql_construct(K_INTO, K_USING, ';',
"INTO or USING or ;",
"SELECT ",
- true, true, &endtoken);
+ true, true,
+ NULL, &endtoken);
new = palloc(sizeof(PLpgSQL_stmt_dynexecute));
new->cmd_type = PLPGSQL_STMT_DYNEXECUTE;
- new->lineno = $2;
+ new->lineno = plpgsql_location_to_lineno(@1);
new->query = expr;
new->into = false;
new->strict = false;
;
-stmt_open : K_OPEN lno cursor_variable
+stmt_open : K_OPEN cursor_variable
{
PLpgSQL_stmt_open *new;
int tok;
new = palloc0(sizeof(PLpgSQL_stmt_open));
new->cmd_type = PLPGSQL_STMT_OPEN;
- new->lineno = $2;
- new->curvar = $3->dno;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->curvar = $2->dno;
new->cursor_options = CURSOR_OPT_FAST_PLAN;
- if ($3->cursor_explicit_expr == NULL)
+ if ($2->cursor_explicit_expr == NULL)
{
/* be nice if we could use opt_scrollable here */
tok = yylex();
}
if (tok != K_FOR)
- {
- plpgsql_error_lineno = $2;
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error at \"%s\"",
yytext),
- errdetail("Expected \"FOR\", to open a cursor for an unbound cursor variable.")));
- }
+ errdetail("Expected \"FOR\", to open a cursor for an unbound cursor variable."),
+ parser_errposition(yylloc)));
tok = yylex();
if (tok == K_EXECUTE)
else
{
/* predefined cursor query, so read args */
- new->argquery = read_cursor_args($3, ';', ";");
+ new->argquery = read_cursor_args($2, ';', ";");
}
$$ = (PLpgSQL_stmt *)new;
}
;
-stmt_fetch : K_FETCH lno opt_fetch_direction cursor_variable K_INTO
+stmt_fetch : K_FETCH opt_fetch_direction cursor_variable K_INTO
{
- PLpgSQL_stmt_fetch *fetch = $3;
+ PLpgSQL_stmt_fetch *fetch = $2;
PLpgSQL_rec *rec;
PLpgSQL_row *row;
if (fetch->returns_multiple_rows)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("FETCH statement cannot return multiple rows")));
+ errmsg("FETCH statement cannot return multiple rows"),
+ parser_errposition(@1)));
- fetch->lineno = $2;
+ fetch->lineno = plpgsql_location_to_lineno(@1);
fetch->rec = rec;
fetch->row = row;
- fetch->curvar = $4->dno;
+ fetch->curvar = $3->dno;
fetch->is_move = false;
$$ = (PLpgSQL_stmt *)fetch;
}
;
-stmt_move : K_MOVE lno opt_fetch_direction cursor_variable ';'
+stmt_move : K_MOVE opt_fetch_direction cursor_variable ';'
{
- PLpgSQL_stmt_fetch *fetch = $3;
+ PLpgSQL_stmt_fetch *fetch = $2;
- fetch->lineno = $2;
- fetch->curvar = $4->dno;
+ fetch->lineno = plpgsql_location_to_lineno(@1);
+ fetch->curvar = $3->dno;
fetch->is_move = true;
$$ = (PLpgSQL_stmt *)fetch;
}
;
-stmt_close : K_CLOSE lno cursor_variable ';'
+stmt_close : K_CLOSE cursor_variable ';'
{
PLpgSQL_stmt_close *new;
new = palloc(sizeof(PLpgSQL_stmt_close));
new->cmd_type = PLPGSQL_STMT_CLOSE;
- new->lineno = $2;
- new->curvar = $3->dno;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->curvar = $2->dno;
$$ = (PLpgSQL_stmt *)new;
}
cursor_variable : T_DATUM
{
if (yylval.datum->dtype != PLPGSQL_DTYPE_VAR)
- yyerror("cursor variable must be a simple variable");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("cursor variable must be a simple variable"),
+ parser_errposition(@1)));
if (((PLpgSQL_var *) yylval.datum)->datatype->typoid != REFCURSOROID)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("variable \"%s\" must be of type cursor or refcursor",
- ((PLpgSQL_var *) yylval.datum)->refname)));
- }
+ ((PLpgSQL_var *) yylval.datum)->refname),
+ parser_errposition(@1)));
$$ = (PLpgSQL_var *) yylval.datum;
}
| T_WORD
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a known variable",
- yytext)));
+ yytext),
+ parser_errposition(@1)));
}
;
exception_sect :
{ $$ = NULL; }
- | K_EXCEPTION lno
+ | K_EXCEPTION
{
/*
* We use a mid-rule action to add these
* scope of the names extends to the end of the
* current block.
*/
+ int lineno = plpgsql_location_to_lineno(@1);
PLpgSQL_exception_block *new = palloc(sizeof(PLpgSQL_exception_block));
PLpgSQL_variable *var;
- var = plpgsql_build_variable("sqlstate", $2,
+ var = plpgsql_build_variable("sqlstate", lineno,
plpgsql_build_datatype(TEXTOID, -1),
true);
((PLpgSQL_var *) var)->isconst = true;
new->sqlstate_varno = var->dno;
- var = plpgsql_build_variable("sqlerrm", $2,
+ var = plpgsql_build_variable("sqlerrm", lineno,
plpgsql_build_datatype(TEXTOID, -1),
true);
((PLpgSQL_var *) var)->isconst = true;
}
proc_exceptions
{
- PLpgSQL_exception_block *new = $<exception_block>3;
- new->exc_list = $4;
+ PLpgSQL_exception_block *new = $<exception_block>2;
+ new->exc_list = $3;
$$ = new;
}
}
;
-proc_exception : K_WHEN lno proc_conditions K_THEN proc_sect
+proc_exception : K_WHEN proc_conditions K_THEN proc_sect
{
PLpgSQL_exception *new;
new = palloc0(sizeof(PLpgSQL_exception));
- new->lineno = $2;
- new->conditions = $3;
- new->action = $5;
+ new->lineno = plpgsql_location_to_lineno(@1);
+ new->conditions = $2;
+ new->action = $4;
$$ = new;
}
/* next token should be a string literal */
if (yylex() != T_STRING)
yyerror("syntax error");
- sqlstatestr = parse_string_token(yytext);
+ sqlstatestr = parse_string_token(yytext, yylloc);
if (strlen(sqlstatestr) != 5)
yyerror("invalid SQLSTATE code");
}
;
-lno :
- {
- $$ = plpgsql_error_lineno = plpgsql_scanner_lineno();
- }
- ;
-
%%
plpgsql_read_expression(int until, const char *expected)
{
return read_sql_construct(until, 0, 0, expected,
- "SELECT ", true, true, NULL);
+ "SELECT ", true, true, NULL, NULL);
}
/* Convenience routine to read an expression with two possible terminators */
int *endtoken)
{
return read_sql_construct(until, until2, 0, expected,
- "SELECT ", true, true, endtoken);
+ "SELECT ", true, true, NULL, endtoken);
}
/* Convenience routine to read a SQL statement that must end with ';' */
read_sql_stmt(const char *sqlstart)
{
return read_sql_construct(';', 0, 0, ";",
- sqlstart, false, true, NULL);
+ sqlstart, false, true, NULL, NULL);
}
/*
* sqlstart: text to prefix to the accumulated SQL text
* isexpression: whether to say we're reading an "expression" or a "statement"
* valid_sql: whether to check the syntax of the expr (prefixed with sqlstart)
+ * startloc: if not NULL, location of first token is stored at *startloc
* endtoken: if not NULL, ending token is stored at *endtoken
* (this is only interesting if until2 or until3 isn't zero)
*/
const char *sqlstart,
bool isexpression,
bool valid_sql,
+ int *startloc,
int *endtoken)
{
int tok;
- int lno;
StringInfoData ds;
bool save_LookupIdentifiers;
+ int startlocation = -1;
int parenlevel = 0;
PLpgSQL_expr *expr;
- lno = plpgsql_scanner_lineno();
initStringInfo(&ds);
appendStringInfoString(&ds, sqlstart);
for (;;)
{
tok = yylex();
+ if (startlocation < 0) /* remember loc of first token */
+ startlocation = yylloc;
if (tok == until && parenlevel == 0)
break;
if (tok == until2 && parenlevel == 0)
{
if (parenlevel != 0)
yyerror("mismatched parentheses");
- plpgsql_error_lineno = lno;
if (isexpression)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("missing \"%s\" at end of SQL expression",
- expected)));
+ expected),
+ parser_errposition(yylloc)));
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("missing \"%s\" at end of SQL statement",
- expected)));
+ expected),
+ parser_errposition(yylloc)));
}
-
- if (plpgsql_SpaceScanned)
- appendStringInfoChar(&ds, ' ');
- appendStringInfoString(&ds, yytext);
}
plpgsql_LookupIdentifiers = save_LookupIdentifiers;
+ if (startloc)
+ *startloc = startlocation;
if (endtoken)
*endtoken = tok;
+ /* give helpful complaint about empty input */
+ if (startlocation >= yylloc)
+ {
+ if (isexpression)
+ yyerror("missing expression");
+ else
+ yyerror("missing SQL statement");
+ }
+
+ plpgsql_append_source_text(&ds, startlocation, yylloc);
+
+ /* trim any trailing whitespace, for neatness */
+ while (ds.len > 0 && scanner_isspace(ds.data[ds.len - 1]))
+ ds.data[--ds.len] = '\0';
+
expr = palloc0(sizeof(PLpgSQL_expr));
expr->dtype = PLPGSQL_DTYPE_EXPR;
expr->query = pstrdup(ds.data);
pfree(ds.data);
if (valid_sql)
- check_sql_expr(expr->query);
+ check_sql_expr(expr->query, startlocation, strlen(sqlstart));
return expr;
}
static PLpgSQL_type *
read_datatype(int tok)
{
- int lno;
StringInfoData ds;
char *type_name;
+ int startlocation;
PLpgSQL_type *result;
- bool needspace = false;
int parenlevel = 0;
/* Should always be called with LookupIdentifiers off */
Assert(!plpgsql_LookupIdentifiers);
- lno = plpgsql_scanner_lineno();
-
initStringInfo(&ds);
/* Often there will be a lookahead token, but if not, get one */
if (tok == YYEMPTY)
tok = yylex();
+ startlocation = yylloc;
+
/*
* If we have a single, double, or triple identifier, check for %TYPE
* and %ROWTYPE constructs.
return result;
}
}
- appendStringInfoString(&ds, " %");
}
- needspace = true;
}
else if (tok == T_DBLWORD)
{
return result;
}
}
- appendStringInfoString(&ds, " %");
}
- needspace = true;
}
else if (tok == T_TRIPWORD)
{
}
}
/* there's no tripword rowtype construct */
- appendStringInfoString(&ds, " %");
}
- needspace = true;
}
+ /* flush temporary usage of ds for rowtype checks */
+ resetStringInfo(&ds);
+
while (tok != ';')
{
if (tok == 0)
parenlevel++;
else if (tok == ')')
parenlevel--;
- if (needspace)
- appendStringInfoChar(&ds, ' ');
- needspace = true;
- appendStringInfoString(&ds, yytext);
tok = yylex();
}
- plpgsql_push_back_token(tok);
-
+ /* set up ds to contain complete typename text */
+ plpgsql_append_source_text(&ds, startlocation, yylloc);
type_name = ds.data;
if (type_name[0] == '\0')
yyerror("missing data type declaration");
- plpgsql_error_lineno = lno; /* in case of error in parse_datatype */
-
- result = plpgsql_parse_datatype(type_name);
+ result = parse_datatype(type_name, startlocation);
pfree(ds.data);
+ plpgsql_push_back_token(tok);
+
return result;
}
static PLpgSQL_stmt *
-make_execsql_stmt(const char *sqlstart, int lineno)
+make_execsql_stmt(int firsttoken, int location)
{
StringInfoData ds;
bool save_LookupIdentifiers;
int prev_tok;
bool have_into = false;
bool have_strict = false;
+ int into_start_loc = -1;
+ int into_end_loc = -1;
initStringInfo(&ds);
- appendStringInfoString(&ds, sqlstart);
/* no need to lookup identifiers within the SQL text */
save_LookupIdentifiers = plpgsql_LookupIdentifiers;
* anywhere in the string, not only at the start; consider CREATE RULE
* containing an INSERT statement.
*/
- if (pg_strcasecmp(sqlstart, "insert") == 0)
- tok = K_INSERT;
- else
- tok = 0;
-
+ tok = firsttoken;
for (;;)
{
prev_tok = tok;
tok = yylex();
+ if (have_into && into_end_loc < 0)
+ into_end_loc = yylloc; /* token after the INTO part */
if (tok == ';')
break;
if (tok == 0)
if (have_into)
yyerror("INTO specified more than once");
have_into = true;
+ into_start_loc = yylloc;
plpgsql_LookupIdentifiers = true;
read_into_target(&rec, &row, &have_strict);
plpgsql_LookupIdentifiers = false;
- continue;
}
-
- if (plpgsql_SpaceScanned)
- appendStringInfoChar(&ds, ' ');
- appendStringInfoString(&ds, yytext);
}
plpgsql_LookupIdentifiers = save_LookupIdentifiers;
+ if (have_into)
+ {
+ /*
+ * Insert an appropriate number of spaces corresponding to the
+ * INTO text, so that locations within the redacted SQL statement
+ * still line up with those in the original source text.
+ */
+ plpgsql_append_source_text(&ds, location, into_start_loc);
+ appendStringInfoSpaces(&ds, into_end_loc - into_start_loc);
+ plpgsql_append_source_text(&ds, into_end_loc, yylloc);
+ }
+ else
+ plpgsql_append_source_text(&ds, location, yylloc);
+
+ /* trim any trailing whitespace, for neatness */
+ while (ds.len > 0 && scanner_isspace(ds.data[ds.len - 1]))
+ ds.data[--ds.len] = '\0';
+
expr = palloc0(sizeof(PLpgSQL_expr));
expr->dtype = PLPGSQL_DTYPE_EXPR;
expr->query = pstrdup(ds.data);
expr->ns = plpgsql_ns_top();
pfree(ds.data);
- check_sql_expr(expr->query);
+ check_sql_expr(expr->query, location, 0);
execsql = palloc(sizeof(PLpgSQL_stmt_execsql));
execsql->cmd_type = PLPGSQL_STMT_EXECSQL;
- execsql->lineno = lineno;
+ execsql->lineno = plpgsql_location_to_lineno(location);
execsql->sqlstmt = expr;
execsql->into = have_into;
execsql->strict = have_strict;
static PLpgSQL_stmt *
-make_return_stmt(int lineno)
+make_return_stmt(int location)
{
PLpgSQL_stmt_return *new;
new = palloc0(sizeof(PLpgSQL_stmt_return));
new->cmd_type = PLPGSQL_STMT_RETURN;
- new->lineno = lineno;
+ new->lineno = plpgsql_location_to_lineno(location);
new->expr = NULL;
new->retvarno = -1;
if (plpgsql_curr_compile->fn_retset)
{
if (yylex() != ';')
- yyerror("RETURN cannot have a parameter in function "
- "returning set; use RETURN NEXT or RETURN QUERY");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN cannot have a parameter in function returning set"),
+ errhint("Use RETURN NEXT or RETURN QUERY."),
+ parser_errposition(yylloc)));
}
else if (plpgsql_curr_compile->out_param_varno >= 0)
{
if (yylex() != ';')
- yyerror("RETURN cannot have a parameter in function with OUT parameters");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN cannot have a parameter in function with OUT parameters"),
+ parser_errposition(yylloc)));
new->retvarno = plpgsql_curr_compile->out_param_varno;
}
else if (plpgsql_curr_compile->fn_rettype == VOIDOID)
{
if (yylex() != ';')
- yyerror("RETURN cannot have a parameter in function returning void");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN cannot have a parameter in function returning void"),
+ parser_errposition(yylloc)));
}
else if (plpgsql_curr_compile->fn_retistuple)
{
yylval.datum->dtype == PLPGSQL_DTYPE_REC)
new->retvarno = yylval.datum->dno;
else
- yyerror("RETURN must specify a record or row variable in function returning row");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN must specify a record or row variable in function returning row"),
+ parser_errposition(yylloc)));
break;
default:
- yyerror("RETURN must specify a record or row variable in function returning row");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN must specify a record or row variable in function returning row"),
+ parser_errposition(yylloc)));
break;
}
if (yylex() != ';')
- yyerror("RETURN must specify a record or row variable in function returning row");
+ yyerror("syntax error");
}
else
{
/*
- * Note that a well-formed expression is
- * _required_ here; anything else is a
- * compile-time error.
+ * Note that a well-formed expression is _required_ here;
+ * anything else is a compile-time error.
*/
new->expr = plpgsql_read_expression(';', ";");
}
static PLpgSQL_stmt *
-make_return_next_stmt(int lineno)
+make_return_next_stmt(int location)
{
PLpgSQL_stmt_return_next *new;
if (!plpgsql_curr_compile->fn_retset)
- yyerror("cannot use RETURN NEXT in a non-SETOF function");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("cannot use RETURN NEXT in a non-SETOF function"),
+ parser_errposition(location)));
new = palloc0(sizeof(PLpgSQL_stmt_return_next));
new->cmd_type = PLPGSQL_STMT_RETURN_NEXT;
- new->lineno = lineno;
+ new->lineno = plpgsql_location_to_lineno(location);
new->expr = NULL;
new->retvarno = -1;
if (plpgsql_curr_compile->out_param_varno >= 0)
{
if (yylex() != ';')
- yyerror("RETURN NEXT cannot have a parameter in function with OUT parameters");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN NEXT cannot have a parameter in function with OUT parameters"),
+ parser_errposition(yylloc)));
new->retvarno = plpgsql_curr_compile->out_param_varno;
}
else if (plpgsql_curr_compile->fn_retistuple)
yylval.datum->dtype == PLPGSQL_DTYPE_REC)
new->retvarno = yylval.datum->dno;
else
- yyerror("RETURN NEXT must specify a record or row variable in function returning row");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN NEXT must specify a record or row variable in function returning row"),
+ parser_errposition(yylloc)));
break;
default:
- yyerror("RETURN NEXT must specify a record or row variable in function returning row");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("RETURN NEXT must specify a record or row variable in function returning row"),
+ parser_errposition(yylloc)));
break;
}
if (yylex() != ';')
- yyerror("RETURN NEXT must specify a record or row variable in function returning row");
+ yyerror("syntax error");
}
else
new->expr = plpgsql_read_expression(';', ";");
static PLpgSQL_stmt *
-make_return_query_stmt(int lineno)
+make_return_query_stmt(int location)
{
PLpgSQL_stmt_return_query *new;
int tok;
if (!plpgsql_curr_compile->fn_retset)
- yyerror("cannot use RETURN QUERY in a non-SETOF function");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("cannot use RETURN QUERY in a non-SETOF function"),
+ parser_errposition(location)));
new = palloc0(sizeof(PLpgSQL_stmt_return_query));
new->cmd_type = PLPGSQL_STMT_RETURN_QUERY;
- new->lineno = lineno;
+ new->lineno = plpgsql_location_to_lineno(location);
/* check for RETURN QUERY EXECUTE */
if ((tok = yylex()) != K_EXECUTE)
static void
-check_assignable(PLpgSQL_datum *datum)
+check_assignable(PLpgSQL_datum *datum, int location)
{
switch (datum->dtype)
{
case PLPGSQL_DTYPE_VAR:
if (((PLpgSQL_var *) datum)->isconst)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_ERROR_IN_ASSIGNMENT),
errmsg("\"%s\" is declared CONSTANT",
- ((PLpgSQL_var *) datum)->refname)));
- }
+ ((PLpgSQL_var *) datum)->refname),
+ parser_errposition(location)));
break;
case PLPGSQL_DTYPE_ROW:
/* always assignable? */
case T_DATUM:
if (yylval.datum->dtype == PLPGSQL_DTYPE_ROW)
{
- check_assignable(yylval.datum);
+ check_assignable(yylval.datum, yylloc);
*row = (PLpgSQL_row *) yylval.datum;
}
else if (yylval.datum->dtype == PLPGSQL_DTYPE_REC)
{
- check_assignable(yylval.datum);
+ check_assignable(yylval.datum, yylloc);
*rec = (PLpgSQL_rec *) yylval.datum;
}
else
{
- *row = read_into_scalar_list(yytext, yylval.datum);
+ *row = read_into_scalar_list(yytext, yylval.datum, yylloc);
}
break;
default:
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error at \"%s\"", yytext),
errdetail("Expected record variable, row variable, "
- "or list of scalar variables following INTO.")));
+ "or list of scalar variables following INTO."),
+ parser_errposition(yylloc)));
}
}
*/
static PLpgSQL_row *
read_into_scalar_list(const char *initial_name,
- PLpgSQL_datum *initial_datum)
+ PLpgSQL_datum *initial_datum,
+ int initial_location)
{
int nfields;
char *fieldnames[1024];
PLpgSQL_row *row;
int tok;
- check_assignable(initial_datum);
+ check_assignable(initial_datum, initial_location);
fieldnames[0] = pstrdup(initial_name);
varnos[0] = initial_datum->dno;
nfields = 1;
{
/* Check for array overflow */
if (nfields >= 1024)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("too many INTO variables specified")));
- }
+ errmsg("too many INTO variables specified"),
+ parser_errposition(yylloc)));
tok = yylex();
- switch(tok)
+ switch (tok)
{
case T_DATUM:
- check_assignable(yylval.datum);
+ check_assignable(yylval.datum, yylloc);
if (yylval.datum->dtype == PLPGSQL_DTYPE_ROW ||
yylval.datum->dtype == PLPGSQL_DTYPE_REC)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a scalar variable",
- yytext)));
+ yytext),
+ parser_errposition(yylloc)));
fieldnames[nfields] = pstrdup(yytext);
varnos[nfields++] = yylval.datum->dno;
break;
default:
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"%s\" is not a known variable",
- yytext)));
+ yytext),
+ parser_errposition(yylloc)));
}
}
row = palloc(sizeof(PLpgSQL_row));
row->dtype = PLPGSQL_DTYPE_ROW;
row->refname = pstrdup("*internal*");
- row->lineno = plpgsql_scanner_lineno();
+ row->lineno = plpgsql_location_to_lineno(initial_location);
row->rowtupdesc = NULL;
row->nfields = nfields;
row->fieldnames = palloc(sizeof(char *) * nfields);
/*
* Convert a single scalar into a "row" list. This is exactly
* like read_into_scalar_list except we never consume any input.
- * In fact, since this can be invoked long after the source
- * input was actually read, the lineno has to be passed in.
+ *
+ * Note: lineno could be computed from location, but since callers
+ * have it at hand already, we may as well pass it in.
*/
static PLpgSQL_row *
make_scalar_list1(const char *initial_name,
PLpgSQL_datum *initial_datum,
- int lineno)
+ int lineno, int location)
{
PLpgSQL_row *row;
- check_assignable(initial_datum);
+ check_assignable(initial_datum, location);
row = palloc(sizeof(PLpgSQL_row));
row->dtype = PLPGSQL_DTYPE_ROW;
* than after parsing has finished, because a malformed SQL statement
* may cause the PL/PgSQL parser to become confused about statement
* borders. So it is best to bail out as early as we can.
+ *
+ * It is assumed that "stmt" represents a copy of the function source text
+ * beginning at offset "location", with leader text of length "leaderlen"
+ * (typically "SELECT ") prefixed to the source text. We use this assumption
+ * to transpose any error cursor position back to the function source text.
+ * If no error cursor is provided, we'll just point at "location".
*/
static void
-check_sql_expr(const char *stmt)
+check_sql_expr(const char *stmt, int location, int leaderlen)
{
+ sql_error_callback_arg cbarg;
ErrorContextCallback syntax_errcontext;
- ErrorContextCallback *previous_errcontext;
MemoryContext oldCxt;
if (!plpgsql_check_syntax)
return;
- /*
- * Setup error traceback support for ereport(). The previous
- * ereport callback is installed by pl_comp.c, but we don't want
- * that to be invoked (since it will try to transpose the syntax
- * error to be relative to the CREATE FUNCTION), so temporarily
- * remove it from the list of callbacks.
- */
- Assert(error_context_stack->callback == plpgsql_compile_error_callback);
+ cbarg.location = location;
+ cbarg.leaderlen = leaderlen;
- previous_errcontext = error_context_stack;
syntax_errcontext.callback = plpgsql_sql_error_callback;
- syntax_errcontext.arg = (char *) stmt;
- syntax_errcontext.previous = error_context_stack->previous;
+ syntax_errcontext.arg = &cbarg;
+ syntax_errcontext.previous = error_context_stack;
error_context_stack = &syntax_errcontext;
oldCxt = MemoryContextSwitchTo(compile_tmp_cxt);
MemoryContextSwitchTo(oldCxt);
/* Restore former ereport callback */
- error_context_stack = previous_errcontext;
+ error_context_stack = syntax_errcontext.previous;
}
static void
plpgsql_sql_error_callback(void *arg)
{
- char *sql_stmt = (char *) arg;
+ sql_error_callback_arg *cbarg = (sql_error_callback_arg *) arg;
+ int errpos;
- Assert(plpgsql_error_funcname);
+ /*
+ * First, set up internalerrposition to point to the start of the
+ * statement text within the function text. Note this converts
+ * location (a byte offset) to a character number.
+ */
+ parser_errposition(cbarg->location);
- errcontext("SQL statement in PL/PgSQL function \"%s\" near line %d",
- plpgsql_error_funcname, plpgsql_error_lineno);
- internalerrquery(sql_stmt);
- internalerrposition(geterrposition());
+ /*
+ * If the core parser provided an error position, transpose it.
+ * Note we are dealing with 1-based character numbers at this point.
+ */
+ errpos = geterrposition();
+ if (errpos > cbarg->leaderlen)
+ {
+ int myerrpos = getinternalerrposition();
+
+ if (myerrpos > 0) /* safety check */
+ internalerrposition(myerrpos + errpos - cbarg->leaderlen - 1);
+ }
+
+ /* In any case, flush errposition --- we want internalerrpos only */
errposition(0);
}
/*
+ * Parse a SQL datatype name and produce a PLpgSQL_type structure.
+ *
+ * The heavy lifting is done elsewhere. Here we are only concerned
+ * with setting up an errcontext link that will let us give an error
+ * cursor pointing into the plpgsql function source, if necessary.
+ * This is handled the same as in check_sql_expr(), and we likewise
+ * expect that the given string is a copy from the source text.
+ */
+static PLpgSQL_type *
+parse_datatype(const char *string, int location)
+{
+ Oid type_id;
+ int32 typmod;
+ sql_error_callback_arg cbarg;
+ ErrorContextCallback syntax_errcontext;
+
+ cbarg.location = location;
+ cbarg.leaderlen = 0;
+
+ syntax_errcontext.callback = plpgsql_sql_error_callback;
+ syntax_errcontext.arg = &cbarg;
+ syntax_errcontext.previous = error_context_stack;
+ error_context_stack = &syntax_errcontext;
+
+ /* Let the main parser try to parse it under standard SQL rules */
+ parseTypeString(string, &type_id, &typmod);
+
+ /* Restore former ereport callback */
+ error_context_stack = syntax_errcontext.previous;
+
+ /* Okay, build a PLpgSQL_type data structure for it */
+ return plpgsql_build_datatype(type_id, typmod);
+}
+
+/*
* Convert a string-literal token to the represented string value.
*
* To do this, we need to invoke the core lexer. Here we are only concerned
- * with setting up the right errcontext state, which is handled the same as
+ * with setting up an errcontext link, which is handled the same as
* in check_sql_expr().
*/
static char *
-parse_string_token(const char *token)
+parse_string_token(const char *token, int location)
{
char *result;
+ sql_error_callback_arg cbarg;
ErrorContextCallback syntax_errcontext;
- ErrorContextCallback *previous_errcontext;
- /* See comments in check_sql_expr() */
- Assert(error_context_stack->callback == plpgsql_compile_error_callback);
+ cbarg.location = location;
+ cbarg.leaderlen = 0;
- previous_errcontext = error_context_stack;
- syntax_errcontext.callback = plpgsql_string_error_callback;
- syntax_errcontext.arg = (char *) token;
- syntax_errcontext.previous = error_context_stack->previous;
+ syntax_errcontext.callback = plpgsql_sql_error_callback;
+ syntax_errcontext.arg = &cbarg;
+ syntax_errcontext.previous = error_context_stack;
error_context_stack = &syntax_errcontext;
result = pg_parse_string_token(token);
/* Restore former ereport callback */
- error_context_stack = previous_errcontext;
+ error_context_stack = syntax_errcontext.previous;
return result;
}
-static void
-plpgsql_string_error_callback(void *arg)
-{
- Assert(plpgsql_error_funcname);
-
- errcontext("string literal in PL/PgSQL function \"%s\" near line %d",
- plpgsql_error_funcname, plpgsql_error_lineno);
- /* representing the string literal as internalquery seems overkill */
- errposition(0);
-}
-
static char *
check_label(const char *yytxt)
{
}
static void
-check_labels(const char *start_label, const char *end_label)
+check_labels(const char *start_label, const char *end_label, int end_location)
{
if (end_label)
{
if (!start_label)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("end label \"%s\" specified for unlabelled block",
- end_label)));
- }
+ end_label),
+ parser_errposition(end_location)));
if (strcmp(start_label, end_label) != 0)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("end label \"%s\" differs from block's label \"%s\"",
- end_label, start_label)));
- }
+ end_label, start_label),
+ parser_errposition(end_location)));
}
}
{
PLpgSQL_expr *expr;
int tok;
- char *cp;
tok = yylex();
if (cursor->cursor_explicit_argrow < 0)
{
/* No arguments expected */
if (tok == '(')
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cursor \"%s\" has no arguments",
- cursor->refname)));
- }
+ cursor->refname),
+ parser_errposition(yylloc)));
if (tok != until)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
- ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("syntax error at \"%s\"",
- yytext)));
- }
+ yyerror("syntax error");
return NULL;
}
/* Else better provide arguments */
if (tok != '(')
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cursor \"%s\" has arguments",
- cursor->refname)));
- }
-
- /*
- * Push back the '(', else plpgsql_read_expression
- * will complain about unbalanced parens.
- */
- plpgsql_push_back_token(tok);
-
- expr = plpgsql_read_expression(until, expected);
+ cursor->refname),
+ parser_errposition(yylloc)));
/*
- * Now remove the leading and trailing parens,
- * because we want "SELECT 1, 2", not "SELECT (1, 2)".
+ * Read expressions until the matching ')'.
*/
- cp = expr->query;
+ expr = plpgsql_read_expression(')', ")");
- if (strncmp(cp, "SELECT", 6) != 0)
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
- /* internal error */
- elog(ERROR, "expected \"SELECT (\", got \"%s\"", expr->query);
- }
- cp += 6;
- while (*cp == ' ') /* could be more than 1 space here */
- cp++;
- if (*cp != '(')
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
- /* internal error */
- elog(ERROR, "expected \"SELECT (\", got \"%s\"", expr->query);
- }
- *cp = ' ';
-
- cp += strlen(cp) - 1;
-
- if (*cp != ')')
- yyerror("expected \")\"");
- *cp = '\0';
+ /* Next we'd better find the until token */
+ tok = yylex();
+ if (tok != until)
+ yyerror("syntax error");
return expr;
}
else if (pg_strcasecmp(yytext, "hint") == 0)
opt->opt_type = PLPGSQL_RAISEOPTION_HINT;
else
- {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unrecognized RAISE statement option \"%s\"",
- yytext)));
- }
+ yytext),
+ parser_errposition(yylloc)));
if (yylex() != K_ASSIGN)
yyerror("syntax error, expected \"=\"");
* Fix up CASE statement
*/
static PLpgSQL_stmt *
-make_case(int lineno, PLpgSQL_expr *t_expr,
+make_case(int location, PLpgSQL_expr *t_expr,
List *case_when_list, List *else_stmts)
{
PLpgSQL_stmt_case *new;
new = palloc(sizeof(PLpgSQL_stmt_case));
new->cmd_type = PLPGSQL_STMT_CASE;
- new->lineno = lineno;
+ new->lineno = plpgsql_location_to_lineno(location);
new->t_expr = t_expr;
new->t_varno = 0;
new->case_when_list = case_when_list;
* variable as if it were INT4; we'll fix this at runtime if needed.
*/
t_var = (PLpgSQL_var *)
- plpgsql_build_variable(varname, lineno,
+ plpgsql_build_variable(varname, new->lineno,
plpgsql_build_datatype(INT4OID, -1),
true);
new->t_varno = t_var->dno;
%{
/*-------------------------------------------------------------------------
*
- * scan.l - Scanner for the PL/pgSQL
- * procedural language
+ * scan.l - Scanner for the PL/pgSQL procedural language
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/pl/plpgsql/src/scan.l,v 1.74 2009/11/07 00:52:26 tgl Exp $
+ * $PostgreSQL: pgsql/src/pl/plpgsql/src/scan.l,v 1.75 2009/11/09 00:26:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define fprintf(file, fmt, msg) ereport(ERROR, (errmsg_internal("%s", msg)))
/*
+ * Each call to yylex must set yylloc to the location of the found token
+ * (expressed as a byte offset from the start of the input text).
* When we parse a token that requires multiple lexer rules to process,
- * remember the token's starting position this way.
+ * this should be done in the first such rule, else yylloc will point
+ * into the middle of the token.
*/
-#define SAVE_TOKEN_START() \
- ( start_lineno = plpgsql_scanner_lineno(), start_charpos = yytext )
+#define SET_YYLLOC() (yylloc = yytext - scanbuf)
/* Handles to the buffer that the lexer uses internally */
static YY_BUFFER_STATE scanbufhandle;
static char *scanbuf;
-static const char *scanstr; /* original input string */
+static const char *scanorig; /* original input string */
static int pushback_token;
static bool have_pushback_token;
static const char *cur_line_start;
+static const char *cur_line_end;
static int cur_line_num;
static int xcdepth = 0; /* depth of nesting in slash-star comments */
static char *dolqstart; /* current $foo$ quote start string */
bool plpgsql_LookupIdentifiers = true;
-bool plpgsql_SpaceScanned = false;
+
+static void location_lineno_init(void);
+
%}
%option 8bit
%option noinput
%option nounput
%option noyywrap
+%option noyyalloc
+%option noyyrealloc
+%option noyyfree
+%option warn
%option prefix="plpgsql_base_yy"
%option case-insensitive
%%
/* ----------
- * Local variables in scanner to remember where
- * a string or comment started
- * ----------
- */
- int start_lineno = 0;
- char *start_charpos = NULL;
-
- /* ----------
- * Reset the state when entering the scanner
+ * Reset the state when entering yylex()
* ----------
*/
BEGIN(INITIAL);
- plpgsql_SpaceScanned = false;
/* ----------
* The keyword rules
* ----------
*/
-:= { return K_ASSIGN; }
-= { return K_ASSIGN; }
-\.\. { return K_DOTDOT; }
-alias { return K_ALIAS; }
-all { return K_ALL; }
-begin { return K_BEGIN; }
-by { return K_BY; }
-case { return K_CASE; }
-close { return K_CLOSE; }
-constant { return K_CONSTANT; }
-continue { return K_CONTINUE; }
-cursor { return K_CURSOR; }
-declare { return K_DECLARE; }
-default { return K_DEFAULT; }
-diagnostics { return K_DIAGNOSTICS; }
-else { return K_ELSE; }
-elseif { return K_ELSIF; }
-elsif { return K_ELSIF; }
-end { return K_END; }
-exception { return K_EXCEPTION; }
-execute { return K_EXECUTE; }
-exit { return K_EXIT; }
-fetch { return K_FETCH; }
-for { return K_FOR; }
-from { return K_FROM; }
-get { return K_GET; }
-if { return K_IF; }
-in { return K_IN; }
-insert { return K_INSERT; }
-into { return K_INTO; }
-is { return K_IS; }
-loop { return K_LOOP; }
-move { return K_MOVE; }
-no{space}+scroll { return K_NOSCROLL; }
-not { return K_NOT; }
-null { return K_NULL; }
-open { return K_OPEN; }
-or { return K_OR; }
-perform { return K_PERFORM; }
-raise { return K_RAISE; }
-result_oid { return K_RESULT_OID; }
-return { return K_RETURN; }
-reverse { return K_REVERSE; }
-row_count { return K_ROW_COUNT; }
-scroll { return K_SCROLL; }
-strict { return K_STRICT; }
-then { return K_THEN; }
-to { return K_TO; }
-type { return K_TYPE; }
-using { return K_USING; }
-when { return K_WHEN; }
-while { return K_WHILE; }
-
-^#option { return O_OPTION; }
-dump { return O_DUMP; }
+:= { SET_YYLLOC(); return K_ASSIGN; }
+= { SET_YYLLOC(); return K_ASSIGN; }
+\.\. { SET_YYLLOC(); return K_DOTDOT; }
+alias { SET_YYLLOC(); return K_ALIAS; }
+all { SET_YYLLOC(); return K_ALL; }
+begin { SET_YYLLOC(); return K_BEGIN; }
+by { SET_YYLLOC(); return K_BY; }
+case { SET_YYLLOC(); return K_CASE; }
+close { SET_YYLLOC(); return K_CLOSE; }
+constant { SET_YYLLOC(); return K_CONSTANT; }
+continue { SET_YYLLOC(); return K_CONTINUE; }
+cursor { SET_YYLLOC(); return K_CURSOR; }
+declare { SET_YYLLOC(); return K_DECLARE; }
+default { SET_YYLLOC(); return K_DEFAULT; }
+diagnostics { SET_YYLLOC(); return K_DIAGNOSTICS; }
+else { SET_YYLLOC(); return K_ELSE; }
+elseif { SET_YYLLOC(); return K_ELSIF; }
+elsif { SET_YYLLOC(); return K_ELSIF; }
+end { SET_YYLLOC(); return K_END; }
+exception { SET_YYLLOC(); return K_EXCEPTION; }
+execute { SET_YYLLOC(); return K_EXECUTE; }
+exit { SET_YYLLOC(); return K_EXIT; }
+fetch { SET_YYLLOC(); return K_FETCH; }
+for { SET_YYLLOC(); return K_FOR; }
+from { SET_YYLLOC(); return K_FROM; }
+get { SET_YYLLOC(); return K_GET; }
+if { SET_YYLLOC(); return K_IF; }
+in { SET_YYLLOC(); return K_IN; }
+insert { SET_YYLLOC(); return K_INSERT; }
+into { SET_YYLLOC(); return K_INTO; }
+is { SET_YYLLOC(); return K_IS; }
+loop { SET_YYLLOC(); return K_LOOP; }
+move { SET_YYLLOC(); return K_MOVE; }
+no{space}+scroll { SET_YYLLOC(); return K_NOSCROLL; }
+not { SET_YYLLOC(); return K_NOT; }
+null { SET_YYLLOC(); return K_NULL; }
+open { SET_YYLLOC(); return K_OPEN; }
+or { SET_YYLLOC(); return K_OR; }
+perform { SET_YYLLOC(); return K_PERFORM; }
+raise { SET_YYLLOC(); return K_RAISE; }
+result_oid { SET_YYLLOC(); return K_RESULT_OID; }
+return { SET_YYLLOC(); return K_RETURN; }
+reverse { SET_YYLLOC(); return K_REVERSE; }
+row_count { SET_YYLLOC(); return K_ROW_COUNT; }
+scroll { SET_YYLLOC(); return K_SCROLL; }
+strict { SET_YYLLOC(); return K_STRICT; }
+then { SET_YYLLOC(); return K_THEN; }
+to { SET_YYLLOC(); return K_TO; }
+type { SET_YYLLOC(); return K_TYPE; }
+using { SET_YYLLOC(); return K_USING; }
+when { SET_YYLLOC(); return K_WHEN; }
+while { SET_YYLLOC(); return K_WHILE; }
+
+^#option { SET_YYLLOC(); return O_OPTION; }
+dump { SET_YYLLOC(); return O_DUMP; }
/* ----------
* Special word rules
- *
- * We set plpgsql_error_lineno in each rule so that errors reported
- * in the pl_comp.c subroutines will point to the right place.
* ----------
*/
{identifier} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_WORD;
return plpgsql_parse_word(yytext); }
{identifier}{space}*\.{space}*{identifier} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_DBLWORD;
return plpgsql_parse_dblword(yytext); }
{identifier}{space}*\.{space}*{identifier}{space}*\.{space}*{identifier} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_TRIPWORD;
return plpgsql_parse_tripword(yytext); }
{param} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_WORD;
return plpgsql_parse_word(yytext); }
{param}{space}*\.{space}*{identifier} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_DBLWORD;
return plpgsql_parse_dblword(yytext); }
{param}{space}*\.{space}*{identifier}{space}*\.{space}*{identifier} {
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+ SET_YYLLOC();
if (!plpgsql_LookupIdentifiers) return T_TRIPWORD;
return plpgsql_parse_tripword(yytext); }
-{digit}+ { return T_NUMBER; }
+{digit}+ { SET_YYLLOC(); return T_NUMBER; }
-\". { yyerror("unterminated quoted identifier"); }
-
- /* ----------
- * Ignore whitespace (including comments) but remember this happened
- * ----------
- */
-{whitespace} { plpgsql_SpaceScanned = true; }
+\". { SET_YYLLOC(); yyerror("unterminated quoted identifier"); }
/* ----------
* Comment and literal handling is mostly copied from the core lexer
* ----------
*/
+{whitespace} {
+ /* ignore */
+ }
+
{xcstart} {
- /* Set location in case of syntax error in comment */
- SAVE_TOKEN_START();
+ SET_YYLLOC();
xcdepth = 0;
BEGIN(xc);
- plpgsql_SpaceScanned = true;
}
<xc>{xcstart} {
<xc><<EOF>> { yyerror("unterminated /* comment"); }
{xqstart} {
- SAVE_TOKEN_START();
+ SET_YYLLOC();
if (standard_conforming_strings)
BEGIN(xq);
else
BEGIN(xe);
}
{xestart} {
- SAVE_TOKEN_START();
+ SET_YYLLOC();
BEGIN(xe);
}
<xq,xe>{quotestop} |
yyless(1);
BEGIN(INITIAL);
/* adjust yytext/yyleng to describe whole string token */
- yyleng += (yytext - start_charpos);
- yytext = start_charpos;
+ yyleng += (yytext - (scanbuf + yylloc));
+ yytext = scanbuf + yylloc;
return T_STRING;
}
<xq,xe>{xqdouble} {
<xq,xe><<EOF>> { yyerror("unterminated quoted string"); }
{dolqdelim} {
- SAVE_TOKEN_START();
+ SET_YYLLOC();
dolqstart = pstrdup(yytext);
BEGIN(xdolq);
}
/* throw back all but the initial "$" */
yyless(1);
/* and treat it as {other} */
- return yytext[0];
+ SET_YYLLOC(); return yytext[0];
}
<xdolq>{dolqdelim} {
if (strcmp(yytext, dolqstart) == 0)
pfree(dolqstart);
BEGIN(INITIAL);
/* adjust yytext/yyleng to describe whole string */
- yyleng += (yytext - start_charpos);
- yytext = start_charpos;
+ yyleng += (yytext - (scanbuf + yylloc));
+ yytext = scanbuf + yylloc;
return T_STRING;
}
else
* ----------
*/
. {
- return yytext[0];
+ SET_YYLLOC(); return yytext[0];
}
%%
/*
* This is the yylex routine called from outside. It exists to provide
- * a one-token pushback facility. Beware of trying to make it do more:
- * for the most part, plpgsql's gram.y assumes that yytext is in step
- * with the "current token".
+ * a one-token pushback facility. Beware of trying to push back more;
+ * for the most part, plpgsql's gram.y assumes that yytext and yylloc
+ * are in step with the "current token". In particular it is assumed that
+ * those are in step with the result immediately after any yylex() call.
*/
int
plpgsql_yylex(void)
/*
* Push back a single token to be re-read by next plpgsql_yylex() call.
*
- * NOTE: this does not cause yytext to "back up".
+ * NOTE: this does not cause yytext or yylloc to "back up". Also, it
+ * is not a good idea to push back a token other than what you read.
*/
void
plpgsql_push_back_token(int token)
}
/*
- * Report a syntax error.
+ * Append the function text starting at startlocation and extending to
+ * (not including) endlocation onto the existing contents of "buf".
*/
void
-plpgsql_yyerror(const char *message)
+plpgsql_append_source_text(StringInfo buf,
+ int startlocation, int endlocation)
{
- const char *loc = yytext;
- int cursorpos;
+ Assert(startlocation <= endlocation);
+ appendBinaryStringInfo(buf, scanorig + startlocation,
+ endlocation - startlocation);
+}
- plpgsql_error_lineno = plpgsql_scanner_lineno();
+/*
+ * plpgsql_scanner_errposition
+ * Report an error cursor position, if possible.
+ *
+ * This is expected to be used within an ereport() call. The return value
+ * is a dummy (always 0, in fact).
+ *
+ * Note that this can only be used for messages emitted during initial
+ * parsing of a plpgsql function, since it requires the scanorig string
+ * to still be available.
+ */
+int
+plpgsql_scanner_errposition(int location)
+{
+ int pos;
- /* in multibyte encodings, return index in characters not bytes */
- cursorpos = pg_mbstrlen_with_len(scanbuf, loc - scanbuf) + 1;
+ if (location < 0 || scanorig == NULL)
+ return 0; /* no-op if location is unknown */
+
+ /* Convert byte offset to character number */
+ pos = pg_mbstrlen_with_len(scanorig, location) + 1;
+ /* And pass it to the ereport mechanism */
+ (void) internalerrposition(pos);
+ /* Also pass the function body string */
+ return internalerrquery(scanorig);
+}
+
+/*
+ * plpgsql_yyerror
+ * Report a lexer or grammar error.
+ *
+ * The message's cursor position is whatever YYLLOC was last set to,
+ * ie, the start of the current token if called within yylex(), or the
+ * most recently lexed token if called from the grammar.
+ * This is OK for syntax error messages from the Bison parser, because Bison
+ * parsers report error as soon as the first unparsable token is reached.
+ * Beware of using yyerror for other purposes, as the cursor position might
+ * be misleading!
+ */
+void
+plpgsql_yyerror(const char *message)
+{
+ const char *loc = scanbuf + yylloc;
if (*loc == YY_END_OF_BUFFER_CHAR)
{
(errcode(ERRCODE_SYNTAX_ERROR),
/* translator: %s is typically the translation of "syntax error" */
errmsg("%s at end of input", _(message)),
- internalerrposition(cursorpos),
- internalerrquery(scanstr)));
+ plpgsql_scanner_errposition(yylloc)));
}
else
{
(errcode(ERRCODE_SYNTAX_ERROR),
/* translator: first %s is typically the translation of "syntax error" */
errmsg("%s at or near \"%s\"", _(message), loc),
- internalerrposition(cursorpos),
- internalerrquery(scanstr)));
+ plpgsql_scanner_errposition(yylloc)));
}
}
/*
- * Get the line number at which the current token ends. This substitutes
- * for flex's very poorly implemented yylineno facility.
+ * Given a location (a byte offset in the function source text),
+ * return a line number.
*
- * We assume that flex has written a '\0' over the character following the
- * current token in scanbuf. So, we just have to count the '\n' characters
- * before that. We optimize this a little by keeping track of the last
- * '\n' seen so far.
+ * We expect that this is typically called for a sequence of increasing
+ * location values, so optimize accordingly by tracking the endpoints
+ * of the "current" line.
*/
int
-plpgsql_scanner_lineno(void)
+plpgsql_location_to_lineno(int location)
{
- const char *c;
+ const char *loc;
+
+ if (location < 0 || scanorig == NULL)
+ return 0; /* garbage in, garbage out */
+ loc = scanorig + location;
- while ((c = strchr(cur_line_start, '\n')) != NULL)
+ /* be correct, but not fast, if input location goes backwards */
+ if (loc < cur_line_start)
+ location_lineno_init();
+
+ while (cur_line_end != NULL && loc > cur_line_end)
{
- cur_line_start = c + 1;
+ cur_line_start = cur_line_end + 1;
cur_line_num++;
+ cur_line_end = strchr(cur_line_start, '\n');
}
+
+ return cur_line_num;
+}
+
+/* initialize or reset the state for plpgsql_location_to_lineno */
+static void
+location_lineno_init(void)
+{
+ cur_line_start = scanorig;
+ cur_line_num = 1;
+
+ /*----------
+ * Hack: skip any initial newline, so that in the common coding layout
+ * CREATE FUNCTION ... AS $$
+ * code body
+ * $$ LANGUAGE plpgsql;
+ * we will think "line 1" is what the programmer thinks of as line 1.
+ *----------
+ */
+ if (*cur_line_start == '\r')
+ cur_line_start++;
+ if (*cur_line_start == '\n')
+ cur_line_start++;
+
+ cur_line_end = strchr(cur_line_start, '\n');
+}
+
+/* return the most recently computed lineno */
+int
+plpgsql_latest_lineno(void)
+{
return cur_line_num;
}
+
/*
* Called before any actual parsing is done
*
void
plpgsql_scanner_init(const char *str)
{
- Size slen;
-
- slen = strlen(str);
+ Size slen = strlen(str);
/*
- * Might be left over after ereport()
+ * Reset flex internal state. Whatever data it might think it has
+ * has long since been pfree'd.
*/
- if (YY_CURRENT_BUFFER)
- yy_delete_buffer(YY_CURRENT_BUFFER);
+ yy_init_globals();
/*
* Make a scan buffer with special termination needed by flex.
*/
- scanbuf = palloc(slen + 2);
+ scanbuf = (char *) palloc(slen + 2);
memcpy(scanbuf, str, slen);
scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
scanbufhandle = yy_scan_buffer(scanbuf, slen + 2);
- /* Other setup */
- scanstr = str;
+ /*
+ * scanorig points to the original string, which unlike scanbuf won't
+ * be modified on-the-fly by flex. Notice that although yytext points
+ * into scanbuf, we rely on being able to apply locations (offsets from
+ * string start) to scanorig as well.
+ */
+ scanorig = str;
+ /* Other setup */
have_pushback_token = false;
- cur_line_start = scanbuf;
- cur_line_num = 1;
-
- /*----------
- * Hack: skip any initial newline, so that in the common coding layout
- * CREATE FUNCTION ... AS '
- * code body
- * ' LANGUAGE plpgsql;
- * we will think "line 1" is what the programmer thinks of as line 1.
- *----------
- */
- if (*cur_line_start == '\r')
- cur_line_start++;
- if (*cur_line_start == '\n')
- cur_line_start++;
+ location_lineno_init();
BEGIN(INITIAL);
plpgsql_LookupIdentifiers = true;
- plpgsql_SpaceScanned = false;
}
/*
void
plpgsql_scanner_finish(void)
{
+ /* release storage */
yy_delete_buffer(scanbufhandle);
pfree(scanbuf);
+ /* avoid leaving any dangling pointers */
+ scanbufhandle = NULL;
+ scanbuf = NULL;
+ scanorig = NULL;
+}
+
+/*
+ * Interface functions to make flex use palloc() instead of malloc().
+ * It'd be better to make these static, but flex insists otherwise.
+ */
+
+void *
+plpgsql_base_yyalloc(yy_size_t bytes)
+{
+ return palloc(bytes);
+}
+
+void *
+plpgsql_base_yyrealloc(void *ptr, yy_size_t bytes)
+{
+ if (ptr)
+ return repalloc(ptr, bytes);
+ else
+ return palloc(bytes);
+}
+
+void
+plpgsql_base_yyfree(void *ptr)
+{
+ if (ptr)
+ pfree(ptr);
}
OSDN Git Service
