#undef PARSER_TEST

#undef PARSER_DEBUG

#define YYDEBUG 1

#define YYERROR_VERBOSE 1

#define YYMALLOC(n) mrb_malloc(p->mrb, (n))

#define YYFREE(o) mrb_free(p->mrb, (o))

#define YYSTACK_USE_ALLOCA 0

#include "mruby.h"

#include "mruby/compile.h"

#include "mruby/proc.h"

#include "node.h"

#include <stdio.h>

#include <errno.h>

#include <ctype.h>

#include <string.h>

#define YYLEX_PARAM p

typedef mrb_ast_node node;

typedef struct mrb_parser_state parser_state;

static int yylex(void *lval, parser_state *p);

static void yyerror(parser_state *p, const char *s);

static void yywarn(parser_state *p, const char *s);

static void yywarning(parser_state *p, const char *s);

static void backref_error(parser_state *p, node *n);

#define identchar(c) (isalnum(c) || (c) == '_' || !isascii(c))

typedef unsigned int stack_type;

#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))

#define BITSTACK_POP(stack) ((stack) = (stack) >> 1)

#define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))

#define BITSTACK_SET_P(stack) ((stack)&1)

#define COND_PUSH(n) BITSTACK_PUSH(p->cond_stack, (n))

#define COND_POP() BITSTACK_POP(p->cond_stack)

#define COND_LEXPOP() BITSTACK_LEXPOP(p->cond_stack)

#define COND_P() BITSTACK_SET_P(p->cond_stack)

#define CMDARG_PUSH(n) BITSTACK_PUSH(p->cmdarg_stack, (n))

#define CMDARG_POP() BITSTACK_POP(p->cmdarg_stack)

#define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)

#define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack)

#define sym(x) ((mrb_sym)(intptr_t)(x))

#define nsym(x) ((node*)(intptr_t)(x))

static mrb_sym

intern_gen(parser_state *p, const char *s)

{

return mrb_intern(p->mrb, s);

}

#define intern(s) intern_gen(p,(s))

static void

cons_free_gen(parser_state *p, node *cons)

{

cons->cdr = p->cells;

p->cells = cons;

}

#define cons_free(c) cons_free_gen(p, (c))

static void*

parser_palloc(parser_state *p, size_t size)

{

void *m = mrb_pool_alloc(p->pool, size);

if (!m) {

longjmp(p->jmp, 1);

}

return m;

}

static node*

cons_gen(parser_state *p, node *car, node *cdr)

{

node *c;

if (p->cells) {

c = p->cells;

p->cells = p->cells->cdr;

}

else {

c = (node *)parser_palloc(p, sizeof(mrb_ast_node));

}

c->car = car;

c->cdr = cdr;

c->lineno = p->lineno;

return c;

}

#define cons(a,b) cons_gen(p,(a),(b))

static node*

list1_gen(parser_state *p, node *a)

{

return cons(a, 0);

}

#define list1(a) list1_gen(p, (a))

static node*

list2_gen(parser_state *p, node *a, node *b)

{

return cons(a, cons(b,0));

}

#define list2(a,b) list2_gen(p, (a),(b))

static node*

list3_gen(parser_state *p, node *a, node *b, node *c)

{

return cons(a, cons(b, cons(c,0)));

}

#define list3(a,b,c) list3_gen(p, (a),(b),(c))

static node*

list4_gen(parser_state *p, node *a, node *b, node *c, node *d)

{

return cons(a, cons(b, cons(c, cons(d, 0))));

}

#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))

static node*

list5_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e)

{

return cons(a, cons(b, cons(c, cons(d, cons(e, 0)))));

}

#define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e))

static node*

list6_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e, node *f)

{

return cons(a, cons(b, cons(c, cons(d, cons(e, cons(f, 0))))));

}

#define list6(a,b,c,d,e,f) list6_gen(p, (a),(b),(c),(d),(e),(f))

static node*

append_gen(parser_state *p, node *a, node *b)

{

node *c = a;

if (!a) return b;

while (c->cdr) {

c = c->cdr;

}

if (b) {

c->cdr = b;

}

return a;

}

