%{

#undef PARSER_TEST

#undef PARSER_DEBUG

#define YYDEBUG 1

#define YYERROR_VERBOSE 1

#define YYSTACK_USE_ALLOCA 0

#include "mruby.h"

#include "st.h"

#include "compile.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))

#define TRUE 1

#define FALSE 0

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)

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 = parser_palloc(p, sizeof(mrb_ast_node));

}

c->car = car;

c->cdr = cdr;

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 = 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)

// xxx -----------------------------

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 ((mrb_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, (node*)sym);

}

static void

local_add(parser_state *p, mrb_sym sym)

{

if (!local_var_p(p, sym)) {

local_add_f(p, sym);

}

}

// (:scope (vars..) (prog...))

static node*

new_scope(parser_state *p, node *body)

{

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

}

// (:begin prog...)

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)

// (:rescue body rescue else)

static node*

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

{

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

}

// (:ensure body ensure)

static node*

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

{

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

}

// (:nil)

static node*

new_nil(parser_state *p)

{

return list1((node*)NODE_NIL);

}

// (:true)

static node*

new_true(parser_state *p)

{

return list1((node*)NODE_TRUE);

}

// (:false)

static node*

new_false(parser_state *p)

{

return list1((node*)NODE_FALSE);

}

// (:alias new old)

static node*

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

{

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

}

// (:if cond then else)

static node*

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

{

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

}

// (:unless cond then else)

static node*

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

{

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

}

// (:while cond body)

static node*

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

{

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

}

// (:until cond body)

static node*

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

{

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

}

// (:for var obj body)

static node*

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

{

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

}

// (:case a ((when ...) body) ((when...) body))

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;

}

// (:postexe a)

static node*

new_postexe(parser_state *p, node *a)

{

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

}

// (:self)

static node*

new_self(parser_state *p)

{

return list1((node*)NODE_SELF);

}

// (:call a b c)

static node*

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

{

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

}

// (:fcall self mid args)

static node*

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

{

return list4((node*)NODE_FCALL, new_self(p), (node*)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

// (:super . c)

static node*

new_super(parser_state *p, node *c)

{

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

}

// (:zsuper)

static node*

new_zsuper(parser_state *p)

{

return list1((node*)NODE_ZSUPER);

}

// (:yield . c)

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);

}

// (:return . c)

static node*

new_return(parser_state *p, node *c)

{

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

}

// (:break . c)

static node*

new_break(parser_state *p, node *c)

{

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

}

// (:next . c)

static node*

new_next(parser_state *p, node *c)

{

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

}

// (:redo)

static node*

new_redo(parser_state *p)

{

return list1((node*)NODE_REDO);

}

// (:retry)

static node*

new_retry(parser_state *p)

{

return list1((node*)NODE_RETRY);

}

// (:dot2 a b)

static node*

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

{

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

}

// (:dot3 a b)

static node*

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

{

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

}

// (:colon2 b c)

static node*

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

{

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

}

// (:colon3 . c)

static node*

new_colon3(parser_state *p, mrb_sym c)

{

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

}

// (:and a b)

static node*

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

{

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

}

// (:or a b)

static node*

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

{

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

}

// (:array a...)

static node*

new_array(parser_state *p, node *a)

{

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

}

// (:splat . a)

static node*

new_splat(parser_state *p, node *a)

{

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

}

// (:hash (k . v) (k . v)...)

static node*

new_hash(parser_state *p, node *a)

{

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

}

// (:sym . a)

static node*

new_sym(parser_state *p, mrb_sym sym)

{

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

}

// (:lvar . a)

static node*

new_lvar(parser_state *p, mrb_sym sym)

{

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

}

// (:gvar . a)

static node*

new_gvar(parser_state *p, mrb_sym sym)

{

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

}

// (:ivar . a)

static node*

new_ivar(parser_state *p, mrb_sym sym)

{

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

}

// (:cvar . a)

static node*

new_cvar(parser_state *p, mrb_sym sym)

{

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

}

// (:const . a)

static node*

new_const(parser_state *p, mrb_sym sym)

{

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

}

// (:undef a...)

