* The value turned out to be a point, ie. all the upper-right
* coordinates were equal to the lower-left coordinates. Resize the
* cube we constructed. Note: we don't bother to repalloc() it
- * smaller, as it's unlikely that the tiny amount of memory freed
- * that way would be useful, and the output is always short-lived.
+ * smaller, as it's unlikely that the tiny amount of memory freed that
+ * way would be useful, and the output is always short-lived.
*/
size = POINT_SIZE(dim);
SET_VARSIZE(bp, size);
write_point_as_box(int dim, char *str,
NDBOX **result, struct Node *escontext)
{
- NDBOX *bp;
+ NDBOX *bp;
int i,
size;
char *s;
yyscan_t yyscanner,
const char *message)
{
- struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
+ struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
+ * macro */
if (*yytext == YY_END_OF_BUFFER_CHAR)
{
errsave(escontext,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for cube"),
- /* translator: %s is typically "syntax error" */
+ /* translator: %s is typically "syntax error" */
errdetail("%s at end of input", message)));
}
else
errsave(escontext,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for cube"),
- /* translator: first %s is typically "syntax error" */
+ /* translator: first %s is typically "syntax error" */
errdetail("%s at or near \"%s\"", message, yytext)));
}
}
void
seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char *message)
{
- struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
+ struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
+ * macro */
/* if we already reported an error, don't overwrite it */
if (SOFT_ERROR_OCCURRED(escontext))
errsave(escontext,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("bad seg representation"),
- /* translator: %s is typically "syntax error" */
+ /* translator: %s is typically "syntax error" */
errdetail("%s at end of input", message)));
}
else
errsave(escontext,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("bad seg representation"),
- /* translator: first %s is typically "syntax error" */
+ /* translator: first %s is typically "syntax error" */
errdetail("%s at or near \"%s\"", message, yytext)));
}
}
void
seg_scanner_init(const char *str, yyscan_t *yyscannerp)
{
- yyscan_t yyscanner;
+ yyscan_t yyscanner;
if (yylex_init(yyscannerp) != 0)
elog(ERROR, "yylex_init() failed: %m");
void
boot_yyerror(yyscan_t yyscanner, const char *message)
{
- struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yylineno macro */
+ struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yylineno
+ * macro */
elog(ERROR, "%s at line %d", message, yylineno);
}
void
yyfree(void *ptr, yyscan_t yyscanner)
{
- if (ptr)
- pfree(ptr);
+ if (ptr)
+ pfree(ptr);
}
{
if (IsA(n, SelectStmt))
{
- SelectStmt *stmt = (SelectStmt *)n;
+ SelectStmt *stmt = (SelectStmt *) n;
stmt->stmt_len = end_location - stmt->stmt_location;
}
else if (IsA(n, InsertStmt))
{
- InsertStmt *stmt = (InsertStmt *)n;
+ InsertStmt *stmt = (InsertStmt *) n;
stmt->stmt_len = end_location - stmt->stmt_location;
}
else if (IsA(n, UpdateStmt))
{
- UpdateStmt *stmt = (UpdateStmt *)n;
+ UpdateStmt *stmt = (UpdateStmt *) n;
stmt->stmt_len = end_location - stmt->stmt_location;
}
else if (IsA(n, DeleteStmt))
{
- DeleteStmt *stmt = (DeleteStmt *)n;
+ DeleteStmt *stmt = (DeleteStmt *) n;
stmt->stmt_len = end_location - stmt->stmt_location;
}
else if (IsA(n, MergeStmt))
{
- MergeStmt *stmt = (MergeStmt *)n;
+ MergeStmt *stmt = (MergeStmt *) n;
stmt->stmt_len = end_location - stmt->stmt_location;
}
int location, core_yyscan_t yyscanner)
{
/*
- * Generate a ColumnRef node, with an A_Indirection node added if there
- * is any subscripting in the specified indirection list. However,
- * any field selection at the start of the indirection list must be
- * transposed into the "fields" part of the ColumnRef node.
+ * Generate a ColumnRef node, with an A_Indirection node added if there is
+ * any subscripting in the specified indirection list. However, any field
+ * selection at the start of the indirection list must be transposed into
+ * the "fields" part of the ColumnRef node.
*/
ColumnRef *c = makeNode(ColumnRef);
int nfields = 0;
static Node *
makeIntConst(int val, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.ival.type = T_Integer;
n->val.ival.ival = val;
n->location = location;
- return (Node *) n;
+ return (Node *) n;
}
static Node *
makeFloatConst(char *str, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.fval.type = T_Float;
n->val.fval.fval = str;
n->location = location;
- return (Node *) n;
+ return (Node *) n;
}
static Node *
makeBoolAConst(bool state, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.boolval.type = T_Boolean;
n->val.boolval.boolval = state;
n->location = location;
- return (Node *) n;
+ return (Node *) n;
}
static Node *
makeBitStringConst(char *str, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.bsval.type = T_BitString;
n->val.bsval.bsval = str;
n->location = location;
- return (Node *) n;
+ return (Node *) n;
}
static Node *
makeNullAConst(int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->isnull = true;
n->location = location;
static List *
check_indirection(List *indirection, core_yyscan_t yyscanner)
{
- ListCell *l;
+ ListCell *l;
foreach(l, indirection)
{
core_yyscan_t yyscanner)
{
FunctionParameter *lastd = (FunctionParameter *) llast(directargs);
- Integer *ndirectargs;
+ Integer *ndirectargs;
/* No restriction unless last direct arg is VARIADIC */
if (lastd->mode == FUNC_PARAM_VARIADIC)
FunctionParameter *firsto = (FunctionParameter *) linitial(orderedargs);
/*
- * We ignore the names, though the aggr_arg production allows them;
- * it doesn't allow default values, so those need not be checked.
+ * We ignore the names, though the aggr_arg production allows them; it
+ * doesn't allow default values, so those need not be checked.
*/
if (list_length(orderedargs) != 1 ||
firsto->mode != FUNC_PARAM_VARIADIC ||
{
if (IsA(n, A_Const))
{
- A_Const *con = (A_Const *) n;
+ A_Const *con = (A_Const *) n;
/* report the constant's location as that of the '-' sign */
con->location = location;
if (*oldval == '+')
oldval++;
if (*oldval == '-')
- v->fval = oldval+1; /* just strip the '-' */
+ v->fval = oldval + 1; /* just strip the '-' */
else
v->fval = psprintf("-%s", oldval);
}
makeXmlExpr(XmlExprOp op, char *name, List *named_args, List *args,
int location)
{
- XmlExpr *x = makeNode(XmlExpr);
+ XmlExpr *x = makeNode(XmlExpr);
x->op = op;
x->name = name;
+
/*
* named_args is a list of ResTarget; it'll be split apart into separate
* expression and name lists in transformXmlExpr().
x->args = args;
/* xmloption, if relevant, must be filled in by caller */
/* type and typmod will be filled in during parse analysis */
- x->type = InvalidOid; /* marks the node as not analyzed */
+ x->type = InvalidOid; /* marks the node as not analyzed */
x->location = location;
return (Node *) x;
}
errcode(ERRCODE_SYNTAX_ERROR),
errmsg("improper qualified name (too many dotted names): %s",
NameListToString(lcons(makeString(name), namelist))),
- parser_errposition(location));
+ parser_errposition(location));
break;
}
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is CHECK, UNIQUE, or similar */
+ /* translator: %s is CHECK, UNIQUE, or similar */
errmsg("%s constraints cannot be marked DEFERRABLE",
constrType),
parser_errposition(location)));
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is CHECK, UNIQUE, or similar */
+ /* translator: %s is CHECK, UNIQUE, or similar */
errmsg("%s constraints cannot be marked DEFERRABLE",
constrType),
parser_errposition(location)));
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is CHECK, UNIQUE, or similar */
+ /* translator: %s is CHECK, UNIQUE, or similar */
errmsg("%s constraints cannot be marked NOT VALID",
constrType),
parser_errposition(location)));
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is CHECK, UNIQUE, or similar */
+ /* translator: %s is CHECK, UNIQUE, or similar */
errmsg("%s constraints cannot be marked NO INHERIT",
constrType),
parser_errposition(location)));
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized partitioning strategy \"%s\"", strategy),
parser_errposition(location)));
- return PARTITION_STRATEGY_LIST; /* keep compiler quiet */
+ return PARTITION_STRATEGY_LIST; /* keep compiler quiet */
}
parser_errposition(pubobj->location));
/*
- * We can distinguish between the different type of schema
- * objects based on whether name and pubtable is set.
+ * We can distinguish between the different type of schema objects
+ * based on whether name and pubtable is set.
*/
if (pubobj->name)
pubobj->pubobjtype = PUBLICATIONOBJ_TABLES_IN_SCHEMA;
w->ctes = list_make1(cte);
w->location = -1;
- /* create target list for the new SELECT from the alias list of the
- * recursive view specification */
- foreach (lc, aliases)
+ /*
+ * create target list for the new SELECT from the alias list of the
+ * recursive view specification
+ */
+ foreach(lc, aliases)
{
- ResTarget *rt = makeNode(ResTarget);
+ ResTarget *rt = makeNode(ResTarget);
rt->name = NULL;
rt->indirection = NIL;
tl = lappend(tl, rt);
}
- /* create new SELECT combining WITH clause, target list, and fake FROM
- * clause */
+ /*
+ * create new SELECT combining WITH clause, target list, and fake FROM
+ * clause
+ */
s->withClause = w;
s->targetList = tl;
s->fromClause = list_make1(makeRangeVar(NULL, relname, -1));
ereport(WARNING,
(errcode(ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
errmsg("nonstandard use of escape in a string literal"),
- errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
+ errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
lexer_errposition()));
- yyextra->warn_on_first_escape = false; /* warn only once per string */
+ yyextra->warn_on_first_escape = false; /* warn only once per string */
}
/*
void
yyfree(void *ptr, yyscan_t yyscanner)
{
- if (ptr)
- pfree(ptr);
+ if (ptr)
+ pfree(ptr);
}
void
syncrep_yyerror(yyscan_t yyscanner, const char *message)
{
- struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
+ struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
+ * macro */
/* report only the first error in a parse operation */
if (syncrep_parse_error_msg)
static bool
makeItemLikeRegex(JsonPathParseItem *expr, JsonPathString *pattern,
- JsonPathString *flags, JsonPathParseItem ** result,
+ JsonPathString *flags, JsonPathParseItem **result,
struct Node *escontext)
{
JsonPathParseItem *v = makeItemType(jpiLikeRegex);
}
/* Convert flags to what pg_regcomp needs */
- if ( !jspConvertRegexFlags(v->value.like_regex.flags, &cflags, escontext))
- return false;
+ if (!jspConvertRegexFlags(v->value.like_regex.flags, &cflags, escontext))
+ return false;
/* check regex validity */
{
- regex_t re_tmp;
+ regex_t re_tmp;
pg_wchar *wpattern;
- int wpattern_len;
- int re_result;
+ int wpattern_len;
+ int re_result;
wpattern = (pg_wchar *) palloc((pattern->len + 1) * sizeof(pg_wchar));
wpattern_len = pg_mb2wchar_with_len(pattern->val,
if ((re_result = pg_regcomp(&re_tmp, wpattern, wpattern_len, cflags,
DEFAULT_COLLATION_OID)) != REG_OKAY)
{
- char errMsg[100];
+ char errMsg[100];
pg_regerror(re_result, &re_tmp, errMsg, sizeof(errMsg));
ereturn(escontext, false,
yyscan_t yyscanner,
const char *message)
{
- struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
+ struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
+ * macro */
/* don't overwrite escontext if it's already been set */
if (SOFT_ERROR_OCCURRED(escontext))
{
errsave(escontext,
(errcode(ERRCODE_SYNTAX_ERROR),
- /* translator: %s is typically "syntax error" */
+ /* translator: %s is typically "syntax error" */
errmsg("%s at end of jsonpath input", _(message))));
}
else
{
errsave(escontext,
(errcode(ERRCODE_SYNTAX_ERROR),
- /* translator: first %s is typically "syntax error" */
+ /* translator: first %s is typically "syntax error" */
errmsg("%s at or near \"%s\" of jsonpath input",
_(message), yytext)));
}
* alphabetical order
*/
static const JsonPathKeyword keywords[] = {
- { 2, false, IS_P, "is"},
- { 2, false, TO_P, "to"},
- { 3, false, ABS_P, "abs"},
- { 3, false, LAX_P, "lax"},
- { 4, false, DATE_P, "date"},
- { 4, false, FLAG_P, "flag"},
- { 4, false, LAST_P, "last"},
- { 4, true, NULL_P, "null"},
- { 4, false, SIZE_P, "size"},
- { 4, false, TIME_P, "time"},
- { 4, true, TRUE_P, "true"},
- { 4, false, TYPE_P, "type"},
- { 4, false, WITH_P, "with"},
- { 5, true, FALSE_P, "false"},
- { 5, false, FLOOR_P, "floor"},
- { 6, false, BIGINT_P, "bigint"},
- { 6, false, DOUBLE_P, "double"},
- { 6, false, EXISTS_P, "exists"},
- { 6, false, NUMBER_P, "number"},
- { 6, false, STARTS_P, "starts"},
- { 6, false, STRICT_P, "strict"},
- { 6, false, STRINGFUNC_P, "string"},
- { 7, false, BOOLEAN_P, "boolean"},
- { 7, false, CEILING_P, "ceiling"},
- { 7, false, DECIMAL_P, "decimal"},
- { 7, false, INTEGER_P, "integer"},
- { 7, false, TIME_TZ_P, "time_tz"},
- { 7, false, UNKNOWN_P, "unknown"},
- { 8, false, DATETIME_P, "datetime"},
- { 8, false, KEYVALUE_P, "keyvalue"},
- { 9, false, TIMESTAMP_P, "timestamp"},
- { 10,false, LIKE_REGEX_P, "like_regex"},
- { 12,false, TIMESTAMP_TZ_P, "timestamp_tz"},
+ {2, false, IS_P, "is"},
+ {2, false, TO_P, "to"},
+ {3, false, ABS_P, "abs"},
+ {3, false, LAX_P, "lax"},
+ {4, false, DATE_P, "date"},
+ {4, false, FLAG_P, "flag"},
+ {4, false, LAST_P, "last"},
+ {4, true, NULL_P, "null"},
+ {4, false, SIZE_P, "size"},
+ {4, false, TIME_P, "time"},
+ {4, true, TRUE_P, "true"},
+ {4, false, TYPE_P, "type"},
+ {4, false, WITH_P, "with"},
+ {5, true, FALSE_P, "false"},
+ {5, false, FLOOR_P, "floor"},
+ {6, false, BIGINT_P, "bigint"},
+ {6, false, DOUBLE_P, "double"},
+ {6, false, EXISTS_P, "exists"},
+ {6, false, NUMBER_P, "number"},
+ {6, false, STARTS_P, "starts"},
+ {6, false, STRICT_P, "strict"},
+ {6, false, STRINGFUNC_P, "string"},
+ {7, false, BOOLEAN_P, "boolean"},
+ {7, false, CEILING_P, "ceiling"},
+ {7, false, DECIMAL_P, "decimal"},
+ {7, false, INTEGER_P, "integer"},
+ {7, false, TIME_TZ_P, "time_tz"},
+ {7, false, UNKNOWN_P, "unknown"},
+ {8, false, DATETIME_P, "datetime"},
+ {8, false, KEYVALUE_P, "keyvalue"},
+ {9, false, TIMESTAMP_P, "timestamp"},
+ {10, false, LIKE_REGEX_P, "like_regex"},
+ {12, false, TIMESTAMP_TZ_P, "timestamp_tz"},
};
/*
{
int res = IDENT_P;
int diff;
- const JsonPathKeyword *StopLow = keywords,
- *StopHigh = keywords + lengthof(keywords),
- *StopMiddle;
+ const JsonPathKeyword *StopLow = keywords,
+ *StopHigh = keywords + lengthof(keywords),
+ *StopMiddle;
if (yyextra->scanstring.len > keywords[lengthof(keywords) - 1].len)
return res;
JsonPathParseResult *
parsejsonpath(const char *str, int len, struct Node *escontext)
{
- JsonPathParseResult *parseresult;
+ JsonPathParseResult *parseresult;
yyscan_t scanner;
struct jsonpath_yy_extra_type yyext;
jsonpath_yy_scan_bytes(str, len, scanner);
if (jsonpath_yyparse(&parseresult, escontext, scanner) != 0)
- jsonpath_yyerror(NULL, escontext, scanner, "invalid input"); /* shouldn't happen */
+ jsonpath_yyerror(NULL, escontext, scanner, "invalid input"); /* shouldn't happen */
jsonpath_yylex_destroy(scanner);
ereturn(escontext, false,
(errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
errmsg("unsupported Unicode escape sequence"),
- errdetail("\\u0000 cannot be converted to text.")));
+ errdetail("\\u0000 cannot be converted to text.")));
}
else
{
* more detailed errors.
*/
- if (! escontext || ! IsA(escontext, ErrorSaveContext))
+ if (!escontext || !IsA(escontext, ErrorSaveContext))
pg_unicode_to_server(ch, (unsigned char *) cbuf);
else if (!pg_unicode_to_server_noerror(ch, (unsigned char *) cbuf))
ereturn(escontext, false,
for (i = 2; i < l; i += 2) /* skip '\u' */
{
int ch = 0;
- int j, si;
+ int j,
+ si;
- if (s[i] == '{') /* parse '\u{XX...}' */
+ if (s[i] == '{') /* parse '\u{XX...}' */
{
while (s[++i] != '}' && i < l)
{
return false;
ch = (ch << 4) | si;
}
- i++; /* skip '}' */
+ i++; /* skip '}' */
}
- else /* parse '\uXXXX' */
+ else /* parse '\uXXXX' */
{
for (j = 0; j < 4 && i < l; j++)
{
}
}
- if (! addUnicode(ch, &hi_surrogate, escontext, yyscanner))
+ if (!addUnicode(ch, &hi_surrogate, escontext, yyscanner))
return false;
}
static bool
parseHexChar(char *s, struct Node *escontext, yyscan_t yyscanner)
{
- int s2, s3, ch;
+ int s2,
+ s3,
+ ch;
+
if (!hexval(s[2], &s2, escontext, yyscanner))
return false;
if (!hexval(s[3], &s3, escontext, yyscanner))
{
ereport(elevel,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("syntax error in file \"%s\" line %u, near end of line",
- config_file, ConfigFileLineno - 1)));
+ errmsg("syntax error in file \"%s\" line %u, near end of line",
+ config_file, ConfigFileLineno - 1)));
record_config_file_error("syntax error",
config_file, ConfigFileLineno - 1,
head_p, tail_p);
{
ereport(elevel,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
- config_file, ConfigFileLineno, yytext)));
+ errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
+ config_file, ConfigFileLineno, yytext)));
record_config_file_error("syntax error",
config_file, ConfigFileLineno,
head_p, tail_p);
{
ereport(elevel,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("too many syntax errors found, abandoning file \"%s\"",
- config_file)));
+ errmsg("too many syntax errors found, abandoning file \"%s\"",
+ config_file)));
break;
}
int num_filenames;
filenames = GetConfFilesInDir(includedir, calling_file, elevel,
- &num_filenames, &err_msg);
+ &num_filenames, &err_msg);
if (!filenames)
{
const char *fname;
int nargs;
PgBenchFunction tag;
-} PGBENCH_FUNCTIONS[] =
+} PGBENCH_FUNCTIONS[] =
+
{
/* parsed as operators, executed as functions */
{
static PgBenchExpr *
make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
{
- int len = elist_length(args);
+ int len = elist_length(args);
PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
/* validate arguments number including few special cases */
switch (PGBENCH_FUNCTIONS[fnumber].nargs)
{
- /* check at least one arg for least & greatest */
+ /* check at least one arg for least & greatest */
case PGBENCH_NARGS_VARIABLE:
if (len == 0)
expr_yyerror_more(yyscanner, "at least one argument expected",
PGBENCH_FUNCTIONS[fnumber].fname);
break;
- /* case (when ... then ...)+ (else ...)? end */
+ /* case (when ... then ...)+ (else ...)? end */
case PGBENCH_NARGS_CASE:
/* 'else' branch is always present, but could be a NULL-constant */
if (len < 3 || len % 2 != 1)
"case control structure");
break;
- /* hash functions with optional seed argument */
+ /* hash functions with optional seed argument */
case PGBENCH_NARGS_HASH:
if (len < 1 || len > 2)
expr_yyerror_more(yyscanner, "unexpected number of arguments",
if (len == 1)
{
PgBenchExpr *var = make_variable("default_seed");
+
args = make_elist(var, args);
}
break;
- /* pseudorandom permutation function with optional seed argument */
+ /* pseudorandom permutation function with optional seed argument */
case PGBENCH_NARGS_PERMUTE:
if (len < 2 || len > 3)
expr_yyerror_more(yyscanner, "unexpected number of arguments",
if (len == 2)
{
PgBenchExpr *var = make_variable("default_seed");
+
args = make_elist(var, args);
}
break;
- /* common case: positive arguments number */
+ /* common case: positive arguments number */
default:
Assert(PGBENCH_FUNCTIONS[fnumber].nargs >= 0);
psql_scan_reselect_sql_lexer(state);
/*
- * Check the lex result: we should have gotten back either LEXRES_OK
- * or LEXRES_EOL (the latter indicating end of string). If we were inside
- * a quoted string, as indicated by final_state, EOL is an error.
+ * Check the lex result: we should have gotten back either LEXRES_OK or
+ * LEXRES_EOL (the latter indicating end of string). If we were inside a
+ * quoted string, as indicated by final_state, EOL is an error.
*/
Assert(lexresult == LEXRES_EOL || lexresult == LEXRES_OK);
termPQExpBuffer(&mybuf);
return NULL;
case xslashwholeline:
+
/*
* In whole-line mode, we interpret semicolon = true as stripping
* trailing whitespace as well as semicolons; this gives the
psql_scan_in_quote(PsqlScanState state)
{
return state->start_state != INITIAL &&
- state->start_state != xqs;
+ state->start_state != xqs;
}
/*
void
psqlscan_test_variable(PsqlScanState state, const char *txt, int len)
{
- char *varname;
- char *value;
+ char *varname;
+ char *value;
varname = psqlscan_extract_substring(state, txt + 3, len - 4);
if (state->callbacks->get_variable)
ptr->used = yb;
/*
- * We use yy_scan_string which will copy the value, so there's
- * no need to worry about a possible undef happening while we
- * are still scanning it.
+ * We use yy_scan_string which will copy the value, so there's no
+ * need to worry about a possible undef happening while we are
+ * still scanning it.
*/
yy_scan_string(ptr->value);
return true;
for (;;)
{
tok = yylex();
- if (startlocation < 0) /* remember loc of first token */
+ if (startlocation < 0) /* remember loc of first token */
startlocation = yylloc;
if (tok == until && parenlevel == 0)
break;
if (parenlevel < 0)
yyerror("mismatched parentheses");
}
+
/*
- * End of function definition is an error, and we don't expect to
- * hit a semicolon either (unless it's the until symbol, in which
- * case we should have fallen out above).
+ * End of function definition is an error, and we don't expect to hit
+ * a semicolon either (unless it's the until symbol, in which case we
+ * should have fallen out above).
*/
if (tok == 0 || tok == ';')
{
plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_EXPR;
/*
- * Scan to the end of the SQL command. Identify any INTO-variables
- * clause lurking within it, and parse that via read_into_target().
+ * Scan to the end of the SQL command. Identify any INTO-variables clause
+ * lurking within it, and parse that via read_into_target().
*
* The end of the statement is defined by a semicolon ... except that
* semicolons within parentheses or BEGIN/END blocks don't terminate a
* but it's not very likely.
*
* 3. IMPORT FOREIGN SCHEMA ... INTO. This is not allowed in CREATE RULE
- * or WITH, so we just check for IMPORT as the command's first token.
- * (If IMPORT FOREIGN SCHEMA returned data someone might wish to capture
- * with an INTO-variables clause, we'd have to work much harder here.)
+ * or WITH, so we just check for IMPORT as the command's first token. (If
+ * IMPORT FOREIGN SCHEMA returned data someone might wish to capture with
+ * an INTO-variables clause, we'd have to work much harder here.)
*
- * Fortunately, INTO is a fully reserved word in the main grammar, so
- * at least we need not worry about it appearing as an identifier.
+ * Fortunately, INTO is a fully reserved word in the main grammar, so at
+ * least we need not worry about it appearing as an identifier.
*
* Any future additional uses of INTO in the main grammar will doubtless
* break this logic again ... beware!
prev_tok = tok;
tok = yylex();
if (have_into && into_end_loc < 0)
- into_end_loc = yylloc; /* token after the INTO part */
+ into_end_loc = yylloc; /* token after the INTO part */
/* Detect CREATE [OR REPLACE] {FUNCTION|PROCEDURE} */
if (tokens[0] == 'c' && token_count < sizeof(tokens))
{
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.
+ * 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);
bool check_FROM = true;
/*
- * We create the PLpgSQL_stmt_fetch struct here, but only fill in
- * the fields arising from the optional direction clause
+ * We create the PLpgSQL_stmt_fetch struct here, but only fill in the
+ * fields arising from the optional direction clause
*/
fetch = (PLpgSQL_stmt_fetch *) palloc0(sizeof(PLpgSQL_stmt_fetch));
fetch->cmd_type = PLPGSQL_STMT_FETCH;
K_LAST, "last"))
{
fetch->direction = FETCH_ABSOLUTE;
- fetch->how_many = -1;
+ fetch->how_many = -1;
}
else if (tok_is_keyword(tok, &yylval,
K_ABSOLUTE, "absolute"))
else
{
/*
- * Assume it's a count expression with no preceding keyword.
- * Note: we allow this syntax because core SQL does, but it's
- * ambiguous with the case of an omitted direction clause; for
- * instance, "MOVE n IN c" will fail if n is a variable, because the
- * preceding else-arm will trigger. Perhaps this can be improved
- * someday, but it hardly seems worth a lot of work.
+ * Assume it's a count expression with no preceding keyword. Note: we
+ * allow this syntax because core SQL does, but it's ambiguous with
+ * the case of an omitted direction clause; for instance, "MOVE n IN
+ * c" will fail if n is a variable, because the preceding else-arm
+ * will trigger. Perhaps this can be improved someday, but it hardly
+ * seems worth a lot of work.
*/
plpgsql_push_back_token(tok);
fetch->expr = read_sql_expression2(K_FROM, K_IN,
* BACKWARD expr, BACKWARD ALL, BACKWARD
*/
static void
-complete_direction(PLpgSQL_stmt_fetch *fetch, bool *check_FROM)
+complete_direction(PLpgSQL_stmt_fetch *fetch, bool *check_FROM)
{
int tok;
new = palloc0(sizeof(PLpgSQL_stmt_return));
new->cmd_type = PLPGSQL_STMT_RETURN;
new->lineno = plpgsql_location_to_lineno(location);
- new->stmtid = ++plpgsql_curr_compile->nstatements;
+ new->stmtid = ++plpgsql_curr_compile->nstatements;
new->expr = NULL;
new->retvarno = -1;
/*
* Not (just) a variable name, so treat as expression.
*
- * 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.
*/
plpgsql_push_back_token(tok);
new->expr = read_sql_expression(';', ";");
/*
* Not (just) a variable name, so treat as expression.
*
- * 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.
*/
plpgsql_push_back_token(tok);
new->expr = read_sql_expression(';', ";");
}
/*
- * Currently, a row or record variable can be the single INTO target,
- * but not a member of a multi-target list. So we throw error if there
- * is a comma after it, because that probably means the user tried to
- * write a multi-target list. If this ever gets generalized, we should
- * probably refactor read_into_scalar_list so it handles all cases.
+ * Currently, a row or record variable can be the single INTO target, but
+ * not a member of a multi-target list. So we throw error if there is a
+ * comma after it, because that probably means the user tried to write a
+ * multi-target list. If this ever gets generalized, we should probably
+ * refactor read_into_scalar_list so it handles all cases.
*/
switch (tok)
{
int nfields;
char *fieldnames[1024];
int varnos[1024];
- PLpgSQL_row *row;
+ PLpgSQL_row *row;
int tok;
check_assignable(initial_datum, initial_location);
NameOfDatum(&(yylval.wdatum))),
parser_errposition(yylloc)));
fieldnames[nfields] = NameOfDatum(&(yylval.wdatum));
- varnos[nfields++] = yylval.wdatum.datum->dno;
+ varnos[nfields++] = yylval.wdatum.datum->dno;
break;
default:
}
/*
- * We read an extra, non-comma token from yylex(), so push it
- * back onto the input stream
+ * We read an extra, non-comma token from yylex(), so push it back onto
+ * the input stream
*/
plpgsql_push_back_token(tok);
check_sql_expr(const char *stmt, RawParseMode parseMode, int location)
{
sql_error_callback_arg cbarg;
- ErrorContextCallback syntax_errcontext;
+ ErrorContextCallback syntax_errcontext;
MemoryContext oldCxt;
if (!plpgsql_check_syntax)
/*
* 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.
+ * statement text within the function text. Note this converts location
+ * (a byte offset) to a character number.
*/
parser_errposition(cbarg->location);
/*
- * If the core parser provided an error position, transpose it.
- * Note we are dealing with 1-based character numbers at this point.
+ * 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 > 0)
Oid type_id;
int32 typmod;
sql_error_callback_arg cbarg;
- ErrorContextCallback syntax_errcontext;
+ ErrorContextCallback syntax_errcontext;
cbarg.location = location;
plpgsql_peek2(&tok1, &tok2, &arglocation, NULL);
if (tok1 == IDENT && tok2 == COLON_EQUALS)
{
- char *argname;
+ char *argname;
IdentifierLookup save_IdentifierLookup;
/* Read the argument name, ignoring any matching variable */
if (expected_nparams < list_length(stmt->params))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("too many parameters specified for RAISE")));
+ errmsg("too many parameters specified for RAISE")));
if (expected_nparams > list_length(stmt->params))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("too few parameters specified for RAISE")));
+ errmsg("too few parameters specified for RAISE")));
}
/*
/*
* When test expression is present, we create a var for it and then
* convert all the WHEN expressions to "VAR IN (original_expression)".
- * This is a bit klugy, but okay since we haven't yet done more than
- * read the expressions as text. (Note that previous parsing won't
- * have complained if the WHEN ... THEN expression contained multiple
+ * This is a bit klugy, but okay since we haven't yet done more than read
+ * the expressions as text. (Note that previous parsing won't have
+ * complained if the WHEN ... THEN expression contained multiple
* comma-separated values.)
*/
if (t_expr)
projects / postgresql.git / commitdiff