#define append(a,b) append_gen(p,(a),(b))

#define push(a,b) append_gen(p,(a),list1(b))

static char*

parser_strndup(parser_state *p, const char *s, size_t len)

{

char *b = (char *)parser_palloc(p, len+1);

memcpy(b, s, len);

b[len] = '\0';

return b;

}

#define strndup(s,len) parser_strndup(p, s, len)

static char*

parser_strdup(parser_state *p, const char *s)

{

return parser_strndup(p, s, strlen(s));

}

#undef strdup

#define strdup(s) parser_strdup(p, s)

static node*

local_switch(parser_state *p)

{

node *prev = p->locals;

p->locals = cons(0, 0);

return prev;

}

static void

local_resume(parser_state *p, node *prev)

{

p->locals = prev;

}

static void

local_nest(parser_state *p)

{

p->locals = cons(0, p->locals);

}

static void

local_unnest(parser_state *p)

{

p->locals = p->locals->cdr;

}

static int

local_var_p(parser_state *p, mrb_sym sym)

{

node *l = p->locals;

while (l) {

node *n = l->car;

while (n) {

if (sym(n->car) == sym) return 1;

n = n->cdr;

}

l = l->cdr;

}

return 0;

}

static void

local_add_f(parser_state *p, mrb_sym sym)

{

p->locals->car = push(p->locals->car, nsym(sym));

}

static void

local_add(parser_state *p, mrb_sym sym)

{

if (!local_var_p(p, sym)) {

local_add_f(p, sym);

}

}

static node*

new_scope(parser_state *p, node *body)

{

return cons((node*)NODE_SCOPE, cons(p->locals->car, body));

}

static node*

new_begin(parser_state *p, node *body)

{

if (body)

return list2((node*)NODE_BEGIN, body);

return cons((node*)NODE_BEGIN, 0);

}

#define newline_node(n) (n)

static node*

new_rescue(parser_state *p, node *body, node *resq, node *els)

{

return list4((node*)NODE_RESCUE, body, resq, els);

}

static node*

new_ensure(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_ENSURE, cons(a, cons(0, b)));

}

static node*

new_nil(parser_state *p)

{

return list1((node*)NODE_NIL);

}

static node*

new_true(parser_state *p)

{

return list1((node*)NODE_TRUE);

}

static node*

new_false(parser_state *p)

{

return list1((node*)NODE_FALSE);

}

static node*

new_alias(parser_state *p, mrb_sym a, mrb_sym b)

{

return cons((node*)NODE_ALIAS, cons(nsym(a), nsym(b)));

}

static node*

new_if(parser_state *p, node *a, node *b, node *c)

{

return list4((node*)NODE_IF, a, b, c);

}

static node*

new_unless(parser_state *p, node *a, node *b, node *c)

{

return list4((node*)NODE_IF, a, c, b);

}

static node*

new_while(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_WHILE, cons(a, b));

}

static node*

new_until(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_UNTIL, cons(a, b));

}

static node*

new_for(parser_state *p, node *v, node *o, node *b)

{

return list4((node*)NODE_FOR, v, o, b);

}

static node*

new_case(parser_state *p, node *a, node *b)

{

node *n = list2((node*)NODE_CASE, a);

node *n2 = n;

while (n2->cdr) {

n2 = n2->cdr;

}

n2->cdr = b;

return n;

}

static node*

new_postexe(parser_state *p, node *a)

{

return cons((node*)NODE_POSTEXE, a);

}

static node*

new_self(parser_state *p)

{

return list1((node*)NODE_SELF);

}

static node*

new_call(parser_state *p, node *a, mrb_sym b, node *c)

{

return list4((node*)NODE_CALL, a, nsym(b), c);

}

static node*

new_fcall(parser_state *p, mrb_sym b, node *c)

{

return list4((node*)NODE_FCALL, new_self(p), nsym(b), c);

}

#if 0

// (:vcall self mid)

static node*

new_vcall(parser_state *p, mrb_sym b)

