/*

** parse.y - mruby parser

**

** See Copyright Notice in mruby.h

*/

%{

#undef PARSER_DEBUG

#define YYDEBUG 1

#define YYERROR_VERBOSE 1

/*

* Force yacc to use our memory management. This is a little evil because

* the macros assume that "parser_state *p" is in scope

*/

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

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

#define YYSTACK_USE_ALLOCA 0

#include <ctype.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include "mruby.h"

#include "mruby/compile.h"

#include "mruby/proc.h"

#include "node.h"

#define YYLEX_PARAM p

typedef mrb_ast_node node;

typedef struct mrb_parser_state parser_state;

typedef struct mrb_parser_heredoc_info parser_heredoc_info;

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

#ifndef isascii

#define isascii(c) (((c) & ~0x7f) == 0)

#endif

#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 inline mrb_sym

intern_gen(parser_state *p, const char *s)

{

return mrb_intern(p->mrb, s);

}

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

static inline mrb_sym

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

{

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

}

#define intern2(s,len) intern_gen2(p,(s),(len))

static inline mrb_sym

intern_gen_c(parser_state *p, const char c)

{

return mrb_intern2(p->mrb, &c, 1);

}

#define intern_c(c) intern_gen_c(p,(c))

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)

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

}

}

// (: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(nsym(a), nsym(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, nsym(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), nsym(b), c);

}

// (: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, nsym(c)));

}

// (:colon3 . c)

static node*

new_colon3(parser_state *p, mrb_sym c)

{

return cons((node*)NODE_COLON3, nsym(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, 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);

}

// (:lvar . a)

static node*

new_lvar(parser_state *p, mrb_sym sym)

{

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

}

// (:gvar . a)

static node*

new_gvar(parser_state *p, mrb_sym sym)

{

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

}

// (:ivar . a)

static node*

new_ivar(parser_state *p, mrb_sym sym)

{

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

}

// (:cvar . a)

static node*

new_cvar(parser_state *p, mrb_sym sym)

{

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

}

// (:const . a)

static node*

new_const(parser_state *p, mrb_sym sym)

{

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

}

// (:undef a...)

static node*

new_undef(parser_state *p, mrb_sym sym)

{

return list2((node*)NODE_UNDEF, nsym(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, nsym(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, nsym(m), p->locals->car, a, b);

}

// (:arg . sym)

static node*

new_arg(parser_state *p, mrb_sym sym)

{

return cons((node*)NODE_ARG, nsym(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, nsym(blk));

n = cons(nsym(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, nsym(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*)(intptr_t)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, int len)

{

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

}

// (:dstr . a)

static node*

new_dstr(parser_state *p, node *a)

{

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

}

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

static node*

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

{

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

}

// (:xstr . a)

static node*

new_dxstr(parser_state *p, node *a)

{

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

}

// (:dsym . a)

static node*

new_dsym(parser_state *p, node *a)

{

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

}

// (:str . (a . a))

static node*

new_regx(parser_state *p, const char *p1, const char* p2)

{

return cons((node*)NODE_REGX, cons((node*)p1, (node*)p2));

}

// (:dregx . a)

static node*

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

{

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

}

// (:backref . n)

static node*

new_back_ref(parser_state *p, int n)

{

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

}

// (:nthref . n)

static node*

new_nth_ref(parser_state *p, int n)

{

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

}

// (:heredoc . a)

static node*

new_heredoc(parser_state *p)

{

parser_heredoc_info *inf = (parser_heredoc_info *)parser_palloc(p, sizeof(parser_heredoc_info));

return cons((node*)NODE_HEREDOC, (node*)inf);

}

static void

new_bv(parser_state *p, mrb_sym id)

{

}

static node*

new_literal_delim(parser_state *p)

{

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

}

// (:words . a)

static node*

new_words(parser_state *p, node *a)

{

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

}

// (:symbols . a)

static node*

new_symbols(parser_state *p, node *a)

{

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

}

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

}

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;

}

typedef enum mrb_string_type string_type;

static node*

new_strterm(parser_state *p, string_type type, int term, int paren)

{

return cons((node*)(intptr_t)type, cons((node*)0, cons((node*)(intptr_t)paren, (node*)(intptr_t)term)));

}

static void

end_strterm(parser_state *p)

{

cons_free(p->lex_strterm->cdr->cdr);

cons_free(p->lex_strterm->cdr);

cons_free(p->lex_strterm);

p->lex_strterm = NULL;

}

parser_heredoc_info *

parsing_heredoc_inf(parser_state *p)

{

node *nd = p->parsing_heredoc;

if (nd == NULL)

return NULL;

/* assert(nd->car->car == NODE_HEREDOC); */

return (parser_heredoc_info*)nd->car->cdr;

}

static void

heredoc_end(parser_state *p)

{

p->parsing_heredoc = p->parsing_heredoc->cdr;

if (p->parsing_heredoc == NULL) {

p->lstate = EXPR_BEG;

p->cmd_start = TRUE;

end_strterm(p);

p->heredoc_end_now = TRUE;

} else {

/* next heredoc */

p->lex_strterm->car = (node*)(intptr_t)parsing_heredoc_inf(p)->type;

}

}

#define is_strterm_type(p,str_func) ((int)(intptr_t)((p)->lex_strterm->car) & (str_func))

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

%}

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

}

%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 <nd> tINTEGER tFLOAT tCHAR tXSTRING tREGEXP

%token <nd> tSTRING tSTRING_PART tSTRING_MID