static node*

new_undef(parser_state *p, mrb_sym sym)

{

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

}

// (:class class super body)

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));

}

// (:sclass obj body)

static node*

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

{

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

}

// (:module module body)

static node*

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

{

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

}

// (:def m lv (arg . body))

static node*

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

{

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

}

// (:sdef obj m lv (arg . body))

static node*

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

{

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

}

// (:arg . sym)

static node*

new_arg(parser_state *p, mrb_sym sym)

{

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

}

// (m o r m2 b)

// m: (a b c)

// o: ((a . e1) (b . e2))

// r: a

// m2: (a b c)

// b: a

static node*

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

{

node *n;

n = cons(m2, (node*)blk);

n = cons((node*)rest, n);

n = cons(opt, n);

return cons(m, n);

}

// (:block_arg . a)

static node*

new_block_arg(parser_state *p, node *a)

{

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

}

// (:block arg body)

static node*

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

{

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

}

// (:lambda arg body)

static node*

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

{

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

}

// (:asgn lhs rhs)

static node*

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

{

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

}

// (:masgn mlhs=(pre rest post) mrhs)

static node*

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

{

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

}

// (:asgn lhs rhs)

static node*

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

{

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

}

// (:int . i)

static node*

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

{

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

}

// (:float . i)

static node*

new_float(parser_state *p, const char *s)

{

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

}

// (:str . (s . len))

static node*

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

{

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

}

// (:dstr . a)

static node*

new_dstr(parser_state *p, node *a)

{

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

}

// (:backref . n)

static node*

new_back_ref(parser_state *p, int n)

{

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

}

// (:nthref . n)

static node*

new_nth_ref(parser_state *p, int n)

{

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

}

static void

new_bv(parser_state *p, mrb_sym id)

{

}

// xxx -----------------------------

// (:call a op)

static node*

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

{

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

}

// (:call a op b)

static node*

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

{

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

}

// (:match (a . b))

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 = 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)

{

switch ((int)lhs->car) {

case NODE_LVAR:

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

break;

default:

break;

}

}

static node*

var_reference(parser_state *p, node *lhs)

{

node *n;

switch ((int)lhs->car) {

case NODE_LVAR:

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

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

cons_free(lhs);

return n;

}

break;

default:

break;

}

return lhs;

}

// xxx -----------------------------

%}

%pure_parser

%parse-param {parser_state *p}

%lex-param {parser_state *p}

%union {

node *node;

mrb_sym id;

int num;

const struct vtable *vars;

}

%token

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 <node> tINTEGER tFLOAT tCHAR tREGEXP

%token <node> tSTRING tSTRING_PART

%token <node> tNTH_REF tBACK_REF

%token <num> tREGEXP_END

%type <node> singleton string string_interp regexp

%type <node> literal numeric cpath

%type <node> top_compstmt top_stmts top_stmt

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

%type <node> expr_value arg_value primary_value

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

%type <node> args call_args opt_call_args

%type <node> paren_args opt_paren_args variable

%type <node> command_args aref_args opt_block_arg block_arg var_ref var_lhs

%type <node> command_asgn mrhs superclass block_call block_command

%type <node> f_block_optarg f_block_opt

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

%type <node> assoc_list assocs assoc undef_list backref for_var

%type <node> block_param opt_block_param block_param_def f_opt

%type <node> bv_decls opt_bv_decl bvar f_larglist lambda_body

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

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

%type <id> fsym sym 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

/*

* precedence table

*/

%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;

local_nest(p);

}

top_compstmt

{

p->tree = new_scope(p, $2);

local_unnest(p);

}

;

top_compstmt : top_stmts opt_terms

{

$$ = $1;

}

;

top_stmts : none

{

$$ = new_begin(p, 0);

}

| top_stmt

{

$$ = new_begin(p, $1);

}

| top_stmts terms top_stmt

{

$$ = push($1, newline_node($3));

}

| error top_stmt

{

$$ = $2;

}

;

top_stmt : stmt

| keyword_BEGIN

{

if (p->in_def || p->in_single) {

yyerror(p, "BEGIN in method");