{

return list3((node*)NODE_VCALL, new_self(p), (node*)b);

}

#endif

static node*

new_super(parser_state *p, node *c)

{

return cons((node*)NODE_SUPER, c);

}

static node*

new_zsuper(parser_state *p)

{

return list1((node*)NODE_ZSUPER);

}

static node*

new_yield(parser_state *p, node *c)

{

if (c) {

if (c->cdr) {

yyerror(p, "both block arg and actual block given");

}

return cons((node*)NODE_YIELD, c->car);

}

return cons((node*)NODE_YIELD, 0);

}

static node*

new_return(parser_state *p, node *c)

{

return cons((node*)NODE_RETURN, c);

}

static node*

new_break(parser_state *p, node *c)

{

return cons((node*)NODE_BREAK, c);

}

static node*

new_next(parser_state *p, node *c)

{

return cons((node*)NODE_NEXT, c);

}

static node*

new_redo(parser_state *p)

{

return list1((node*)NODE_REDO);

}

static node*

new_retry(parser_state *p)

{

return list1((node*)NODE_RETRY);

}

static node*

new_dot2(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_DOT2, cons(a, b));

}

static node*

new_dot3(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_DOT3, cons(a, b));

}

static node*

new_colon2(parser_state *p, node *b, mrb_sym c)

{

return cons((node*)NODE_COLON2, cons(b, nsym(c)));

}

static node*

new_colon3(parser_state *p, mrb_sym c)

{

return cons((node*)NODE_COLON3, nsym(c));

}

static node*

new_and(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_AND, cons(a, b));

}

static node*

new_or(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_OR, cons(a, b));

}

static node*

new_array(parser_state *p, node *a)

{

return cons((node*)NODE_ARRAY, a);

}

static node*

new_splat(parser_state *p, node *a)

{

return cons((node*)NODE_SPLAT, a);

}

static node*

new_hash(parser_state *p, node *a)

{

return cons((node*)NODE_HASH, a);

}

static node*

new_sym(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_SYM, nsym(sym));

}

static mrb_sym

new_strsym(parser_state *p, node* str)

{

const char *s = (const char*)str->cdr->car;

size_t len = (size_t)str->cdr->cdr;

return mrb_intern2(p->mrb, s, len);

}

static node*

new_lvar(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_LVAR, nsym(sym));

}

static node*

new_gvar(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_GVAR, nsym(sym));

}

static node*

new_ivar(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_IVAR, nsym(sym));

}

static node*

new_cvar(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_CVAR, nsym(sym));

}

static node*

new_const(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_CONST, nsym(sym));

}

static node*

new_undef(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_UNDEF, nsym(sym));

}

static node*

new_class(parser_state *p, node *c, node *s, node *b)

{

return list4((node*)NODE_CLASS, c, s, cons(p->locals->car, b));

}

static node*

new_sclass(parser_state *p, node *o, node *b)

{

return list3((node*)NODE_SCLASS, o, cons(p->locals->car, b));

}

static node*

new_module(parser_state *p, node *m, node *b)

{

return list3((node*)NODE_MODULE, m, cons(p->locals->car, b));

}

static node*

new_def(parser_state *p, mrb_sym m, node *a, node *b)

{

return list5((node*)NODE_DEF, nsym(m), p->locals->car, a, b);

}

static node*

new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)

{

return list6((node*)NODE_SDEF, o, nsym(m), p->locals->car, a, b);

}

static node*

new_arg(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_ARG, nsym(sym));

}

static node*

new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, mrb_sym blk)

{

node *n;

n = cons(m2, nsym(blk));

n = cons(nsym(rest), n);

n = cons(opt, n);

return cons(m, n);

}

static node*

new_block_arg(parser_state *p, node *a)

{

return cons((node*)NODE_BLOCK_ARG, a);

}

static node*

new_block(parser_state *p, node *a, node *b)

{

return list4((node*)NODE_BLOCK, p->locals->car, a, b);

}

static node*

new_lambda(parser_state *p, node *a, node *b)

{

return list4((node*)NODE_LAMBDA, p->locals->car, a, b);

}

