vsndrg/jq
1
0 Fork 0
mirror of https://github.com/jqlang/jq.git synced 2026-11-01 09:20:19 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
841445eea7ce016e2d07cd466836dba631081a23
jq/src/parser.c
T

4367 lines
151 KiB
C
Raw Normal View History

Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* A Bison parser, made by GNU Bison 3.8.2. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Bison implementation for Yacc-like parsers in C
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
Inc.
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
along with this program. If not, see <https://www.gnu.org/licenses/>. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
especially those whose name start with YY_ or yy_. They are
private implementation details that can be changed or removed. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
variables, as they might otherwise be expanded by user macros.
There are some unavoidable exceptions within include files to
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Identify Bison output, and Bison version. */
#define YYBISON 30802
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Bison version string. */
#define YYBISON_VERSION "3.8.2"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 1
/* Push parsers. */
#define YYPUSH 0
/* Pull parsers. */
#define YYPULL 1
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* First part of user prologue. */
#line 1 "src/parser.y"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Fix #814: raise on div-0, add inf isinf nan isnan
2015-06-17 19:46:57 -05:00
#include <assert.h>
#include <math.h>
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#include <stdio.h>
#include <string.h>
#include "compile.h"
#include "jv_alloc.h"
#define YYMALLOC jv_mem_alloc
#define YYFREE jv_mem_free
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#line 82 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# ifndef YY_CAST
# ifdef __cplusplus
# define YY_CAST(Type, Val) static_cast<Type> (Val)
# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_CAST(Type, Val) ((Type) (Val))
# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
# endif
# endif
# ifndef YY_NULLPTR
# if defined __cplusplus
# if 201103L <= __cplusplus
# define YY_NULLPTR nullptr
# else
# define YY_NULLPTR 0
# endif
# else
# define YY_NULLPTR ((void*)0)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# endif
# endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Use api.header.include to #include this header
instead of duplicating it here. */
Improve invalid object key error message
2015-09-16 09:49:11 -07:00
#ifndef YY_YY_SRC_PARSER_H_INCLUDED
# define YY_YY_SRC_PARSER_H_INCLUDED
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* "%code requires" blocks. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#line 11 "src/parser.y"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#include "locfile.h"
struct lexer_param;
#define YYLTYPE location
#define YYLLOC_DEFAULT(Loc, Rhs, N) \
do { \
if (N) { \
(Loc).start = YYRHSLOC(Rhs, 1).start; \
(Loc).end = YYRHSLOC(Rhs, N).end; \
} else { \
(Loc).start = YYRHSLOC(Rhs, 0).end; \
(Loc).end = YYRHSLOC(Rhs, 0).end; \
} \
} while (0)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#line 134 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Token kinds. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYEMPTY = -2,
YYEOF = 0, /* "end of file" */
YYerror = 256, /* error */
YYUNDEF = 257, /* "invalid token" */
INVALID_CHARACTER = 258, /* INVALID_CHARACTER */
IDENT = 259, /* IDENT */
FIELD = 260, /* FIELD */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
BINDING = 261, /* BINDING */
LITERAL = 262, /* LITERAL */
FORMAT = 263, /* FORMAT */
REC = 264, /* ".." */
SETMOD = 265, /* "%=" */
EQ = 266, /* "==" */
NEQ = 267, /* "!=" */
DEFINEDOR = 268, /* "//" */
AS = 269, /* "as" */
DEF = 270, /* "def" */
MODULE = 271, /* "module" */
IMPORT = 272, /* "import" */
INCLUDE = 273, /* "include" */
IF = 274, /* "if" */
THEN = 275, /* "then" */
ELSE = 276, /* "else" */
ELSE_IF = 277, /* "elif" */
REDUCE = 278, /* "reduce" */
FOREACH = 279, /* "foreach" */
END = 280, /* "end" */
AND = 281, /* "and" */
OR = 282, /* "or" */
TRY = 283, /* "try" */
CATCH = 284, /* "catch" */
LABEL = 285, /* "label" */
BREAK = 286, /* "break" */
LOC = 287, /* "$__loc__" */
SETPIPE = 288, /* "|=" */
SETPLUS = 289, /* "+=" */
SETMINUS = 290, /* "-=" */
SETMULT = 291, /* "*=" */
SETDIV = 292, /* "/=" */
SETDEFINEDOR = 293, /* "//=" */
LESSEQ = 294, /* "<=" */
GREATEREQ = 295, /* ">=" */
ALTERNATION = 296, /* "?//" */
QQSTRING_START = 297, /* QQSTRING_START */
QQSTRING_TEXT = 298, /* QQSTRING_TEXT */
QQSTRING_INTERP_START = 299, /* QQSTRING_INTERP_START */
QQSTRING_INTERP_END = 300, /* QQSTRING_INTERP_END */
QQSTRING_END = 301, /* QQSTRING_END */
FUNCDEF = 302, /* FUNCDEF */
NONOPT = 303 /* NONOPT */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
typedef enum yytokentype yytoken_kind_t;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Token kinds. */
#define YYEMPTY -2
#define YYEOF 0
#define YYerror 256
#define YYUNDEF 257
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#define INVALID_CHARACTER 258
#define IDENT 259
#define FIELD 260
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define BINDING 261
#define LITERAL 262
#define FORMAT 263
#define REC 264
#define SETMOD 265
#define EQ 266
#define NEQ 267
#define DEFINEDOR 268
#define AS 269
#define DEF 270
#define MODULE 271
#define IMPORT 272
#define INCLUDE 273
#define IF 274
#define THEN 275
#define ELSE 276
#define ELSE_IF 277
#define REDUCE 278
#define FOREACH 279
#define END 280
#define AND 281
#define OR 282
#define TRY 283
#define CATCH 284
#define LABEL 285
#define BREAK 286
#define LOC 287
#define SETPIPE 288
#define SETPLUS 289
#define SETMINUS 290
#define SETMULT 291
#define SETDIV 292
#define SETDEFINEDOR 293
#define LESSEQ 294
#define GREATEREQ 295
#define ALTERNATION 296
#define QQSTRING_START 297
#define QQSTRING_TEXT 298
#define QQSTRING_INTERP_START 299
#define QQSTRING_INTERP_END 300
#define QQSTRING_END 301
#define FUNCDEF 302
#define NONOPT 303
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#line 31 "src/parser.y"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
jv literal;
block blk;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 255 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
};
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
typedef union YYSTYPE YYSTYPE;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
/* Location type. */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
int first_line;
int first_column;
int last_line;
int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif /* !YY_YY_SRC_PARSER_H_INCLUDED */
/* Symbol kind. */
enum yysymbol_kind_t
{
YYSYMBOL_YYEMPTY = -2,
YYSYMBOL_YYEOF = 0, /* "end of file" */
YYSYMBOL_YYerror = 1, /* error */
YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
YYSYMBOL_INVALID_CHARACTER = 3, /* INVALID_CHARACTER */
YYSYMBOL_IDENT = 4, /* IDENT */
YYSYMBOL_FIELD = 5, /* FIELD */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
YYSYMBOL_BINDING = 6, /* BINDING */
YYSYMBOL_LITERAL = 7, /* LITERAL */
YYSYMBOL_FORMAT = 8, /* FORMAT */
YYSYMBOL_REC = 9, /* ".." */
YYSYMBOL_SETMOD = 10, /* "%=" */
YYSYMBOL_EQ = 11, /* "==" */
YYSYMBOL_NEQ = 12, /* "!=" */
YYSYMBOL_DEFINEDOR = 13, /* "//" */
YYSYMBOL_AS = 14, /* "as" */
YYSYMBOL_DEF = 15, /* "def" */
YYSYMBOL_MODULE = 16, /* "module" */
YYSYMBOL_IMPORT = 17, /* "import" */
YYSYMBOL_INCLUDE = 18, /* "include" */
YYSYMBOL_IF = 19, /* "if" */
YYSYMBOL_THEN = 20, /* "then" */
YYSYMBOL_ELSE = 21, /* "else" */
YYSYMBOL_ELSE_IF = 22, /* "elif" */
YYSYMBOL_REDUCE = 23, /* "reduce" */
YYSYMBOL_FOREACH = 24, /* "foreach" */
YYSYMBOL_END = 25, /* "end" */
YYSYMBOL_AND = 26, /* "and" */
YYSYMBOL_OR = 27, /* "or" */
YYSYMBOL_TRY = 28, /* "try" */
YYSYMBOL_CATCH = 29, /* "catch" */
YYSYMBOL_LABEL = 30, /* "label" */
YYSYMBOL_BREAK = 31, /* "break" */
YYSYMBOL_LOC = 32, /* "$__loc__" */
YYSYMBOL_SETPIPE = 33, /* "|=" */
YYSYMBOL_SETPLUS = 34, /* "+=" */
YYSYMBOL_SETMINUS = 35, /* "-=" */
YYSYMBOL_SETMULT = 36, /* "*=" */
YYSYMBOL_SETDIV = 37, /* "/=" */
YYSYMBOL_SETDEFINEDOR = 38, /* "//=" */
YYSYMBOL_LESSEQ = 39, /* "<=" */
YYSYMBOL_GREATEREQ = 40, /* ">=" */
YYSYMBOL_ALTERNATION = 41, /* "?//" */
YYSYMBOL_QQSTRING_START = 42, /* QQSTRING_START */
YYSYMBOL_QQSTRING_TEXT = 43, /* QQSTRING_TEXT */
YYSYMBOL_QQSTRING_INTERP_START = 44, /* QQSTRING_INTERP_START */
YYSYMBOL_QQSTRING_INTERP_END = 45, /* QQSTRING_INTERP_END */
YYSYMBOL_QQSTRING_END = 46, /* QQSTRING_END */
YYSYMBOL_FUNCDEF = 47, /* FUNCDEF */
YYSYMBOL_48_ = 48, /* '|' */
YYSYMBOL_49_ = 49, /* ',' */
YYSYMBOL_50_ = 50, /* '=' */
YYSYMBOL_51_ = 51, /* '<' */
YYSYMBOL_52_ = 52, /* '>' */
YYSYMBOL_53_ = 53, /* '+' */
YYSYMBOL_54_ = 54, /* '-' */
YYSYMBOL_55_ = 55, /* '*' */
YYSYMBOL_56_ = 56, /* '/' */
YYSYMBOL_57_ = 57, /* '%' */
YYSYMBOL_NONOPT = 58, /* NONOPT */
YYSYMBOL_59_ = 59, /* '?' */
YYSYMBOL_60_ = 60, /* ';' */
YYSYMBOL_61_ = 61, /* '(' */
YYSYMBOL_62_ = 62, /* ')' */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYSYMBOL_63_ = 63, /* ':' */
YYSYMBOL_64_ = 64, /* '.' */
YYSYMBOL_65_ = 65, /* '[' */
YYSYMBOL_66_ = 66, /* ']' */
YYSYMBOL_67_ = 67, /* '{' */
YYSYMBOL_68_ = 68, /* '}' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
YYSYMBOL_69_ = 69, /* '$' */
YYSYMBOL_YYACCEPT = 70, /* $accept */
YYSYMBOL_TopLevel = 71, /* TopLevel */
YYSYMBOL_Module = 72, /* Module */
YYSYMBOL_Imports = 73, /* Imports */
YYSYMBOL_FuncDefs = 74, /* FuncDefs */
YYSYMBOL_Exp = 75, /* Exp */
YYSYMBOL_Import = 76, /* Import */
YYSYMBOL_ImportWhat = 77, /* ImportWhat */
YYSYMBOL_ImportFrom = 78, /* ImportFrom */
YYSYMBOL_FuncDef = 79, /* FuncDef */
YYSYMBOL_Params = 80, /* Params */
YYSYMBOL_Param = 81, /* Param */
YYSYMBOL_String = 82, /* String */
YYSYMBOL_83_1 = 83, /* @1 */
YYSYMBOL_84_2 = 84, /* @2 */
YYSYMBOL_QQString = 85, /* QQString */
YYSYMBOL_ElseBody = 86, /* ElseBody */
YYSYMBOL_ExpD = 87, /* ExpD */
YYSYMBOL_Term = 88, /* Term */
YYSYMBOL_Args = 89, /* Args */
YYSYMBOL_Arg = 90, /* Arg */
YYSYMBOL_RepPatterns = 91, /* RepPatterns */
YYSYMBOL_Patterns = 92, /* Patterns */
YYSYMBOL_Pattern = 93, /* Pattern */
YYSYMBOL_ArrayPats = 94, /* ArrayPats */
YYSYMBOL_ObjPats = 95, /* ObjPats */
YYSYMBOL_ObjPat = 96, /* ObjPat */
YYSYMBOL_Keyword = 97, /* Keyword */
YYSYMBOL_MkDict = 98, /* MkDict */
YYSYMBOL_MkDictPair = 99 /* MkDictPair */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
};
typedef enum yysymbol_kind_t yysymbol_kind_t;
/* Second part of user prologue. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 125 "src/parser.y"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#include "lexer.h"
struct lexer_param {
yyscan_t lexer;
};
#define FAIL(loc, msg) \
do { \
location l = loc; \
yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \
/*YYERROR*/; \
} while (0)
Clean up trailing whitespace
2015-07-19 09:36:16 -07:00
void yyerror(YYLTYPE* loc, block* answer, int* errors,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){
(*errors)++;
if (strstr(s, "unexpected")) {
#ifdef WIN32
locfile_locate(locations, *loc, "jq: error: %s (Windows cmd shell quoting issues?)", s);
#else
locfile_locate(locations, *loc, "jq: error: %s (Unix shell quoting issues?)", s);
#endif
} else {
locfile_locate(locations, *loc, "jq: error: %s", s);
}
}
Clean up trailing whitespace
2015-07-19 09:36:16 -07:00
int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
struct locfile* locations, struct lexer_param* lexer_param_ptr) {
yyscan_t lexer = lexer_param_ptr->lexer;
int tok = jq_yylex(yylval, yylloc, lexer);
if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) {
jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
if (jv_get_kind(msg) == JV_KIND_STRING) {
FAIL(*yylloc, jv_string_value(msg));
} else {
FAIL(*yylloc, "Invalid literal");
}
jv_free(msg);
jv_free(yylval->literal);
yylval->literal = jv_null();
}
return tok;
}
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
/* Returns string message if the block is a constant that is not valid as an
* object key. */
static jv check_object_key(block k) {
if (block_is_const(k) && block_const_kind(k) != JV_KIND_STRING) {
char errbuf[15];
return jv_string_fmt("Cannot use %s (%s) as object key",
jv_kind_name(block_const_kind(k)),
Save literal value of the parsed number to preserve it for the output
2018-10-19 21:57:41 +03:00
jv_dump_string_trunc(block_const(k), errbuf, sizeof(errbuf)));
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
}
return jv_invalid();
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static block gen_index(block obj, block key) {
return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX));
}
static block gen_index_opt(block obj, block key) {
return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX_OPT));
}
static block gen_slice_index(block obj, block start, block end, opcode idx_op) {
block key = BLOCK(gen_subexp(gen_const(jv_object())),
gen_subexp(gen_const(jv_string("start"))),
gen_subexp(start),
gen_op_simple(INSERT),
gen_subexp(gen_const(jv_string("end"))),
gen_subexp(end),
gen_op_simple(INSERT));
return BLOCK(key, obj, gen_op_simple(idx_op));
}
static block constant_fold(block a, block b, int op) {
if (!block_is_single(a) || !block_is_const(a) ||
!block_is_single(b) || !block_is_const(b))
return gen_noop();
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
if (op == '+') {
if (block_const_kind(a) == JV_KIND_NULL) {
block_free(a);
return b;
}
if (block_const_kind(b) == JV_KIND_NULL) {
block_free(b);
return a;
}
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (block_const_kind(a) != block_const_kind(b))
return gen_noop();
jv res = jv_invalid();
if (block_const_kind(a) == JV_KIND_NUMBER) {
Save literal value of the parsed number to preserve it for the output
2018-10-19 21:57:41 +03:00
jv jv_a = block_const(a);
jv jv_b = block_const(b);
double na = jv_number_value(jv_a);
double nb = jv_number_value(jv_b);
int cmp = jv_cmp(jv_a, jv_b);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
switch (op) {
case '+': res = jv_number(na + nb); break;
case '-': res = jv_number(na - nb); break;
case '*': res = jv_number(na * nb); break;
case '/': res = jv_number(na / nb); break;
Save literal value of the parsed number to preserve it for the output
2018-10-19 21:57:41 +03:00
case EQ: res = (cmp == 0 ? jv_true() : jv_false()); break;
case NEQ: res = (cmp != 0 ? jv_true() : jv_false()); break;
case '<': res = (cmp < 0 ? jv_true() : jv_false()); break;
case '>': res = (cmp > 0 ? jv_true() : jv_false()); break;
case LESSEQ: res = (cmp <= 0 ? jv_true() : jv_false()); break;
case GREATEREQ: res = (cmp >= 0 ? jv_true() : jv_false()); break;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
default: break;
}
} else if (op == '+' && block_const_kind(a) == JV_KIND_STRING) {
res = jv_string_concat(block_const(a), block_const(b));
} else {
return gen_noop();
}
if (jv_get_kind(res) == JV_KIND_INVALID)
return gen_noop();
block_free(a);
block_free(b);
return gen_const(res);
}
static block gen_binop(block a, block b, int op) {
block folded = constant_fold(a, b, op);
if (!block_is_noop(folded))
return folded;
const char* funcname = 0;
switch (op) {
case '+': funcname = "_plus"; break;
case '-': funcname = "_minus"; break;
case '*': funcname = "_multiply"; break;
case '/': funcname = "_divide"; break;
case '%': funcname = "_mod"; break;
case EQ: funcname = "_equal"; break;
case NEQ: funcname = "_notequal"; break;
case '<': funcname = "_less"; break;
case '>': funcname = "_greater"; break;
case LESSEQ: funcname = "_lesseq"; break;
case GREATEREQ: funcname = "_greatereq"; break;
}
assert(funcname);
return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b)));
}
static block gen_format(block a, jv fmt) {
Fix unnecessary use of BLOCK macro
2015-08-16 09:01:35 -07:00
return BLOCK(a, gen_call("format", gen_lambda(gen_const(fmt))));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
static block gen_definedor_assign(block object, block val) {
block tmp = gen_op_var_fresh(STOREV, "tmp");
return BLOCK(gen_op_simple(DUP),
val, tmp,
gen_call("_modify", BLOCK(gen_lambda(object),
Clean up trailing whitespace
2015-07-19 09:36:16 -07:00
gen_lambda(gen_definedor(gen_noop(),
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
gen_op_bound(LOADV, tmp))))));
}
Clean up trailing whitespace
2015-07-19 09:36:16 -07:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static block gen_update(block object, block val, int optype) {
block tmp = gen_op_var_fresh(STOREV, "tmp");
return BLOCK(gen_op_simple(DUP),
val,
tmp,
Clean up trailing whitespace
2015-07-19 09:36:16 -07:00
gen_call("_modify", BLOCK(gen_lambda(object),
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
gen_lambda(gen_binop(gen_noop(),
gen_op_bound(LOADV, tmp),
optype)))));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 573 "src/parser.c"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#ifdef short
# undef short
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
<limits.h> and (if available) <stdint.h> are included
so that the code can choose integer types of a good width. */
#ifndef __PTRDIFF_MAX__
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
# define YY_STDINT_H
# endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Narrow types that promote to a signed type and that can represent a
signed or unsigned integer of at least N bits. In tables they can
save space and decrease cache pressure. Promoting to a signed type
helps avoid bugs in integer arithmetic. */
#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#else
typedef signed char yytype_int8;
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
typedef short yytype_int16;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Work around bug in HP-UX 11.23, which defines these macros
incorrectly for preprocessor constants. This workaround can likely
be removed in 2023, as HPE has promised support for HP-UX 11.23
(aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
<https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
#ifdef __hpux
# undef UINT_LEAST8_MAX
# undef UINT_LEAST16_MAX
# define UINT_LEAST8_MAX 255
# define UINT_LEAST16_MAX 65535
#endif
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
&& UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
typedef short yytype_uint8;
#endif
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
&& UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif
#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
# define YYPTRDIFF_T __PTRDIFF_TYPE__
# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
# ifndef ptrdiff_t
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# endif
# define YYPTRDIFF_T ptrdiff_t
# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
# define YYPTRDIFF_T long
# define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YYSIZE_T unsigned
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# endif
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define YYSIZE_MAXIMUM \
YY_CAST (YYPTRDIFF_T, \
(YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
? YYPTRDIFF_MAXIMUM \
: YY_CAST (YYSIZE_T, -1)))
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
/* Stored state numbers (used for stacks). */
typedef yytype_int16 yy_state_t;
/* State numbers in computations. */
typedef int yy_state_fast_t;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_ATTRIBUTE_PURE
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# endif
#endif
#ifndef YY_ATTRIBUTE_UNUSED
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
# else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_ATTRIBUTE_UNUSED
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
# endif
#endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_USE(E) ((void) (E))
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#else
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_USE(E) /* empty */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
# else
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# endif
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
_Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END \
_Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define YY_ASSERT(E) ((void) (0 && (E)))
#if 1
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif /* 1 */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
&& defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_state_t yyss_alloc;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYSTYPE yyvs_alloc;
YYLTYPE yyls_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
+ YYSIZEOF (YYLTYPE)) \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
+ 2 * YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yynewbytes; \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / YYSIZEOF (*yyptr); \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
} \
while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
__builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yyi; \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYFINAL 29
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYLAST -- Last index in YYTABLE. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYLAST 2034
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYNTOKENS -- Number of terminals. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYNTOKENS 70
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYNNTS -- Number of nonterminals. */
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
#define YYNNTS 30
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYNRULES -- Number of rules. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYNRULES 169
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYNSTATES -- Number of states. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYNSTATES 317
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYMAXUTOK -- Last valid token kind. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYMAXUTOK 303
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, with out-of-bounds checking. */
#define YYTRANSLATE(YYX) \
(0 <= (YYX) && (YYX) <= YYMAXUTOK \
? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
: YYSYMBOL_YYUNDEF)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
as returned by yylex. */
static const yytype_int8 yytranslate[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
2, 2, 2, 2, 2, 2, 69, 57, 2, 2,
61, 62, 55, 53, 49, 54, 64, 56, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 63, 60,
51, 50, 52, 59, 2, 2, 2, 2, 2, 2,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
2, 65, 2, 66, 2, 2, 2, 2, 2, 2,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
2, 2, 2, 67, 48, 68, 2, 2, 2, 2,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
Resolve shift/reduce conflict of 'def' vs '|'
2015-07-18 21:57:20 -07:00
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
45, 46, 47, 58
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
#if YYDEBUG
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_int16 yyrline[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 307, 307, 310, 315, 318, 333, 336, 341, 344,
349, 353, 356, 360, 364, 368, 371, 376, 380, 384,
389, 396, 400, 404, 408, 412, 416, 420, 424, 428,
432, 436, 440, 444, 448, 452, 456, 460, 466, 472,
476, 480, 484, 488, 492, 496, 500, 504, 509, 512,
529, 538, 545, 553, 564, 569, 575, 578, 583, 587,
594, 594, 598, 598, 605, 608, 611, 617, 620, 623,
628, 631, 634, 640, 643, 646, 654, 658, 661, 664,
667, 670, 673, 676, 679, 682, 686, 692, 695, 698,
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
701, 704, 707, 710, 713, 716, 719, 722, 725, 728,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
731, 734, 737, 740, 743, 746, 749, 752, 774, 778,
782, 786, 798, 803, 804, 805, 806, 809, 812, 817,
822, 825, 830, 833, 838, 842, 845, 850, 853, 858,
861, 866, 869, 872, 875, 878, 881, 889, 895, 898,
901, 904, 907, 910, 913, 916, 919, 922, 925, 928,
931, 934, 937, 940, 943, 946, 951, 954, 955, 956,
959, 962, 965, 968, 972, 976, 980, 984, 988, 996
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/** Accessing symbol of state STATE. */
#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
#if 1
/* The user-facing name of the symbol whose (internal) number is
YYSYMBOL. No bounds checking. */
static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
"\"end of file\"", "error", "\"invalid token\"", "INVALID_CHARACTER",
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
"IDENT", "FIELD", "BINDING", "LITERAL", "FORMAT", "\"..\"", "\"%=\"",
"\"==\"", "\"!=\"", "\"//\"", "\"as\"", "\"def\"", "\"module\"",
"\"import\"", "\"include\"", "\"if\"", "\"then\"", "\"else\"",
"\"elif\"", "\"reduce\"", "\"foreach\"", "\"end\"", "\"and\"", "\"or\"",
"\"try\"", "\"catch\"", "\"label\"", "\"break\"", "\"$__loc__\"",
"\"|=\"", "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"",
"\">=\"", "\"?//\"", "QQSTRING_START", "QQSTRING_TEXT",
"QQSTRING_INTERP_START", "QQSTRING_INTERP_END", "QQSTRING_END",
"FUNCDEF", "'|'", "','", "'='", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'",
"'%'", "NONOPT", "'?'", "';'", "'('", "')'", "':'", "'.'", "'['", "']'",
"'{'", "'}'", "'$'", "$accept", "TopLevel", "Module", "Imports",
"FuncDefs", "Exp", "Import", "ImportWhat", "ImportFrom", "FuncDef",
"Params", "Param", "String", "@1", "@2", "QQString", "ElseBody", "ExpD",
"Term", "Args", "Arg", "RepPatterns", "Patterns", "Pattern", "ArrayPats",
"ObjPats", "ObjPat", "Keyword", "MkDict", "MkDictPair", YY_NULLPTR
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
static const char *
yysymbol_name (yysymbol_kind_t yysymbol)
{
return yytname[yysymbol];
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#endif
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYPACT_NINF (-161)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define yypact_value_is_default(Yyn) \
((Yyn) == YYPACT_NINF)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#define YYTABLE_NINF (-157)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define yytable_value_is_error(Yyn) \
((Yyn) == YYTABLE_NINF)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static const yytype_int16 yypact[] =
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
-14, 863, 29, 34, 14, 20, -161, -161, 21, -161,
78, 863, 448, 448, 863, 103, 39, -161, -161, 863,
417, 284, 350, 581, 50, 1351, 863, -161, 2, -161,
7, 7, 863, 34, 665, 863, -161, -161, -22, 1707,
9, 51, 97, 82, -161, -161, -161, -2, 69, 1181,
-161, 133, 21, 81, 77, -161, 992, -46, 83, 85,
-161, -161, -161, -161, -161, -161, -161, -161, -161, -161,
-161, -161, -161, -161, -161, -161, -161, -161, 863, 86,
87, 76, 96, 84, 863, 863, 863, 863, 863, 863,
863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
863, 863, 863, 863, 863, 863, 863, 863, -161, -161,
1875, 92, -5, -4, 165, 140, -161, -161, -161, 1875,
863, -161, -161, 1402, 1875, 10, -161, -161, 74, 863,
468, -5, -5, 519, 863, 4, -161, -161, -161, -161,
-161, -161, 637, 206, -161, 206, 206, 1215, 206, 206,
-161, 637, 149, 1943, 580, 580, 1909, 779, 1975, 1943,
1943, 1943, 1943, 1943, 1943, 580, 580, 1875, 1909, 1943,
580, 580, -2, -2, 98, 98, 98, -161, -161, -5,
925, 117, 111, 119, 731, 102, 99, 863, 104, 958,
121, -161, -161, 863, -161, 25, -161, -161, 75, -161,
1453, -161, 1657, 101, 106, -161, -161, 1875, -161, 863,
-161, -19, -161, 206, 116, 59, 116, 116, 105, 116,
116, -161, -161, -161, -24, 112, 113, 114, 863, 115,
-25, -161, 118, -5, 863, 120, 1026, -161, -161, 1060,
-161, 797, 123, -161, -161, -161, -161, 74, 124, -161,
863, 863, -161, -161, 863, 863, 1741, -161, 206, 206,
-5, -161, -5, -5, -5, 1249, -5, 925, -161, -5,
150, 1875, -161, 131, 135, 139, 1094, -161, -161, 863,
1791, 1841, 1504, 1555, -161, 116, 116, -161, -161, -161,
-161, 136, -161, -161, -161, -161, -161, -161, 141, 1606,
-161, 863, 863, 863, -5, -161, -161, 1657, 1283, 1128,
-161, -161, -161, 863, -161, 1317, -161
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do. Zero
means the default is an error. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static const yytype_uint8 yydefact[] =
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
4, 0, 0, 6, 111, 82, 109, 101, 103, 74,
0, 0, 0, 0, 0, 0, 0, 110, 60, 0,
0, 0, 0, 0, 0, 0, 0, 102, 47, 1,
0, 0, 8, 6, 0, 0, 78, 62, 0, 0,
0, 0, 18, 0, 76, 75, 64, 32, 0, 0,
85, 0, 0, 84, 0, 106, 0, 0, 166, 165,
138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
148, 149, 150, 151, 152, 153, 154, 155, 0, 163,
167, 0, 157, 0, 0, 0, 0, 0, 0, 0,
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 0, 0, 0, 0, 0, 0, 0, 21, 5,
10, 81, 0, 0, 0, 0, 53, 52, 3, 2,
8, 7, 48, 0, 119, 0, 117, 64, 0, 0,
0, 0, 0, 0, 0, 0, 113, 104, 86, 80,
114, 105, 0, 0, 116, 0, 0, 0, 0, 0,
107, 0, 0, 40, 41, 42, 25, 24, 23, 27,
31, 34, 36, 39, 26, 45, 46, 28, 29, 22,
43, 44, 30, 33, 35, 37, 38, 77, 124, 0,
0, 0, 0, 123, 0, 83, 0, 0, 92, 0,
0, 9, 49, 0, 112, 0, 59, 58, 0, 56,
0, 16, 0, 0, 0, 19, 17, 20, 65, 0,
61, 0, 159, 0, 169, 72, 160, 164, 0, 162,
161, 158, 108, 127, 0, 0, 0, 131, 0, 0,
0, 129, 0, 0, 0, 94, 0, 79, 115, 0,
91, 0, 88, 51, 50, 118, 63, 0, 0, 54,
0, 0, 69, 15, 0, 0, 0, 71, 0, 0,
0, 125, 0, 0, 0, 0, 0, 0, 126, 0,
122, 11, 93, 90, 100, 99, 0, 87, 57, 0,
0, 0, 0, 0, 66, 70, 168, 128, 137, 133,
132, 0, 135, 130, 134, 89, 97, 96, 98, 0,
68, 0, 0, 0, 0, 95, 55, 0, 0, 0,
136, 67, 12, 0, 14, 0, 13
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYPGOTO[NTERM-NUM]. */
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
static const yytype_int16 yypgoto[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
-161, -161, -161, 168, 89, -1, -161, -161, 171, 0,
-161, -44, 5, -161, -161, 90, -103, -137, -7, -161,
12, -161, -73, -152, -161, -161, -51, -160, -105, -161
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYDEFGOTO[NTERM-NUM]. */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
static const yytype_uint8 yydefgoto[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 2, 3, 32, 118, 110, 33, 34, 115, 26,
198, 199, 27, 46, 127, 135, 253, 214, 28, 125,
126, 181, 182, 183, 224, 230, 231, 80, 81, 82
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule whose
number is the opposite. If YYTABLE_NINF, syntax error. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static const yytype_int16 yytable[] =
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
25, 178, 1, 142, 52, 40, 41, 111, 216, 217,
39, 219, 220, 42, 111, 52, 112, 143, 47, 49,
232, 56, 144, 131, 267, 260, 53, 223, 79, 29,
142, 119, 120, 123, 124, 116, 116, 212, 18, 128,
44, 129, 261, 268, 143, 45, 221, 208, 209, 18,
210, 30, 31, 105, 106, 107, 111, 108, 203, 204,
179, 184, 180, 37, 111, 132, 113, 114, 208, 209,
193, 246, 194, 113, 114, 35, 257, 147, 196, 36,
197, 270, 38, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176, 232, 287, 43,
288, 289, 290, 189, 292, 113, 114, 294, 185, 83,
120, 285, 286, 113, 114, 243, 133, 244, 200, 202,
134, 136, 206, 207, 138, 247, 215, 248, 215, 215,
139, 215, 215, 140, 150, 151, 145, 79, 146, 148,
149, 177, 310, 152, 190, 222, 79, 108, 233, 234,
-121, 237, 254, 240, 258, 238, 186, 255, 259, 4,
5, 6, 7, 8, 9, 262, 263, 264, 266, 272,
10, 269, 277, 236, 11, 229, 239, 279, 12, 13,
295, -120, 124, 14, 296, 15, 16, 17, 297, 304,
305, 121, 117, 278, 311, 245, 215, 18, 256, 191,
4, 5, 6, 7, 8, 9, 293, 195, 0, 19,
0, 0, 0, 0, 0, 0, 20, 265, 187, 21,
22, 188, 23, 271, 24, 0, 0, 16, 17, 0,
276, 0, 0, 0, 0, 0, 0, 0, 18, 280,
281, 215, 215, 282, 283, 0, 0, 0, 0, 0,
213, 0, 0, 0, 0, 0, 0, 20, 0, 0,
21, 22, 229, 23, 0, 24, 0, 0, 299, 0,
0, 0, 0, 0, -73, 50, 0, 0, 51, -73,
0, 0, 52, 0, -73, -73, -73, -73, -73, 0,
307, 308, 309, 0, -73, -73, -73, 0, 0, -73,
-73, -73, 315, -73, 0, 0, 0, -73, -73, -73,
-73, -73, -73, -73, -73, 0, 18, 0, 0, -73,
0, 0, -73, -73, -73, -73, -73, -73, -73, -73,
-73, -73, 0, -73, -73, 0, -73, -73, -73, -73,
-73, 54, -73, 0, 4, 5, 6, 7, 8, 9,
0, 0, 0, 0, 0, 10, 0, 0, 0, 11,
0, 0, 0, 12, 13, 0, 0, 0, 14, 0,
15, 16, 17, 0, 0, 0, 0, 0, 0, 0,
0, 0, 18, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 19, 0, 0, 0, 0, 0,
0, 20, 0, 0, 21, 22, 55, 23, 48, 24,
0, 4, 5, 6, 7, 8, 9, 0, 0, 0,
0, 0, 10, 0, 0, 0, 11, 0, 0, 0,
12, 13, 0, 0, 0, 14, 0, 15, 16, 17,
0, 0, 4, 5, 6, 7, 8, 9, 0, 18,
0, 0, 0, 0, 0, 0, 0, 0, 0, 201,
0, 19, 4, 5, 6, 7, 8, 9, 20, 16,
17, 21, 22, 10, 23, 0, 24, 11, 0, 0,
18, 12, 13, 0, 0, 0, 14, 0, 15, 16,
17, 0, 0, 0, 0, 0, 0, 0, 0, 20,
18, 0, 21, 22, 0, 23, 0, 24, 0, 0,
205, 0, 19, 4, 5, 6, 7, 8, 9, 20,
0, 0, 21, 22, 10, 23, 0, 24, 11, 0,
0, 0, 12, 13, 0, 0, 0, 14, 0, 15,
16, 17, 0, 0, 0, 0, 0, 0, 0, 0,
0, 18, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 19, 0, 0, 0, 0, 0, 0,
20, 0, 57, 21, 22, 58, 23, 59, 24, 52,
0, -157, -157, 0, 0, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 0, 0, 0, 0, 0, 0, -157,
-157, 0, 0, 18, 0, 0, 0, 0, 0, 0,
0, -157, -157, 103, 104, 105, 106, 107, 211, 108,
0, 58, 78, 59, 0, 52, 0, 0, 0, -156,
0, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 70, 71, 72, 73, 74, 75, 76, 77, 4,
5, 6, 7, 8, 9, 0, 0, 0, 0, 18,
10, 0, 0, 0, 11, 0, 0, 0, 12, 13,
0, 0, 0, 14, 0, 15, 16, 17, 78, 0,
0, 0, 0, 0, 0, -156, 0, 18, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 19,
0, 0, 0, 0, 0, 122, 20, 0, 0, 21,
22, 0, 23, 0, 24, 4, 5, 6, 7, 8,
9, 0, 0, 0, 0, 0, 10, 0, 0, 0,
11, 0, 0, 0, 12, 13, 0, 0, 0, 14,
0, 15, 16, 17, 0, 0, 0, 0, 0, 0,
0, 0, 0, 18, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 19, 0, 0, 0, 0,
85, 86, 20, 0, 0, 21, 22, 235, 23, 0,
24, 4, 5, 6, 7, 8, 9, 0, 0, 0,
0, 0, 10, 0, 0, 0, 11, 0, 96, 97,
12, 13, 0, 0, 0, 14, 0, 15, 16, 17,
101, 102, 103, 104, 105, 106, 107, 0, 108, 18,
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 19, 0, 0, 0, 0, 0, 0, 20, 0,
0, 21, 22, 275, 23, 0, 24, 4, 5, 6,
7, 8, 9, 0, 0, 0, 0, 0, 10, 0,
0, 0, 11, 0, 0, 0, 12, 13, 0, 0,
0, 14, 0, 15, 16, 17, 0, 0, 0, 0,
0, 0, 0, 0, 0, 18, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 19, 0, 0,
0, 0, 0, 0, 20, 0, 225, 21, 22, 226,
23, 227, 24, 52, 0, 0, 0, 0, 0, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 18, 84, 85,
86, 87, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 88, 89, 228, 0, 0, 0,
0, 90, 91, 92, 93, 94, 95, 96, 97, 0,
0, 0, 84, 85, 86, 87, 98, 99, 100, 101,
102, 103, 104, 105, 106, 107, 0, 108, 88, 89,
0, 241, 0, 0, 242, 90, 91, 92, 93, 94,
95, 96, 97, 0, 0, 0, 84, 85, 86, 87,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
0, 108, 88, 89, 0, 0, 0, 0, 141, 90,
91, 92, 93, 94, 95, 96, 97, 0, 0, 0,
84, 85, 86, 87, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 0, 108, 88, 89, 0, 0,
0, 0, 273, 90, 91, 92, 93, 94, 95, 96,
97, 0, 0, 0, 84, 85, 86, 87, 98, 99,
100, 101, 102, 103, 104, 105, 106, 107, 0, 108,
88, 89, 0, 0, 0, 0, 274, 90, 91, 92,
93, 94, 95, 96, 97, 0, 0, 0, 84, 85,
86, 87, 98, 99, 100, 101, 102, 103, 104, 105,
106, 107, 0, 108, 88, 89, 0, 0, 0, 0,
298, 90, 91, 92, 93, 94, 95, 96, 97, 0,
0, 0, 0, 0, 0, 0, 98, 99, 100, 101,
102, 103, 104, 105, 106, 107, 0, 108, 313, 0,
314, 84, 85, 86, 87, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 88, 89, 0,
0, 0, 0, 0, 90, 91, 92, 93, 94, 95,
96, 97, 0, 0, 0, 84, 85, 86, 87, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
108, 88, 89, 137, 0, 0, 0, 0, 90, 91,
92, 93, 94, 95, 96, 97, 0, 0, 0, 84,
85, 86, 87, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 0, 108, 88, 89, 218, 0, 0,
0, 0, 90, 91, 92, 93, 94, 95, 96, 97,
0, 0, 0, 84, 85, 86, 87, 98, 99, 100,
101, 102, 103, 104, 105, 106, 107, 0, 108, 88,
89, 291, 0, 0, 0, 0, 90, 91, 92, 93,
94, 95, 96, 97, 0, 0, 0, 84, 85, 86,
87, 98, 99, 100, 101, 102, 103, 104, 105, 106,
107, 0, 108, 88, 89, 312, 0, 0, 0, 0,
90, 91, 92, 93, 94, 95, 96, 97, 0, 0,
0, 84, 85, 86, 87, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 0, 108, 88, 89, 316,
0, 0, 0, 0, 90, 91, 92, 93, 94, 95,
96, 97, 0, 0, 0, 0, 0, 0, 0, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
108, 109, 84, 85, 86, 87, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 88, 89,
0, 0, 0, 0, 0, 90, 91, 92, 93, 94,
95, 96, 97, 0, 0, 0, 0, 0, 0, 0,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
0, 108, 192, 84, 85, 86, 87, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 88,
89, 0, 0, 0, 0, 0, 90, 91, 92, 93,
94, 95, 96, 97, 0, 0, 0, 0, 0, 0,
0, 98, 99, 100, 101, 102, 103, 104, 105, 106,
107, 0, 108, 249, 84, 85, 86, 87, 0, 0,
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
88, 89, 0, 0, 0, 0, 0, 90, 91, 92,
93, 94, 95, 96, 97, 0, 0, 0, 0, 0,
0, 0, 98, 99, 100, 101, 102, 103, 104, 105,
106, 107, 0, 108, 302, 84, 85, 86, 87, 0,
Allow variable refs as object keys {$key:value}
2018-12-10 21:54:59 -06:00
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 88, 89, 0, 0, 0, 0, 0, 90, 91,
92, 93, 94, 95, 96, 97, 0, 0, 0, 0,
0, 0, 0, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 0, 108, 303, 84, 85, 86, 87,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 88, 89, 0, 0, 0, 0, 0, 90,
91, 92, 93, 94, 95, 96, 97, 0, 0, 0,
0, 0, 0, 0, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 0, 108, 306, 84, 85, 86,
87, 0, 0, 0, 0, 0, 0, 0, 250, 251,
0, 0, 252, 88, 89, 0, 0, 0, 0, 0,
90, 91, 92, 93, 94, 95, 96, 97, 0, 0,
0, 0, 0, 0, 0, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 0, 108, 84, 85, 86,
87, 0, 0, 0, 0, 0, 0, 130, 0, 0,
0, 0, 0, 88, 89, 0, 0, 0, 0, 0,
90, 91, 92, 93, 94, 95, 96, 97, 0, 0,
0, 84, 85, 86, 87, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 0, 108, 88, 89, 0,
0, 0, 0, 0, 90, 91, 92, 93, 94, 95,
96, 97, 0, 0, 0, 0, 284, 0, 0, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
108, 84, 85, 86, 87, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 300, 88, 89, 0,
0, 0, 0, 0, 90, 91, 92, 93, 94, 95,
96, 97, 0, 0, 0, 0, 0, 0, 0, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
108, 84, 85, 86, 87, 0, 0, 0, 0, 0,
0, 301, 0, 0, 0, 0, 0, 88, 89, 0,
0, 0, 0, 0, 90, 91, 92, 93, 94, 95,
96, 97, 0, 0, 0, 84, 85, 86, 87, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
108, 88, 89, 0, 0, 0, 0, 0, 90, 91,
92, 93, 94, 95, 96, 97, 0, 0, 0, 84,
85, 86, 87, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 0, 108, 88, 89, 0, 0, 0,
0, 0, 90, 91, 92, 93, 94, 95, 96, 97,
0, 0, 0, -157, 85, 86, 0, 0, 0, 100,
101, 102, 103, 104, 105, 106, 107, 0, 108, 88,
89, 0, 0, 0, 0, 0, -157, -157, -157, -157,
-157, -157, 96, 97, 0, 0, 85, 86, 0, 0,
0, 0, 0, -157, 101, 102, 103, 104, 105, 106,
107, 88, 108, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 96, 97, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 101, 102, 103, 104,
105, 106, 107, 0, 108
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
static const yytype_int16 yycheck[] =
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
1, 6, 16, 49, 8, 12, 13, 5, 145, 146,
11, 148, 149, 14, 5, 8, 14, 63, 19, 20,
180, 22, 68, 14, 49, 49, 21, 179, 23, 0,
49, 32, 32, 34, 35, 30, 31, 142, 42, 61,
1, 63, 66, 68, 63, 6, 151, 43, 44, 42,
46, 17, 18, 55, 56, 57, 5, 59, 131, 132,
65, 65, 67, 42, 5, 14, 64, 65, 43, 44,
60, 46, 62, 64, 65, 61, 213, 78, 4, 59,
6, 233, 4, 84, 85, 86, 87, 88, 89, 90,
Update parser.c
2015-05-25 13:17:22 -05:00
91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
101, 102, 103, 104, 105, 106, 107, 267, 260, 6,
262, 263, 264, 114, 266, 64, 65, 269, 113, 69,
120, 258, 259, 64, 65, 4, 29, 6, 129, 130,
48, 62, 133, 134, 1, 60, 143, 62, 145, 146,
59, 148, 149, 66, 68, 49, 63, 142, 63, 63,
63, 59, 304, 69, 14, 6, 151, 59, 41, 48,
41, 59, 61, 59, 48, 66, 1, 61, 63, 4,
5, 6, 7, 8, 9, 63, 63, 63, 63, 59,
15, 63, 59, 184, 19, 180, 187, 63, 23, 24,
59, 41, 193, 28, 59, 30, 31, 32, 59, 63,
59, 33, 31, 247, 307, 193, 213, 42, 209, 120,
4, 5, 6, 7, 8, 9, 267, 127, -1, 54,
-1, -1, -1, -1, -1, -1, 61, 228, 63, 64,
65, 66, 67, 234, 69, -1, -1, 31, 32, -1,
241, -1, -1, -1, -1, -1, -1, -1, 42, 250,
251, 258, 259, 254, 255, -1, -1, -1, -1, -1,
54, -1, -1, -1, -1, -1, -1, 61, -1, -1,
64, 65, 267, 67, -1, 69, -1, -1, 279, -1,
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
-1, -1, -1, -1, 0, 1, -1, -1, 4, 5,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
-1, -1, 8, -1, 10, 11, 12, 13, 14, -1,
301, 302, 303, -1, 20, 21, 22, -1, -1, 25,
26, 27, 313, 29, -1, -1, -1, 33, 34, 35,
36, 37, 38, 39, 40, -1, 42, -1, -1, 45,
-1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, -1, 59, 60, -1, 62, 63, 64, 65,
66, 1, 68, -1, 4, 5, 6, 7, 8, 9,
-1, -1, -1, -1, -1, 15, -1, -1, -1, 19,
-1, -1, -1, 23, 24, -1, -1, -1, 28, -1,
30, 31, 32, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 42, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 54, -1, -1, -1, -1, -1,
-1, 61, -1, -1, 64, 65, 66, 67, 1, 69,
-1, 4, 5, 6, 7, 8, 9, -1, -1, -1,
-1, -1, 15, -1, -1, -1, 19, -1, -1, -1,
23, 24, -1, -1, -1, 28, -1, 30, 31, 32,
-1, -1, 4, 5, 6, 7, 8, 9, -1, 42,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 1,
-1, 54, 4, 5, 6, 7, 8, 9, 61, 31,
32, 64, 65, 15, 67, -1, 69, 19, -1, -1,
42, 23, 24, -1, -1, -1, 28, -1, 30, 31,
32, -1, -1, -1, -1, -1, -1, -1, -1, 61,
42, -1, 64, 65, -1, 67, -1, 69, -1, -1,
1, -1, 54, 4, 5, 6, 7, 8, 9, 61,
-1, -1, 64, 65, 15, 67, -1, 69, 19, -1,
-1, -1, 23, 24, -1, -1, -1, 28, -1, 30,
31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 42, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 54, -1, -1, -1, -1, -1, -1,
61, -1, 1, 64, 65, 4, 67, 6, 69, 8,
-1, 11, 12, -1, -1, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, -1, -1, -1, -1, -1, -1, 39,
40, -1, -1, 42, -1, -1, -1, -1, -1, -1,
-1, 51, 52, 53, 54, 55, 56, 57, 1, 59,
-1, 4, 61, 6, -1, 8, -1, -1, -1, 68,
-1, 14, 15, 16, 17, 18, 19, 20, 21, 22,
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
23, 24, 25, 26, 27, 28, 29, 30, 31, 4,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
5, 6, 7, 8, 9, -1, -1, -1, -1, 42,
15, -1, -1, -1, 19, -1, -1, -1, 23, 24,
-1, -1, -1, 28, -1, 30, 31, 32, 61, -1,
-1, -1, -1, -1, -1, 68, -1, 42, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 54,
-1, -1, -1, -1, -1, 60, 61, -1, -1, 64,
65, -1, 67, -1, 69, 4, 5, 6, 7, 8,
9, -1, -1, -1, -1, -1, 15, -1, -1, -1,
19, -1, -1, -1, 23, 24, -1, -1, -1, 28,
-1, 30, 31, 32, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 42, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 54, -1, -1, -1, -1,
11, 12, 61, -1, -1, 64, 65, 66, 67, -1,
69, 4, 5, 6, 7, 8, 9, -1, -1, -1,
-1, -1, 15, -1, -1, -1, 19, -1, 39, 40,
23, 24, -1, -1, -1, 28, -1, 30, 31, 32,
51, 52, 53, 54, 55, 56, 57, -1, 59, 42,
Allow variable refs as object keys {$key:value}
2018-12-10 21:54:59 -06:00
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
-1, 54, -1, -1, -1, -1, -1, -1, 61, -1,
-1, 64, 65, 66, 67, -1, 69, 4, 5, 6,
7, 8, 9, -1, -1, -1, -1, -1, 15, -1,
-1, -1, 19, -1, -1, -1, 23, 24, -1, -1,
-1, 28, -1, 30, 31, 32, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 42, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 54, -1, -1,
-1, -1, -1, -1, 61, -1, 1, 64, 65, 4,
67, 6, 69, 8, -1, -1, -1, -1, -1, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 42, 10, 11,
12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 26, 27, 61, -1, -1, -1,
-1, 33, 34, 35, 36, 37, 38, 39, 40, -1,
-1, -1, 10, 11, 12, 13, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, -1, 59, 26, 27,
-1, 63, -1, -1, 66, 33, 34, 35, 36, 37,
38, 39, 40, -1, -1, -1, 10, 11, 12, 13,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-1, 59, 26, 27, -1, -1, -1, -1, 66, 33,
34, 35, 36, 37, 38, 39, 40, -1, -1, -1,
10, 11, 12, 13, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, -1, 59, 26, 27, -1, -1,
-1, -1, 66, 33, 34, 35, 36, 37, 38, 39,
40, -1, -1, -1, 10, 11, 12, 13, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
26, 27, -1, -1, -1, -1, 66, 33, 34, 35,
36, 37, 38, 39, 40, -1, -1, -1, 10, 11,
12, 13, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, -1, 59, 26, 27, -1, -1, -1, -1,
66, 33, 34, 35, 36, 37, 38, 39, 40, -1,
-1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
62, 10, 11, 12, 13, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 26, 27, -1,
-1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
39, 40, -1, -1, -1, 10, 11, 12, 13, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
59, 26, 27, 62, -1, -1, -1, -1, 33, 34,
35, 36, 37, 38, 39, 40, -1, -1, -1, 10,
11, 12, 13, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, -1, 59, 26, 27, 62, -1, -1,
-1, -1, 33, 34, 35, 36, 37, 38, 39, 40,
-1, -1, -1, 10, 11, 12, 13, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, -1, 59, 26,
27, 62, -1, -1, -1, -1, 33, 34, 35, 36,
37, 38, 39, 40, -1, -1, -1, 10, 11, 12,
13, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, -1, 59, 26, 27, 62, -1, -1, -1, -1,
33, 34, 35, 36, 37, 38, 39, 40, -1, -1,
-1, 10, 11, 12, 13, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, -1, 59, 26, 27, 62,
-1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
39, 40, -1, -1, -1, -1, -1, -1, -1, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
59, 60, 10, 11, 12, 13, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 26, 27,
-1, -1, -1, -1, -1, 33, 34, 35, 36, 37,
38, 39, 40, -1, -1, -1, -1, -1, -1, -1,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-1, 59, 60, 10, 11, 12, 13, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 26,
27, -1, -1, -1, -1, -1, 33, 34, 35, 36,
37, 38, 39, 40, -1, -1, -1, -1, -1, -1,
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, -1, 59, 60, 10, 11, 12, 13, -1, -1,
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
26, 27, -1, -1, -1, -1, -1, 33, 34, 35,
36, 37, 38, 39, 40, -1, -1, -1, -1, -1,
-1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, -1, 59, 60, 10, 11, 12, 13, -1,
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
-1, 26, 27, -1, -1, -1, -1, -1, 33, 34,
35, 36, 37, 38, 39, 40, -1, -1, -1, -1,
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, -1, 59, 60, 10, 11, 12, 13,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 26, 27, -1, -1, -1, -1, -1, 33,
34, 35, 36, 37, 38, 39, 40, -1, -1, -1,
-1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, -1, 59, 60, 10, 11, 12,
13, -1, -1, -1, -1, -1, -1, -1, 21, 22,
-1, -1, 25, 26, 27, -1, -1, -1, -1, -1,
33, 34, 35, 36, 37, 38, 39, 40, -1, -1,
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, -1, 59, 10, 11, 12,
13, -1, -1, -1, -1, -1, -1, 20, -1, -1,
-1, -1, -1, 26, 27, -1, -1, -1, -1, -1,
33, 34, 35, 36, 37, 38, 39, 40, -1, -1,
-1, 10, 11, 12, 13, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, -1, 59, 26, 27, -1,
-1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
39, 40, -1, -1, -1, -1, 45, -1, -1, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
59, 10, 11, 12, 13, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 25, 26, 27, -1,
-1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
39, 40, -1, -1, -1, -1, -1, -1, -1, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
59, 10, 11, 12, 13, -1, -1, -1, -1, -1,
-1, 20, -1, -1, -1, -1, -1, 26, 27, -1,
-1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
39, 40, -1, -1, -1, 10, 11, 12, 13, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
59, 26, 27, -1, -1, -1, -1, -1, 33, 34,
35, 36, 37, 38, 39, 40, -1, -1, -1, 10,
11, 12, 13, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, -1, 59, 26, 27, -1, -1, -1,
-1, -1, 33, 34, 35, 36, 37, 38, 39, 40,
-1, -1, -1, 10, 11, 12, -1, -1, -1, 50,
51, 52, 53, 54, 55, 56, 57, -1, 59, 26,
27, -1, -1, -1, -1, -1, 33, 34, 35, 36,
37, 38, 39, 40, -1, -1, 11, 12, -1, -1,
-1, -1, -1, 50, 51, 52, 53, 54, 55, 56,
57, 26, 59, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 39, 40, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 51, 52, 53, 54,
55, 56, 57, -1, 59
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
state STATE-NUM. */
static const yytype_int8 yystos[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 16, 71, 72, 4, 5, 6, 7, 8, 9,
15, 19, 23, 24, 28, 30, 31, 32, 42, 54,
61, 64, 65, 67, 69, 75, 79, 82, 88, 0,
17, 18, 73, 76, 77, 61, 59, 42, 4, 75,
88, 88, 75, 6, 1, 6, 83, 75, 1, 75,
1, 4, 8, 82, 1, 66, 75, 1, 4, 6,
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
24, 25, 26, 27, 28, 29, 30, 31, 61, 82,
97, 98, 99, 69, 10, 11, 12, 13, 26, 27,
33, 34, 35, 36, 37, 38, 39, 40, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 59, 60,
75, 5, 14, 64, 65, 78, 82, 78, 74, 75,
79, 73, 60, 75, 75, 89, 90, 84, 61, 63,
20, 14, 14, 29, 48, 85, 62, 62, 1, 59,
66, 66, 49, 63, 68, 63, 63, 75, 63, 63,
68, 49, 69, 75, 75, 75, 75, 75, 75, 75,
75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
75, 75, 75, 75, 75, 75, 75, 59, 6, 65,
67, 91, 92, 93, 65, 82, 1, 63, 66, 75,
14, 74, 60, 60, 62, 85, 4, 6, 80, 81,
75, 1, 75, 92, 92, 1, 75, 75, 43, 44,
46, 1, 98, 54, 87, 88, 87, 87, 62, 87,
87, 98, 6, 93, 94, 1, 4, 6, 61, 82,
95, 96, 97, 41, 48, 66, 75, 59, 66, 75,
59, 63, 66, 4, 6, 90, 46, 60, 62, 60,
21, 22, 25, 86, 61, 61, 75, 87, 48, 63,
49, 66, 63, 63, 63, 75, 63, 49, 68, 63,
93, 75, 59, 66, 66, 66, 75, 59, 81, 63,
75, 75, 75, 75, 45, 87, 87, 93, 93, 93,
93, 62, 93, 96, 93, 59, 59, 59, 66, 75,
25, 20, 60, 60, 63, 59, 60, 75, 75, 75,
93, 86, 62, 60, 62, 75, 62
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
static const yytype_int8 yyr1[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
0, 70, 71, 71, 72, 72, 73, 73, 74, 74,
75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
75, 75, 75, 75, 75, 75, 75, 75, 76, 76,
77, 77, 77, 78, 79, 79, 80, 80, 81, 81,
83, 82, 84, 82, 85, 85, 85, 86, 86, 86,
87, 87, 87, 88, 88, 88, 88, 88, 88, 88,
88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
88, 88, 88, 88, 88, 88, 88, 89, 89, 90,
91, 91, 92, 92, 93, 93, 93, 94, 94, 95,
95, 96, 96, 96, 96, 96, 96, 96, 97, 97,
97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
97, 97, 97, 97, 97, 97, 98, 98, 98, 98,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
static const yytype_int8 yyr2[] =
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
0, 2, 3, 3, 0, 3, 0, 2, 0, 2,
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
2, 5, 9, 11, 9, 5, 4, 4, 2, 4,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
4, 2, 3, 3, 3, 3, 3, 3, 3, 3,
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
3, 3, 2, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 1, 2, 3,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
4, 4, 2, 1, 5, 8, 1, 3, 1, 1,
0, 4, 0, 5, 0, 2, 4, 5, 3, 1,
3, 2, 1, 1, 1, 2, 2, 3, 2, 4,
3, 2, 1, 3, 2, 2, 3, 5, 4, 6,
5, 4, 3, 5, 4, 7, 6, 6, 6, 5,
5, 1, 1, 1, 3, 3, 2, 3, 4, 1,
1, 1, 4, 3, 3, 4, 3, 1, 3, 1,
3, 1, 3, 1, 1, 3, 3, 1, 3, 1,
3, 1, 3, 3, 3, 3, 5, 3, 1, 1,
Update parser.c
2015-05-25 13:17:22 -05:00
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
1, 1, 1, 1, 1, 1, 0, 1, 3, 3,
3, 3, 3, 1, 3, 1, 1, 1, 5, 3
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
};
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
enum { YYENOMEM = -2 };
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define YYNOMEM goto yyexhaustedlab
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#define YYRECOVERING() (!!yyerrstatus)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Backward compatibility with an undocumented macro.
Use YYerror or YYUNDEF. */
#define YYERRCODE YYUNDEF
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (0)
#endif
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
/* Enable debugging if requested. */
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYLOCATION_PRINT -- Print the location on the stream.
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
This macro was not mandated originally: define only if we know
we won't break user code: when these are the locations we know. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# ifndef YYLOCATION_PRINT
# if defined YY_LOCATION_PRINT
/* Temporary convenience wrapper in case some people defined the
undocumented and private YY_LOCATION_PRINT macros. */
# define YYLOCATION_PRINT(File, Loc) YY_LOCATION_PRINT(File, *(Loc))
# elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
YY_ATTRIBUTE_UNUSED
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
static int
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int res = 0;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
if (0 <= yylocp->first_line)
{
res += YYFPRINTF (yyo, "%d", yylocp->first_line);
if (0 <= yylocp->first_column)
res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
}
if (0 <= yylocp->last_line)
{
if (yylocp->first_line < yylocp->last_line)
{
res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
if (0 <= end_col)
res += YYFPRINTF (yyo, ".%d", end_col);
}
else if (0 <= end_col && yylocp->first_column < end_col)
res += YYFPRINTF (yyo, "-%d", end_col);
}
return res;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YYLOCATION_PRINT yy_location_print_
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Temporary convenience wrapper in case some people defined the
undocumented and private YY_LOCATION_PRINT macros. */
# define YY_LOCATION_PRINT(File, Loc) YYLOCATION_PRINT(File, &(Loc))
# else
# define YYLOCATION_PRINT(File, Loc) ((void) 0)
/* Temporary convenience wrapper in case some people defined the
undocumented and private YY_LOCATION_PRINT macros. */
# define YY_LOCATION_PRINT YYLOCATION_PRINT
# endif
# endif /* !defined YYLOCATION_PRINT */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Kind, Value, Location, answer, errors, locations, lexer_param_ptr); \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/*-----------------------------------.
| Print this symbol's value on YYO. |
`-----------------------------------*/
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static void
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_symbol_value_print (FILE *yyo,
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
FILE *yyoutput = yyo;
YY_USE (yyoutput);
YY_USE (yylocationp);
YY_USE (answer);
YY_USE (errors);
YY_USE (locations);
YY_USE (lexer_param_ptr);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (!yyvaluep)
return;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YY_USE (yykind);
YY_IGNORE_MAYBE_UNINITIALIZED_END
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/*---------------------------.
| Print this symbol on YYO. |
`---------------------------*/
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static void
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_symbol_print (FILE *yyo,
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYFPRINTF (yyo, "%s %s (",
yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYLOCATION_PRINT (yyo, yylocationp);
YYFPRINTF (yyo, ": ");
yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr);
YYFPRINTF (yyo, ")");
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
static void
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
static void
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
int yyrule, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int yylno = yyrline[yyrule];
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yynrhs = yyr2[yyrule];
int yyi;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr,
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
&yyvsp[(yyi + 1) - (yynrhs)],
&(yylsp[(yyi + 1) - (yynrhs)]), answer, errors, locations, lexer_param_ptr);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYFPRINTF (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyssp, yyvsp, yylsp, Rule, answer, errors, locations, lexer_param_ptr); \
} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# define YYDPRINTF(Args) ((void) 0)
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Context of a parse error. */
typedef struct
{
yy_state_t *yyssp;
yysymbol_kind_t yytoken;
YYLTYPE *yylloc;
} yypcontext_t;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Put in YYARG at most YYARGN of the expected tokens given the
current YYCTX, and return the number of tokens stored in YYARG. If
YYARG is null, return the number of expected tokens (guaranteed to
be less than YYNTOKENS). Return YYENOMEM on memory exhaustion.
Return 0 if there are more than YYARGN expected tokens, yet fill
YYARG up to YYARGN. */
static int
yypcontext_expected_tokens (const yypcontext_t *yyctx,
yysymbol_kind_t yyarg[], int yyargn)
{
/* Actual size of YYARG. */
int yycount = 0;
int yyn = yypact[+*yyctx->yyssp];
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (!yyarg)
++yycount;
else if (yycount == yyargn)
return 0;
else
yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
}
}
if (yyarg && yycount == 0 && 0 < yyargn)
yyarg[0] = YYSYMBOL_YYEMPTY;
return yycount;
}
#ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
# else
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Return the length of YYSTR. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
static YYPTRDIFF_T
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yystrlen (const char *yystr)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yylen;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#ifndef yytnamerr
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result
would have been. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
static YYPTRDIFF_T
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yyn = 0;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
else
goto append;
append:
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
if (yyres)
return yystpcpy (yyres, yystr) - yyres;
else
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
return yystrlen (yystr);
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
static int
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_syntax_error_arguments (const yypcontext_t *yyctx,
yysymbol_kind_t yyarg[], int yyargn)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Actual size of YYARG. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yycount = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int yyn;
if (yyarg)
yyarg[yycount] = yyctx->yytoken;
++yycount;
yyn = yypcontext_expected_tokens (yyctx,
yyarg ? yyarg + 1 : yyarg, yyargn - 1);
if (yyn == YYENOMEM)
return YYENOMEM;
else
yycount += yyn;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
return yycount;
}
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is
not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the
required number of bytes is too large to store. */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
const yypcontext_t *yyctx)
{
enum { YYARGS_MAX = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat: reported tokens (one for the "unexpected",
one per "expected"). */
yysymbol_kind_t yyarg[YYARGS_MAX];
/* Cumulated lengths of YYARG. */
YYPTRDIFF_T yysize = 0;
/* Actual size of YYARG. */
int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
if (yycount == YYENOMEM)
return YYENOMEM;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
switch (yycount)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#define YYCASE_(N, S) \
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
case N: \
yyformat = S; \
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
break
default: /* Avoid compiler warnings. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#undef YYCASE_
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Compute error message size. Don't count the "%s"s, but reserve
room for the terminator. */
yysize = yystrlen (yyformat) - 2 * yycount + 1;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int yyi;
for (yyi = 0; yyi < yycount; ++yyi)
{
YYPTRDIFF_T yysize1
= yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
yysize = yysize1;
else
return YYENOMEM;
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
if (*yymsg_alloc < yysize)
{
*yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
return -1;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
/* Avoid sprintf, as that infringes on the user's name space.
Don't have undefined behavior even if the translation
produced a string with the wrong number of "%s"s. */
{
char *yyp = *yymsg;
int yyi = 0;
while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yyformat += 2;
}
else
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
++yyp;
++yyformat;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
}
return 0;
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
static void
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yydestruct (const char *yymsg,
yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_USE (yyvaluep);
YY_USE (yylocationp);
YY_USE (answer);
YY_USE (errors);
YY_USE (locations);
YY_USE (lexer_param_ptr);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (!yymsg)
yymsg = "Deleting";
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
switch (yykind)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_IDENT: /* IDENT */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2191 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_FIELD: /* FIELD */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2197 "src/parser.c"
break;
case YYSYMBOL_BINDING: /* BINDING */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
#line 2203 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_LITERAL: /* LITERAL */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2209 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_FORMAT: /* FORMAT */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2215 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_QQSTRING_TEXT: /* QQSTRING_TEXT */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2221 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Module: /* Module */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2227 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Imports: /* Imports */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2233 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_FuncDefs: /* FuncDefs */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2239 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Exp: /* Exp */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2245 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Import: /* Import */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2251 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ImportWhat: /* ImportWhat */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2257 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ImportFrom: /* ImportFrom */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2263 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_FuncDef: /* FuncDef */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2269 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Params: /* Params */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2275 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Param: /* Param */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2281 "src/parser.c"
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_String: /* String */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2287 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_QQString: /* QQString */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2293 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ElseBody: /* ElseBody */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2299 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ExpD: /* ExpD */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2305 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Term: /* Term */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2311 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Args: /* Args */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2317 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Arg: /* Arg */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2323 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_RepPatterns: /* RepPatterns */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2329 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Patterns: /* Patterns */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2335 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Pattern: /* Pattern */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2341 "src/parser.c"
Update parser.c
2015-05-25 13:17:22 -05:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ArrayPats: /* ArrayPats */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2347 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ObjPats: /* ObjPats */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2353 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_ObjPat: /* ObjPat */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2359 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_Keyword: /* Keyword */
#line 36 "src/parser.y"
{ jv_free(((*yyvaluep).literal)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2365 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_MkDict: /* MkDict */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2371 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case YYSYMBOL_MkDictPair: /* MkDictPair */
#line 37 "src/parser.y"
{ block_free(((*yyvaluep).blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2377 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
default:
break;
}
YY_IGNORE_MAYBE_UNINITIALIZED_END
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/*----------.
| yyparse. |
`----------*/
int
yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Lookahead token kind. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yychar;
/* The semantic value of the lookahead symbol. */
/* Default value used for initialization, for pacifying older GCCs
or non-GCC compilers. */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
/* Location data for the lookahead symbol. */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
= { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;
/* Number of syntax errors so far. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int yynerrs = 0;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_state_fast_t yystate = 0;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Number of tokens to shift before error messages enabled. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
int yyerrstatus = 0;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Refer to the stacks through separate pointers, to allow yyoverflow
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
to reallocate them elsewhere. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Their size. */
YYPTRDIFF_T yystacksize = YYINITDEPTH;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* The state stack: array, bottom, top. */
yy_state_t yyssa[YYINITDEPTH];
yy_state_t *yyss = yyssa;
yy_state_t *yyssp = yyss;
/* The semantic value stack: array, bottom, top. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYSTYPE yyvsa[YYINITDEPTH];
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYSTYPE *yyvs = yyvsa;
YYSTYPE *yyvsp = yyvs;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* The location stack: array, bottom, top. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYLTYPE yylsa[YYINITDEPTH];
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp = yyls;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yyn;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* The return value of yyparse. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int yyresult;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Lookahead symbol kind. */
yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
YYLTYPE yyloc;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* The locations where the error started and ended. */
YYLTYPE yyerror_range[3];
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
YYDPRINTF ((stderr, "Starting parse\n"));
yychar = YYEMPTY; /* Cause a token to be read. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yylsp[0] = yylloc;
goto yysetstate;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/*------------------------------------------------------------.
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
| yynewstate -- push a new state, which is found in yystate. |
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
`------------------------------------------------------------*/
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yynewstate:
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate. |
`--------------------------------------------------------------------*/
yysetstate:
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
YY_IGNORE_USELESS_CAST_BEGIN
*yyssp = YY_CAST (yy_state_t, yystate);
YY_IGNORE_USELESS_CAST_END
YY_STACK_PRINT (yyss, yyssp);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yyss + yystacksize - 1 <= yyssp)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
YYNOMEM;
#else
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
/* Get the current used size of the three stacks, in elements. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYPTRDIFF_T yysize = yyssp - yyss + 1;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# if defined yyoverflow
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_state_t *yyss1 = yyss;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYSTYPE *yyvs1 = yyvs;
YYLTYPE *yyls1 = yyls;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
&yyss1, yysize * YYSIZEOF (*yyssp),
&yyvs1, yysize * YYSIZEOF (*yyvsp),
&yyls1, yysize * YYSIZEOF (*yylsp),
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
&yystacksize);
yyss = yyss1;
yyvs = yyvs1;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yyls = yyls1;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
# else /* defined YYSTACK_RELOCATE */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYNOMEM;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yy_state_t *yyss1 = yyss;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
union yyalloc *yyptr =
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_CAST (union yyalloc *,
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (! yyptr)
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYNOMEM;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
YYSTACK_RELOCATE (yyls_alloc, yyls);
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
# undef YYSTACK_RELOCATE
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
yylsp = yyls + yysize - 1;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_IGNORE_USELESS_CAST_BEGIN
YYDPRINTF ((stderr, "Stack size increased to %ld\n",
YY_CAST (long, yystacksize)));
YY_IGNORE_USELESS_CAST_END
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yystate == YYFINAL)
YYACCEPT;
goto yybackup;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yypact_value_is_default (yyn))
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yychar == YYEMPTY)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YYDPRINTF ((stderr, "Reading a token\n"));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yychar = yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
}
if (yychar <= YYEOF)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yychar = YYEOF;
yytoken = YYSYMBOL_YYEOF;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
else if (yychar == YYerror)
{
/* The scanner already issued an error message, process directly
to error recovery. But do not keep the error token as
lookahead, it is too special and may lead us to an endless
loop in error recovery. */
yychar = YYUNDEF;
yytoken = YYSYMBOL_YYerror;
yyerror_range[1] = yylloc;
goto yyerrlab1;
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yytable_value_is_error (yyn))
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
*++yylsp = yylloc;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Discard the shifted token. */
yychar = YYEMPTY;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
| yyreduce -- do a reduction. |
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
'$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Default location. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yyerror_range[1] = yyloc;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 2: /* TopLevel: Module Imports Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 307 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
*answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), gen_op_simple(TOP), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2685 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 3: /* TopLevel: Module Imports FuncDefs */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 310 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
*answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2693 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 4: /* Module: %empty */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 315 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2701 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 5: /* Module: "module" Exp ';' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 318 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (!block_is_const((yyvsp[-1].blk))) {
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
FAIL((yyloc), "Module metadata must be constant");
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_noop();
Fix memory leak in non-constant module declaration
2015-08-12 00:59:30 -07:00
block_free((yyvsp[-1].blk));
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
} else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) {
FAIL((yyloc), "Module metadata must be an object");
(yyval.blk) = gen_noop();
block_free((yyvsp[-1].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
} else {
(yyval.blk) = gen_module((yyvsp[-1].blk));
}
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2719 "src/parser.c"
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 6: /* Imports: %empty */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 333 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2727 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 7: /* Imports: Import Imports */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 336 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = BLOCK((yyvsp[-1].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2735 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 8: /* FuncDefs: %empty */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 341 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_noop();
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2743 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 9: /* FuncDefs: FuncDef FuncDefs */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 344 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Make builtin binding fast again by binding only referenced symbols
2019-02-20 01:48:56 -05:00
(yyval.blk) = block_join((yyvsp[-1].blk), (yyvsp[0].blk));
Update parser.c
2015-05-25 13:17:22 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2751 "src/parser.c"
Update parser.c
2015-05-25 13:17:22 -05:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 10: /* Exp: FuncDef Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 349 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = block_bind_referenced((yyvsp[-1].blk), (yyvsp[0].blk), OP_IS_CALL_PSEUDO);
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2759 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 11: /* Exp: Term "as" Patterns '|' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 353 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_destructure((yyvsp[-4].blk), (yyvsp[-2].blk), (yyvsp[0].blk));
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2767 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 12: /* Exp: "reduce" Term "as" Patterns '(' Exp ';' Exp ')' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 356 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_reduce((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk));
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2775 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 13: /* Exp: "foreach" Term "as" Patterns '(' Exp ';' Exp ';' Exp ')' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 360 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_foreach((yyvsp[-9].blk), (yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk));
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2783 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 14: /* Exp: "foreach" Term "as" Patterns '(' Exp ';' Exp ')' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 364 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_foreach((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), gen_noop());
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2791 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
case 15: /* Exp: "if" Exp "then" Exp ElseBody */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 368 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2799 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 16: /* Exp: "if" Exp "then" error */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 371 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
FAIL((yyloc), "Possibly unterminated 'if' statement");
(yyval.blk) = (yyvsp[-2].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2808 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 17: /* Exp: "try" Exp "catch" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 376 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
//$$ = BLOCK(gen_op_target(FORK_OPT, $2), $2, $4);
(yyval.blk) = gen_try((yyvsp[-2].blk), gen_try_handler((yyvsp[0].blk)));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2817 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 18: /* Exp: "try" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 380 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
//$$ = BLOCK(gen_op_target(FORK_OPT, $2), $2, gen_op_simple(BACKTRACK));
(yyval.blk) = gen_try((yyvsp[0].blk), gen_op_simple(BACKTRACK));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2826 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 19: /* Exp: "try" Exp "catch" error */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 384 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
FAIL((yyloc), "Possibly unterminated 'try' statement");
(yyval.blk) = (yyvsp[-2].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2835 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 20: /* Exp: "label" BINDING '|' Exp */
#line 389 "src/parser.y"
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[-2].literal)));
(yyval.blk) = gen_location((yyloc), locations, gen_label(jv_string_value(v), (yyvsp[0].blk)));
jv_free((yyvsp[-2].literal));
jv_free(v);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2846 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 21: /* Exp: Exp '?' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 396 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_try((yyvsp[-1].blk), gen_op_simple(BACKTRACK));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2854 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 22: /* Exp: Exp '=' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 400 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_call("_assign", BLOCK(gen_lambda((yyvsp[-2].blk)), gen_lambda((yyvsp[0].blk))));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2862 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 23: /* Exp: Exp "or" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 404 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_or((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2870 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 24: /* Exp: Exp "and" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 408 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_and((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2878 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 25: /* Exp: Exp "//" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 412 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_definedor((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2886 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 26: /* Exp: Exp "//=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 416 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_definedor_assign((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2894 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 27: /* Exp: Exp "|=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 420 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_call("_modify", BLOCK(gen_lambda((yyvsp[-2].blk)), gen_lambda((yyvsp[0].blk))));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2902 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 28: /* Exp: Exp '|' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 424 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2910 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 29: /* Exp: Exp ',' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 428 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_both((yyvsp[-2].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2918 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 30: /* Exp: Exp '+' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 432 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '+');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2926 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 31: /* Exp: Exp "+=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 436 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '+');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2934 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 32: /* Exp: '-' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 440 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = BLOCK((yyvsp[0].blk), gen_call("_negate", gen_noop()));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2942 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 33: /* Exp: Exp '-' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 444 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '-');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2950 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 34: /* Exp: Exp "-=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 448 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '-');
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2958 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 35: /* Exp: Exp '*' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 452 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '*');
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2966 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 36: /* Exp: Exp "*=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 456 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '*');
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2974 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 37: /* Exp: Exp '/' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 460 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '/');
Fix #814: raise on div-0, add inf isinf nan isnan
2015-06-17 19:46:57 -05:00
if (block_is_const_inf((yyval.blk)))
FAIL((yyloc), "Division by zero?");
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2984 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 38: /* Exp: Exp '%' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 466 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '%');
Fix #814: raise on div-0, add inf isinf nan isnan
2015-06-17 19:46:57 -05:00
if (block_is_const_inf((yyval.blk)))
FAIL((yyloc), "Remainder by zero?");
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 2994 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 39: /* Exp: Exp "/=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 472 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '/');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3002 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 40: /* Exp: Exp "%=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 476 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '%');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3010 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 41: /* Exp: Exp "==" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 480 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), EQ);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3018 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 42: /* Exp: Exp "!=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 484 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), NEQ);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3026 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 43: /* Exp: Exp '<' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 488 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '<');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3034 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 44: /* Exp: Exp '>' Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 492 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '>');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3042 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 45: /* Exp: Exp "<=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 496 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), LESSEQ);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3050 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 46: /* Exp: Exp ">=" Exp */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 500 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), GREATEREQ);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3058 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 47: /* Exp: Term */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 504 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = (yyvsp[0].blk);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3066 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 48: /* Import: ImportWhat ';' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 509 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = (yyvsp[-1].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3074 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 49: /* Import: ImportWhat Exp ';' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 512 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
if (!block_is_const((yyvsp[-1].blk))) {
FAIL((yyloc), "Module metadata must be constant");
(yyval.blk) = gen_noop();
block_free((yyvsp[-2].blk));
block_free((yyvsp[-1].blk));
} else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) {
FAIL((yyloc), "Module metadata must be an object");
(yyval.blk) = gen_noop();
block_free((yyvsp[-2].blk));
block_free((yyvsp[-1].blk));
} else {
(yyval.blk) = gen_import_meta((yyvsp[-2].blk), (yyvsp[-1].blk));
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3094 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 50: /* ImportWhat: "import" ImportFrom "as" BINDING */
#line 529 "src/parser.y"
{
jv v = block_const((yyvsp[-2].blk));
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
// XXX Make gen_import take only blocks and the int is_data so we
// don't have to free so much stuff here
(yyval.blk) = gen_import(jv_string_value(v), jv_string_value((yyvsp[0].literal)), 1);
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
block_free((yyvsp[-2].blk));
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
jv_free((yyvsp[0].literal));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
jv_free(v);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3108 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 51: /* ImportWhat: "import" ImportFrom "as" IDENT */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 538 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
jv v = block_const((yyvsp[-2].blk));
(yyval.blk) = gen_import(jv_string_value(v), jv_string_value((yyvsp[0].literal)), 0);
block_free((yyvsp[-2].blk));
jv_free((yyvsp[0].literal));
jv_free(v);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3120 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 52: /* ImportWhat: "include" ImportFrom */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 545 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on non-object import metadata (fix #900)
2015-08-11 23:26:51 -07:00
jv v = block_const((yyvsp[0].blk));
(yyval.blk) = gen_import(jv_string_value(v), NULL, 0);
block_free((yyvsp[0].blk));
jv_free(v);
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3131 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 53: /* ImportFrom: String */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 553 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
if (!block_is_const((yyvsp[0].blk))) {
FAIL((yyloc), "Import path must be constant");
(yyval.blk) = gen_const(jv_string(""));
block_free((yyvsp[0].blk));
} else {
(yyval.blk) = (yyvsp[0].blk);
}
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3145 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 54: /* FuncDef: "def" IDENT ':' Exp ';' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 564 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_function(jv_string_value((yyvsp[-3].literal)), gen_noop(), (yyvsp[-1].blk));
jv_free((yyvsp[-3].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3154 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 55: /* FuncDef: "def" IDENT '(' Params ')' ':' Exp ';' */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 569 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_function(jv_string_value((yyvsp[-6].literal)), (yyvsp[-4].blk), (yyvsp[-1].blk));
jv_free((yyvsp[-6].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3163 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 56: /* Params: Param */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 575 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = (yyvsp[0].blk);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3171 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
case 57: /* Params: Params ';' Param */
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 578 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3179 "src/parser.c"
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 58: /* Param: BINDING */
#line 583 "src/parser.y"
{
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
(yyval.blk) = gen_param_regular(jv_string_value((yyvsp[0].literal)));
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3188 "src/parser.c"
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 59: /* Param: IDENT */
#line 587 "src/parser.y"
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
{
(yyval.blk) = gen_param(jv_string_value((yyvsp[0].literal)));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3197 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 60: /* @1: %empty */
#line 594 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{ (yyval.literal) = jv_string("text"); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3203 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 61: /* String: QQSTRING_START @1 QQString QQSTRING_END */
#line 594 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
(yyval.blk) = (yyvsp[-1].blk);
jv_free((yyvsp[-2].literal));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3212 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 62: /* @2: %empty */
#line 598 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{ (yyval.literal) = (yyvsp[-1].literal); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3218 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 63: /* String: FORMAT QQSTRING_START @2 QQString QQSTRING_END */
#line 598 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = (yyvsp[-1].blk);
jv_free((yyvsp[-2].literal));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3227 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 64: /* QQString: %empty */
#line 605 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_const(jv_string(""));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3235 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 65: /* QQString: QQString QQSTRING_TEXT */
#line 608 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_binop((yyvsp[-1].blk), gen_const((yyvsp[0].literal)), '+');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3243 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 66: /* QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END */
#line 611 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_binop((yyvsp[-3].blk), gen_format((yyvsp[-1].blk), jv_copy((yyvsp[-4].literal))), '+');
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3251 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 67: /* ElseBody: "elif" Exp "then" Exp ElseBody */
#line 617 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3259 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 68: /* ElseBody: "else" Exp "end" */
#line 620 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = (yyvsp[-1].blk);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3267 "src/parser.c"
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 69: /* ElseBody: "end" */
#line 623 "src/parser.y"
Support optional else-branch for if-then-elif-end (#2598)
2023-07-04 00:51:29 +02:00
{
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3275 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 70: /* ExpD: ExpD '|' ExpD */
#line 628 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3283 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 71: /* ExpD: '-' ExpD */
#line 631 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = BLOCK((yyvsp[0].blk), gen_call("_negate", gen_noop()));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3291 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 72: /* ExpD: Term */
#line 634 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = (yyvsp[0].blk);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3299 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 73: /* Term: '.' */
#line 640 "src/parser.y"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_noop();
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3307 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 74: /* Term: ".." */
#line 643 "src/parser.y"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
{
(yyval.blk) = gen_call("recurse", gen_noop());
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3315 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 75: /* Term: "break" BINDING */
#line 646 "src/parser.y"
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[0].literal))); // impossible symbol
(yyval.blk) = gen_location((yyloc), locations,
BLOCK(gen_op_unbound(LOADV, jv_string_value(v)),
gen_call("error", gen_noop())));
jv_free(v);
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3328 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 76: /* Term: "break" error */
#line 654 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Drop name-less label/break for now
2015-03-23 14:57:35 -05:00
FAIL((yyloc), "break requires a label to break to");
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3337 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 77: /* Term: Term FIELD '?' */
#line 658 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index_opt((yyvsp[-2].blk), gen_const((yyvsp[-1].literal)));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3345 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 78: /* Term: FIELD '?' */
#line 661 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index_opt(gen_noop(), gen_const((yyvsp[-1].literal)));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3353 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 79: /* Term: Term '.' String '?' */
#line 664 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index_opt((yyvsp[-3].blk), (yyvsp[-1].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3361 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 80: /* Term: '.' String '?' */
#line 667 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index_opt(gen_noop(), (yyvsp[-1].blk));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3369 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 81: /* Term: Term FIELD */
#line 670 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index((yyvsp[-1].blk), gen_const((yyvsp[0].literal)));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3377 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 82: /* Term: FIELD */
#line 673 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index(gen_noop(), gen_const((yyvsp[0].literal)));
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3385 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 83: /* Term: Term '.' String */
#line 676 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index((yyvsp[-2].blk), (yyvsp[0].blk));
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3393 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 84: /* Term: '.' String */
#line 679 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index(gen_noop(), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3401 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 85: /* Term: '.' error */
#line 682 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields");
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3410 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 86: /* Term: '.' IDENT error */
#line 686 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
jv_free((yyvsp[-1].literal));
FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields");
(yyval.blk) = gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3420 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 87: /* Term: Term '[' Exp ']' '?' */
#line 692 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index_opt((yyvsp[-4].blk), (yyvsp[-2].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3428 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 88: /* Term: Term '[' Exp ']' */
#line 695 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
(yyval.blk) = gen_index((yyvsp[-3].blk), (yyvsp[-1].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3436 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 89: /* Term: Term '.' '[' Exp ']' '?' */
#line 698 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_index_opt((yyvsp[-5].blk), (yyvsp[-2].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3444 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 90: /* Term: Term '.' '[' Exp ']' */
#line 701 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_index((yyvsp[-4].blk), (yyvsp[-1].blk));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3452 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 91: /* Term: Term '[' ']' '?' */
#line 704 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH_OPT));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3460 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 92: /* Term: Term '[' ']' */
#line 707 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = block_join((yyvsp[-2].blk), gen_op_simple(EACH));
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3468 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 93: /* Term: Term '.' '[' ']' '?' */
#line 710 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = block_join((yyvsp[-4].blk), gen_op_simple(EACH_OPT));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3476 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 94: /* Term: Term '.' '[' ']' */
#line 713 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3484 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 95: /* Term: Term '[' Exp ':' Exp ']' '?' */
#line 716 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-6].blk), (yyvsp[-4].blk), (yyvsp[-2].blk), INDEX_OPT);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3492 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 96: /* Term: Term '[' Exp ':' ']' '?' */
#line 719 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), gen_const(jv_null()), INDEX_OPT);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3500 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 97: /* Term: Term '[' ':' Exp ']' '?' */
#line 722 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-5].blk), gen_const(jv_null()), (yyvsp[-2].blk), INDEX_OPT);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3508 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 98: /* Term: Term '[' Exp ':' Exp ']' */
#line 725 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), INDEX);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3516 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 99: /* Term: Term '[' Exp ':' ']' */
#line 728 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-4].blk), (yyvsp[-2].blk), gen_const(jv_null()), INDEX);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3524 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 100: /* Term: Term '[' ':' Exp ']' */
#line 731 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_slice_index((yyvsp[-4].blk), gen_const(jv_null()), (yyvsp[-1].blk), INDEX);
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3532 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 101: /* Term: LITERAL */
#line 734 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_const((yyvsp[0].literal));
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3540 "src/parser.c"
Restore import into caller's namespace
2015-06-26 23:40:37 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 102: /* Term: String */
#line 737 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = (yyvsp[0].blk);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3548 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 103: /* Term: FORMAT */
#line 740 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_format(gen_noop(), (yyvsp[0].literal));
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3556 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 104: /* Term: '(' Exp ')' */
#line 743 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = (yyvsp[-1].blk);
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3564 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 105: /* Term: '[' Exp ']' */
#line 746 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_collect((yyvsp[-1].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3572 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 106: /* Term: '[' ']' */
#line 749 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_const(jv_array());
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3580 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 107: /* Term: '{' MkDict '}' */
#line 752 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
block o = gen_const_object((yyvsp[-1].blk));
if (o.first != NULL)
(yyval.blk) = o;
else
(yyval.blk) = BLOCK(gen_subexp(gen_const(jv_object())), (yyvsp[-1].blk), gen_op_simple(POP));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3592 "src/parser.c"
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 108: /* Term: '$' '$' '$' BINDING */
#line 774 "src/parser.y"
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADVN, jv_string_value((yyvsp[0].literal))));
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3601 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 109: /* Term: BINDING */
#line 778 "src/parser.y"
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal))));
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3610 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 110: /* Term: "$__loc__" */
#line 782 "src/parser.y"
{
(yyval.blk) = gen_const(JV_OBJECT(jv_string("file"), jv_copy(locations->fname),
jv_string("line"), jv_number(locfile_get_line(locations, (yyloc).start) + 1)));
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3619 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 111: /* Term: IDENT */
#line 786 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
const char *s = jv_string_value((yyvsp[0].literal));
if (strcmp(s, "false") == 0)
(yyval.blk) = gen_const(jv_false());
else if (strcmp(s, "true") == 0)
(yyval.blk) = gen_const(jv_true());
else if (strcmp(s, "null") == 0)
(yyval.blk) = gen_const(jv_null());
else
(yyval.blk) = gen_location((yyloc), locations, gen_call(s, gen_noop()));
jv_free((yyvsp[0].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3636 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 112: /* Term: IDENT '(' Args ')' */
#line 798 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
(yyval.blk) = gen_call(jv_string_value((yyvsp[-3].literal)), (yyvsp[-1].blk));
(yyval.blk) = gen_location((yylsp[-3]), locations, (yyval.blk));
jv_free((yyvsp[-3].literal));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3646 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 113: /* Term: '(' error ')' */
#line 803 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = gen_noop(); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3652 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 114: /* Term: '[' error ']' */
#line 804 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = gen_noop(); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3658 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 115: /* Term: Term '[' error ']' */
#line 805 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = (yyvsp[-3].blk); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3664 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 116: /* Term: '{' error '}' */
#line 806 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = gen_noop(); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3670 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 117: /* Args: Arg */
#line 809 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = (yyvsp[0].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3678 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 118: /* Args: Args ';' Arg */
#line 812 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3686 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 119: /* Arg: Exp */
#line 817 "src/parser.y"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
{
(yyval.blk) = gen_lambda((yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3694 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 120: /* RepPatterns: RepPatterns "?//" Pattern */
#line 822 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = BLOCK((yyvsp[-2].blk), gen_destructure_alt((yyvsp[0].blk)));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3702 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 121: /* RepPatterns: Pattern */
#line 825 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_destructure_alt((yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3710 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 122: /* Patterns: RepPatterns "?//" Pattern */
#line 830 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3718 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 123: /* Patterns: Pattern */
#line 833 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = (yyvsp[0].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3726 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 124: /* Pattern: BINDING */
#line 838 "src/parser.y"
{
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
(yyval.blk) = gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal)));
jv_free((yyvsp[0].literal));
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3735 "src/parser.c"
Update parser.c
2015-05-25 13:17:22 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 125: /* Pattern: '[' ArrayPats ']' */
#line 842 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP));
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3743 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 126: /* Pattern: '{' ObjPats '}' */
#line 845 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP));
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3751 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 127: /* ArrayPats: Pattern */
#line 850 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_array_matcher(gen_noop(), (yyvsp[0].blk));
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3759 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 128: /* ArrayPats: ArrayPats ',' Pattern */
#line 853 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_array_matcher((yyvsp[-2].blk), (yyvsp[0].blk));
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3767 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 129: /* ObjPats: ObjPat */
#line 858 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = (yyvsp[0].blk);
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3775 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 130: /* ObjPats: ObjPats ',' ObjPat */
#line 861 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk));
Allow . as {$a:$b} destructuring
2017-02-20 19:24:22 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3783 "src/parser.c"
Allow . as {$a:$b} destructuring
2017-02-20 19:24:22 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 131: /* ObjPat: BINDING */
#line 866 "src/parser.y"
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_object_matcher(gen_const((yyvsp[0].literal)), gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal))));
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3791 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 132: /* ObjPat: BINDING ':' Pattern */
#line 869 "src/parser.y"
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), BLOCK(gen_op_simple(DUP), gen_op_unbound(STOREV, jv_string_value((yyvsp[-2].literal))), (yyvsp[0].blk)));
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3799 "src/parser.c"
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 133: /* ObjPat: IDENT ':' Pattern */
#line 872 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3807 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 134: /* ObjPat: Keyword ':' Pattern */
#line 875 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk));
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3815 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 135: /* ObjPat: String ':' Pattern */
#line 878 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_object_matcher((yyvsp[-2].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3823 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 136: /* ObjPat: '(' Exp ')' ':' Pattern */
#line 881 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
jv msg = check_object_key((yyvsp[-3].blk));
if (jv_is_valid(msg)) {
FAIL((yyloc), jv_string_value(msg));
}
jv_free(msg);
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
(yyval.blk) = gen_object_matcher((yyvsp[-3].blk), (yyvsp[0].blk));
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3836 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 137: /* ObjPat: error ':' Pattern */
#line 889 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
FAIL((yyloc), "May need parentheses around object key expression");
(yyval.blk) = (yyvsp[0].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3845 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 138: /* Keyword: "as" */
#line 895 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("as");
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3853 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 139: /* Keyword: "def" */
#line 898 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("def");
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3861 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 140: /* Keyword: "module" */
#line 901 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("module");
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3869 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 141: /* Keyword: "import" */
#line 904 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("import");
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3877 "src/parser.c"
array and object destructuring (fix #533)
2015-06-07 21:45:14 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 142: /* Keyword: "include" */
#line 907 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("include");
Add {$var} . as {$var} syntax (fix #831)
2015-06-26 20:29:04 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3885 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 143: /* Keyword: "if" */
#line 910 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("if");
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3893 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 144: /* Keyword: "then" */
#line 913 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("then");
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3901 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 145: /* Keyword: "else" */
#line 916 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("else");
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3909 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 146: /* Keyword: "elif" */
#line 919 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("elif");
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3917 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 147: /* Keyword: "reduce" */
#line 922 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("reduce");
Improve invalid object key error message
2015-09-16 09:49:11 -07:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3925 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 148: /* Keyword: "foreach" */
#line 925 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("foreach");
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3933 "src/parser.c"
Resolve remaining shift/reduce conflicts involving '?'
2015-07-18 23:44:06 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 149: /* Keyword: "end" */
#line 928 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("end");
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3941 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 150: /* Keyword: "and" */
#line 931 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("and");
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3949 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 151: /* Keyword: "or" */
#line 934 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("or");
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3957 "src/parser.c"
Fix assert fail on invalid import path (fix #899)
2015-08-12 00:46:34 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 152: /* Keyword: "try" */
#line 937 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("try");
Allow . as {$a:$b} destructuring
2017-02-20 19:24:22 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3965 "src/parser.c"
Add $__loc__ (fix #740)
2015-03-30 15:55:54 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 153: /* Keyword: "catch" */
#line 940 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("catch");
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3973 "src/parser.c"
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 154: /* Keyword: "label" */
#line 943 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("label");
Allow keywords in more places (fix #1868)
2019-03-21 23:58:55 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3981 "src/parser.c"
Add flex/bison outputs
2017-02-20 19:15:23 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 155: /* Keyword: "break" */
#line 946 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.literal) = jv_string("break");
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3989 "src/parser.c"
Support "if" without "else" clause
2019-02-14 19:59:59 -08:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 156: /* MkDict: %empty */
#line 951 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk)=gen_noop();
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 3997 "src/parser.c"
Allow . as {$a:$b} destructuring
2017-02-20 19:24:22 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 157: /* MkDict: MkDictPair */
#line 954 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = (yyvsp[0].blk); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4003 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 158: /* MkDict: MkDictPair ',' MkDict */
#line 955 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk)=block_join((yyvsp[-2].blk), (yyvsp[0].blk)); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4009 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 159: /* MkDict: error ',' MkDict */
#line 956 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{ (yyval.blk) = (yyvsp[0].blk); }
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4015 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 160: /* MkDictPair: IDENT ':' ExpD */
#line 959 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4023 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 161: /* MkDictPair: Keyword ':' ExpD */
#line 962 "src/parser.y"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
{
(yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4031 "src/parser.c"
Support .a.[] and .a.[]? each syntax
2023-07-03 18:24:37 +02:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 162: /* MkDictPair: String ':' ExpD */
#line 965 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_dictpair((yyvsp[-2].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4039 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 163: /* MkDictPair: String */
#line 968 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_dictpair((yyvsp[0].blk), BLOCK(gen_op_simple(POP), gen_op_simple(DUP2),
gen_op_simple(DUP2), gen_op_simple(INDEX)));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4048 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 164: /* MkDictPair: BINDING ':' ExpD */
#line 972 "src/parser.y"
{
Allow variable refs as object keys {$key:value}
2018-12-10 21:54:59 -06:00
(yyval.blk) = gen_dictpair(gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[-2].literal)))),
(yyvsp[0].blk));
Add {$var} . as {$var} syntax (fix #831)
2015-06-26 20:29:04 -05:00
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4057 "src/parser.c"
Allow variable refs as object keys {$key:value}
2018-12-10 21:54:59 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 165: /* MkDictPair: BINDING */
#line 976 "src/parser.y"
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_dictpair(gen_const((yyvsp[0].literal)),
gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal)))));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4066 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 166: /* MkDictPair: IDENT */
#line 980 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
(yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))),
gen_index(gen_noop(), gen_const((yyvsp[0].literal))));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4075 "src/parser.c"
Allow .["foo"].["bar"]
2019-03-08 09:59:47 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 167: /* MkDictPair: Keyword */
#line 984 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
(yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))),
gen_index(gen_noop(), gen_const((yyvsp[0].literal))));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4084 "src/parser.c"
Fix accidentally quadratic behavior in _modify
2021-10-21 00:17:39 -05:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 168: /* MkDictPair: '(' Exp ')' ':' ExpD */
#line 988 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Fix assert fail if object literal key is not a string (fix #953)
2015-09-21 12:09:37 -07:00
jv msg = check_object_key((yyvsp[-3].blk));
if (jv_is_valid(msg)) {
FAIL((yyloc), jv_string_value(msg));
}
jv_free(msg);
Improve invalid object key error message
2015-09-16 09:49:11 -07:00
(yyval.blk) = gen_dictpair((yyvsp[-3].blk), (yyvsp[0].blk));
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4097 "src/parser.c"
Improve invalid object key error message
2015-09-16 09:49:11 -07:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
case 169: /* MkDictPair: error ':' ExpD */
#line 996 "src/parser.y"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
Address comments on PR #950
2015-09-16 10:48:50 -07:00
FAIL((yyloc), "May need parentheses around object key expression");
Improve invalid object key error message
2015-09-16 09:49:11 -07:00
(yyval.blk) = (yyvsp[0].blk);
}
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4106 "src/parser.c"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
break;
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 4110 "src/parser.c"
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
incorrect destructor might then be invoked immediately. In the
case of YYERROR or YYBACKUP, subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYPOPSTACK (yylen);
yylen = 0;
*++yyvsp = yyval;
*++yylsp = yyloc;
/* Now 'shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
{
const int yylhs = yyr1[yyn] - YYNTOKENS;
const int yyi = yypgoto[yylhs] + *yyssp;
yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
? yytable[yyi]
: yydefgoto[yylhs]);
}
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
goto yynewstate;
/*--------------------------------------.
| yyerrlab -- here on detecting error. |
`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yypcontext_t yyctx
= {yyssp, yytoken, &yylloc};
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
char const *yymsgp = YY_("syntax error");
int yysyntax_error_status;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yysyntax_error_status == 0)
yymsgp = yymsg;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
else if (yysyntax_error_status == -1)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yymsg = YY_CAST (char *,
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
if (yymsg)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yysyntax_error_status
= yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
yymsgp = yymsg;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
else
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = YYENOMEM;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
}
yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp);
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
if (yysyntax_error_status == YYENOMEM)
YYNOMEM;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
}
}
yyerror_range[1] = yylloc;
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
yychar = YYEMPTY;
}
}
/* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Pacify compilers when the user code never invokes YYERROR and the
label yyerrorlab therefore never appears in user code. */
if (0)
YYERROR;
++yynerrs;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/* Pop stack until we find a state that shifts the error token. */
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
{
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
yyn += YYSYMBOL_YYerror;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yyerror_range[1] = *yylsp;
yydestruct ("Error: popping",
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
yyerror_range[2] = yylloc;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
++yylsp;
YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/* Shift the error token. */
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
goto yyreturnlab;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
goto yyreturnlab;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/*-----------------------------------------------------------.
| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
`-----------------------------------------------------------*/
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
yyexhaustedlab:
yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted"));
yyresult = 2;
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
goto yyreturnlab;
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
/*----------------------------------------------------------.
| yyreturnlab -- parsing is finished, clean up and return. |
`----------------------------------------------------------*/
yyreturnlab:
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
if (yychar != YYEMPTY)
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
}
/* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
return yyresult;
}
Validate module metadata to be an object (#2357)
2023-06-28 17:59:46 +09:00
Lex $foo as a single token, instead of using '$' IDENT
2023-07-09 20:32:51 +02:00
#line 1000 "src/parser.y"
Add --disable-maintainer-mode; make bison optional
2015-02-15 17:57:53 -06:00
int jq_parse(struct locfile* locations, block* answer) {
struct lexer_param scanner;
YY_BUFFER_STATE buf;
jq_yylex_init_extra(0, &scanner.lexer);
buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer);
int errors = 0;
*answer = gen_noop();
yyparse(answer, &errors, locations, &scanner);
jq_yy_delete_buffer(buf, scanner.lexer);
jq_yylex_destroy(scanner.lexer);
if (errors > 0) {
block_free(*answer);
*answer = gen_noop();
}
return errors;
}
int jq_parse_library(struct locfile* locations, block* answer) {
int errs = jq_parse(locations, answer);
if (errs) return errs;
if (block_has_main(*answer)) {
locfile_locate(locations, UNKNOWN_LOCATION, "jq: error: library should only have function definitions, not a main expression");
return 1;
}
assert(block_has_only_binders_and_imports(*answer, OP_IS_CALL_PSEUDO));
return 0;
}
Reference in new issue Copy Permalink