static node*

new_asgn(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_ASGN, cons(a, b));

}

static node*

new_masgn(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_MASGN, cons(a, b));

}

static node*

new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)

{

return list4((node*)NODE_OP_ASGN, a, nsym(op), b);

}

static node*

new_int(parser_state *p, const char *s, int base)

{

return list3((node*)NODE_INT, (node*)strdup(s), (node*)(intptr_t)base);

}

static node*

new_float(parser_state *p, const char *s)

{

return cons((node*)NODE_FLOAT, (node*)strdup(s));

}

static node*

new_str(parser_state *p, const char *s, int len)

{

return cons((node*)NODE_STR, cons((node*)strndup(s, len), (node*)(intptr_t)len));

}

static node*

new_dstr(parser_state *p, node *a)

{

return cons((node*)NODE_DSTR, a);

}

static node*

new_dsym(parser_state *p, node *a)

{

return cons((node*)NODE_DSYM, new_dstr(p, a));

}

static node*

new_back_ref(parser_state *p, int n)

{

return cons((node*)NODE_BACK_REF, (node*)(intptr_t)n);

}

static node*

new_nth_ref(parser_state *p, int n)

{

return cons((node*)NODE_NTH_REF, (node*)(intptr_t)n);

}

static void

new_bv(parser_state *p, mrb_sym id)

{

}

static node*

call_uni_op(parser_state *p, node *recv, char *m)

{

return new_call(p, recv, intern(m), 0);

}

static node*

call_bin_op(parser_state *p, node *recv, char *m, node *arg1)

{

return new_call(p, recv, intern(m), list1(list1(arg1)));

}

static node*

match_op(parser_state *p, node *a, node *b)

{

return cons((node*)NODE_MATCH, cons((node*)a, (node*)b));

}

static void

args_with_block(parser_state *p, node *a, node *b)

{

if (b) {

if (a->cdr) {

yyerror(p, "both block arg and actual block given");

}

a->cdr = b;

}

}

static void

call_with_block(parser_state *p, node *a, node *b)

{

node *n;

if (a->car == (node*)NODE_SUPER ||

a->car == (node*)NODE_ZSUPER) {

if (!a->cdr) a->cdr = cons(0, b);

else {

args_with_block(p, a->cdr, b);

}

}

else {

n = a->cdr->cdr->cdr;

if (!n->car) n->car = cons(0, b);

else {

args_with_block(p, n->car, b);

}

}

}

static node*

negate_lit(parser_state *p, node *n)

{

return cons((node*)NODE_NEGATE, n);

}

static node*

cond(node *n)

{

return n;

}

static node*

ret_args(parser_state *p, node *n)

{

if (n->cdr) {

yyerror(p, "block argument should not be given");

}

if (!n->car->cdr) return n->car->car;

return new_array(p, n->car);

}

static void

assignable(parser_state *p, node *lhs)

{

if ((int)(intptr_t)lhs->car == NODE_LVAR) {

local_add(p, sym(lhs->cdr));

}

}

static node*

var_reference(parser_state *p, node *lhs)

{

node *n;

if ((int)(intptr_t)lhs->car == NODE_LVAR) {

if (!local_var_p(p, sym(lhs->cdr))) {

n = new_fcall(p, sym(lhs->cdr), 0);

cons_free(lhs);

return n;

}

}

return lhs;

}

%pure_parser

%parse-param {parser_state *p}

%lex-param {parser_state *p}

%union {

node *nd;

mrb_sym id;

int num;

unsigned int stack;

const struct vtable *vars;

}

keyword_class

keyword_module

keyword_def

keyword_undef

keyword_begin

keyword_rescue

keyword_ensure

keyword_end

keyword_if

keyword_unless

keyword_then

keyword_elsif

keyword_else

keyword_case

keyword_when

keyword_while

keyword_until

keyword_for

keyword_break

keyword_next

keyword_redo

keyword_retry

keyword_in

keyword_do

keyword_do_cond

keyword_do_block

keyword_do_LAMBDA

keyword_return

keyword_yield

keyword_super

keyword_self

keyword_nil

keyword_true

keyword_false

keyword_and

keyword_or

keyword_not

modifier_if

modifier_unless

modifier_while

modifier_until

modifier_rescue

keyword_alias

keyword_BEGIN

keyword_END

keyword__LINE__

keyword__FILE__

keyword__ENCODING__

%token <id> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL

%token <nd> tINTEGER tFLOAT tCHAR tREGEXP

%token <nd> tSTRING tSTRING_PART

%token <nd> tNTH_REF tBACK_REF

%token <num> tREGEXP_END

%type <nd> singleton string string_interp regexp

%type <nd> literal numeric cpath symbol

%type <nd> top_compstmt top_stmts top_stmt

%type <nd> bodystmt compstmt stmts stmt expr arg primary command command_call method_call

%type <nd> expr_value arg_value primary_value

%type <nd> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure

%type <nd> args call_args opt_call_args

%type <nd> paren_args opt_paren_args variable

%type <nd> command_args aref_args opt_block_arg block_arg var_ref var_lhs

%type <nd> command_asgn mrhs superclass block_call block_command

%type <nd> f_block_optarg f_block_opt

%type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs

%type <nd> assoc_list assocs assoc undef_list backref for_var

%type <nd> block_param opt_block_param block_param_def f_opt

%type <nd> bv_decls opt_bv_decl bvar f_larglist lambda_body

%type <nd> brace_block cmd_brace_block do_block lhs none fitem f_bad_arg

%type <nd> mlhs mlhs_list mlhs_post mlhs_basic mlhs_item mlhs_node mlhs_inner

%type <id> fsym sym basic_symbol operation operation2 operation3

%type <id> cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg

%token tUPLUS /* unary+ */

%token tUMINUS /* unary- */

%token tPOW /* ** */

%token tCMP /* <=> */

%token tEQ /* == */

%token tEQQ /* === */

%token tNEQ /* != */

%token tGEQ /* >= */

%token tLEQ /* <= */

%token tANDOP tOROP /* && and || */

%token tMATCH tNMATCH /* =~ and !~ */

%token tDOT2 tDOT3 /* .. and ... */

%token tAREF tASET /* [] and []= */

%token tLSHFT tRSHFT /* << and >> */

%token tCOLON2 /* :: */

%token tCOLON3 /* :: at EXPR_BEG */

%token <id> tOP_ASGN /* +=, -= etc. */

%token tASSOC /* => */

%token tLPAREN /* ( */

%token tLPAREN_ARG /* ( */

%token tRPAREN /* ) */

%token tLBRACK /* [ */

%token tLBRACE /* { */

%token tLBRACE_ARG /* { */

%token tSTAR /* * */

%token tAMPER /* & */

%token tLAMBDA /* -> */

%token tSYMBEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG

%token tSTRING_BEG tSTRING_DVAR tLAMBEG

%nonassoc tLOWEST

%nonassoc tLBRACE_ARG

%nonassoc modifier_if modifier_unless modifier_while modifier_until

%left keyword_or keyword_and

%right keyword_not

%right '=' tOP_ASGN

%left modifier_rescue

%right '?' ':'

%nonassoc tDOT2 tDOT3

%left tOROP

%left tANDOP

%nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH

%left '>' tGEQ '<' tLEQ

%left '|' '^'

%left '&'

%left tLSHFT tRSHFT

%left '+' '-'

%left '*' '/' '%'

%right tUMINUS_NUM tUMINUS

%right tPOW

%right '!' '~' tUPLUS

%nonassoc idNULL

%nonassoc idRespond_to

%nonassoc idIFUNC

%nonassoc idCFUNC

%nonassoc id_core_set_method_alias

%nonassoc id_core_set_variable_alias

%nonassoc id_core_undef_method

%nonassoc id_core_define_method

%nonassoc id_core_define_singleton_method

%nonassoc id_core_set_postexe

%token tLAST_TOKEN

program : {

p->lstate = EXPR_BEG;

if (!p->locals) p->locals = cons(0,0);

}

top_compstmt