mutant-melbourne 2.0.1

data/ext/melbourne/node_types19.cpp

@@ -0,0 +1,249 @@
+/* This file is generated by node_types.rb. Do not edit. */
+
+#include "node_types19.hpp"
+
+#include <stdio.h>
+
+namespace melbourne {
+  namespace grammar19 {
+    static const char node_types[] = {
+      "scope\0"
+      "block\0"
+      "if\0"
+      "case\0"
+      "when\0"
+      "opt_n\0"
+      "while\0"
+      "until\0"
+      "iter\0"
+      "for\0"
+      "break\0"
+      "next\0"
+      "redo\0"
+      "retry\0"
+      "begin\0"
+      "rescue\0"
+      "resbody\0"
+      "ensure\0"
+      "and\0"
+      "or\0"
+      "masgn\0"
+      "lasgn\0"
+      "dasgn\0"
+      "dasgn_curr\0"
+      "gasgn\0"
+      "iasgn\0"
+      "iasgn2\0"
+      "cdecl\0"
+      "cvasgn\0"
+      "cvdecl\0"
+      "op_asgn1\0"
+      "op_asgn2\0"
+      "op_asgn_and\0"
+      "op_asgn_or\0"
+      "call\0"
+      "fcall\0"
+      "vcall\0"
+      "super\0"
+      "zsuper\0"
+      "array\0"
+      "zarray\0"
+      "values\0"
+      "hash\0"
+      "return\0"
+      "yield\0"
+      "lvar\0"
+      "dvar\0"
+      "gvar\0"
+      "ivar\0"
+      "const\0"
+      "cvar\0"
+      "nth_ref\0"
+      "back_ref\0"
+      "match\0"
+      "match2\0"
+      "match3\0"
+      "lit\0"
+      "str\0"
+      "dstr\0"
+      "xstr\0"
+      "dxstr\0"
+      "evstr\0"
+      "dregx\0"
+      "dregx_once\0"
+      "args\0"
+      "args_aux\0"
+      "opt_arg\0"
+      "postarg\0"
+      "argscat\0"
+      "argspush\0"
+      "splat\0"
+      "to_ary\0"
+      "block_arg\0"
+      "block_pass\0"
+      "defn\0"
+      "defs\0"
+      "alias\0"
+      "valias\0"
+      "undef\0"
+      "class\0"
+      "module\0"
+      "sclass\0"
+      "colon2\0"
+      "colon3\0"
+      "dot2\0"
+      "dot3\0"
+      "flip2\0"
+      "flip3\0"
+      "self\0"
+      "nil\0"
+      "true\0"
+      "false\0"
+      "errinfo\0"
+      "defined\0"
+      "postexe\0"
+      "alloca\0"
+      "bmethod\0"
+      "memo\0"
+      "ifunc\0"
+      "dsym\0"
+      "attrasgn\0"
+      "prelude\0"
+      "lambda\0"
+      "optblock\0"
+      "last\0"
+      "file\0"
+      "regex\0"
+      "number\0"
+      "float\0"
+      "encoding\0"
+      "preexe\0"
+    };
+
+    static const unsigned short node_types_offsets[] = {
+      0,
+      6,
+      12,
+      15,
+      20,
+      25,
+      31,
+      37,
+      43,
+      48,
+      52,
+      58,
+      63,
+      68,
+      74,
+      80,
+      87,
+      95,
+      102,
+      106,
+      109,
+      115,
+      121,
+      127,
+      138,
+      144,
+      150,
+      157,
+      163,
+      170,
+      177,
+      186,
+      195,
+      207,
+      218,
+      223,
+      229,
+      235,
+      241,
+      248,
+      254,
+      261,
+      268,
+      273,
+      280,
+      286,
+      291,
+      296,
+      301,
+      306,
+      312,
+      317,
+      325,
+      334,
+      340,
+      347,
+      354,
+      358,
+      362,
+      367,
+      372,
+      378,
+      384,
+      390,
+      401,
+      406,
+      415,
+      423,
+      431,
+      439,
+      448,
+      454,
+      461,
+      471,
+      482,
+      487,
+      492,
+      498,
+      505,
+      511,
+      517,
+      524,
+      531,
+      538,
+      545,
+      550,
+      555,
+      561,
+      567,
+      572,
+      576,
+      581,
+      587,
+      595,
+      603,
+      611,
+      618,
+      626,
+      631,
+      637,
+      642,
+      651,
+      659,
+      666,
+      675,
+      680,
+      685,
+      691,
+      698,
+      704,
+      713,
+      720
+    };
+
+    const char *get_node_type_string(enum node_type node) {
+      if(node < 111) {
+        return node_types + node_types_offsets[node];
+      } else {
+#define NODE_STRING_MESSAGE_LEN 20
+        static char msg[NODE_STRING_MESSAGE_LEN];
+        snprintf(msg, NODE_STRING_MESSAGE_LEN, "unknown node type: %d", node);
+        return msg;
+      }
+    }
+  };  // namespace grammar19
+};  // namespace melbourne

data/ext/melbourne/node_types19.hpp

@@ -0,0 +1,126 @@
+#ifndef MEL_NODE_TYPES19_HPP
+#define MEL_NODE_TYPES19_HPP
+/* This file is generated by node_types.rb. Do not edit. */
+
+namespace melbourne {
+  namespace grammar19 {
+    enum node_type {
+      NODE_SCOPE,
+      NODE_BLOCK,
+      NODE_IF,
+      NODE_CASE,
+      NODE_WHEN,
+      NODE_OPT_N,
+      NODE_WHILE,
+      NODE_UNTIL,
+      NODE_ITER,
+      NODE_FOR,
+      NODE_BREAK,
+      NODE_NEXT,
+      NODE_REDO,
+      NODE_RETRY,
+      NODE_BEGIN,
+      NODE_RESCUE,
+      NODE_RESBODY,
+      NODE_ENSURE,
+      NODE_AND,
+      NODE_OR,
+      NODE_MASGN,
+      NODE_LASGN,
+      NODE_DASGN,
+      NODE_DASGN_CURR,
+      NODE_GASGN,
+      NODE_IASGN,
+      NODE_IASGN2,
+      NODE_CDECL,
+      NODE_CVASGN,
+      NODE_CVDECL,
+      NODE_OP_ASGN1,
+      NODE_OP_ASGN2,
+      NODE_OP_ASGN_AND,
+      NODE_OP_ASGN_OR,
+      NODE_CALL,
+      NODE_FCALL,
+      NODE_VCALL,
+      NODE_SUPER,
+      NODE_ZSUPER,
+      NODE_ARRAY,
+      NODE_ZARRAY,
+      NODE_VALUES,
+      NODE_HASH,
+      NODE_RETURN,
+      NODE_YIELD,
+      NODE_LVAR,
+      NODE_DVAR,
+      NODE_GVAR,
+      NODE_IVAR,
+      NODE_CONST,
+      NODE_CVAR,
+      NODE_NTH_REF,
+      NODE_BACK_REF,
+      NODE_MATCH,
+      NODE_MATCH2,
+      NODE_MATCH3,
+      NODE_LIT,
+      NODE_STR,
+      NODE_DSTR,
+      NODE_XSTR,
+      NODE_DXSTR,
+      NODE_EVSTR,
+      NODE_DREGX,
+      NODE_DREGX_ONCE,
+      NODE_ARGS,
+      NODE_ARGS_AUX,
+      NODE_OPT_ARG,
+      NODE_POSTARG,
+      NODE_ARGSCAT,
+      NODE_ARGSPUSH,
+      NODE_SPLAT,
+      NODE_TO_ARY,
+      NODE_BLOCK_ARG,
+      NODE_BLOCK_PASS,
+      NODE_DEFN,
+      NODE_DEFS,
+      NODE_ALIAS,
+      NODE_VALIAS,
+      NODE_UNDEF,
+      NODE_CLASS,
+      NODE_MODULE,
+      NODE_SCLASS,
+      NODE_COLON2,
+      NODE_COLON3,
+      NODE_DOT2,
+      NODE_DOT3,
+      NODE_FLIP2,
+      NODE_FLIP3,
+      NODE_SELF,
+      NODE_NIL,
+      NODE_TRUE,
+      NODE_FALSE,
+      NODE_ERRINFO,
+      NODE_DEFINED,
+      NODE_POSTEXE,
+      NODE_ALLOCA,
+      NODE_BMETHOD,
+      NODE_MEMO,
+      NODE_IFUNC,
+      NODE_DSYM,
+      NODE_ATTRASGN,
+      NODE_PRELUDE,
+      NODE_LAMBDA,
+      NODE_OPTBLOCK,
+      NODE_LAST,
+      NODE_FILE,
+      NODE_REGEX,
+      NODE_NUMBER,
+      NODE_FLOAT,
+      NODE_ENCODING,
+      NODE_PREEXE
+    };
+
+    const char *get_node_type_string(enum node_type nt);
+
+  }; // namespace grammar19
+};  // namespace melbourne
+
+#endif

data/ext/melbourne/parser_state18.hpp

@@ -0,0 +1,181 @@
+#ifndef MEL_PARSER_STATE18_HPP
+#define MEL_PARSER_STATE18_HPP
+
+#include "node18.hpp"
+#include "node_types18.hpp"
+#include "local_state.hpp"
+
+#include <vector>
+#include <list>
+
+namespace melbourne {
+  namespace grammar18 {
+
+    enum lex_state_e {
+      EXPR_BEG,       /* ignore newline, +/- is a sign. */
+      EXPR_END,       /* newline significant, +/- is a operator. */
+      EXPR_ARG,       /* newline significant, +/- is a operator. */
+      EXPR_CMDARG,    /* newline significant, +/- is a operator. */
+      EXPR_ENDARG,    /* newline significant, +/- is a operator. */
+      EXPR_MID,       /* newline significant, +/- is a operator. */
+      EXPR_FNAME,     /* ignore newline, no reserved words. */
+      EXPR_DOT,       /* right after `.' or `::', no reserved words. */
+      EXPR_CLASS,     /* immediate after `class', no here document. */
+    };
+
+typedef VALUE stack_type;
+
+    struct StartPosition {
+      int line;
+      const char* kind;
+
+      StartPosition(int l, const char* k)
+        : line(l)
+        , kind(k)
+      {}
+    };
+
+    typedef struct rb_parser_state {
+      int end_seen;
+      int debug_lines;
+      int heredoc_end;
+      int command_start;
+      NODE *lex_strterm;
+      int paren_nest;
+      int lpar_beg;
+      int class_nest;
+      int in_single;
+      int in_def;
+      int compile_for_eval;
+      ID cur_mid;
+      char *token_buffer;
+      int tokidx;
+      int toksiz;
+      int emit_warnings;
+      /* Mirror'ing the 1.8 parser, There are 2 input methods,
+         from IO and directly from a string. */
+
+      /* this function reads a line from lex_io and stores it in
+       * line_buffer.
+       */
+      bool (*lex_gets)(rb_parser_state*);
+      bstring line_buffer;
+
+      /* If this is set, we use the io method. */
+      FILE *lex_io;
+      /* Otherwise, we use this. */
+      bstring lex_string;
+      bstring lex_lastline;
+      bstring lex_nextline;
+
+      char *lex_pbeg;
+      char *lex_p;
+      char *lex_pend;
+      int lex_str_used;
+
+      enum lex_state_e lex_state;
+      int in_defined;
+      stack_type cond_stack;
+      stack_type cmdarg_stack;
+
+      void *lval; /* the parser's yylval */
+      bool eofp;
+
+      std::vector<bstring>* magic_comments;
+      int column;
+      NODE *top_node;
+
+      LocalState* variables;
+
+      int ternary_colon;
+
+      void **memory_pools;
+      int pool_size, current_pool;
+      char *memory_cur;
+      char *memory_last_addr;
+      int memory_size;
+
+      bool verbose;
+
+      bool parse_error;
+      VALUE processor;
+
+      char *ruby_sourcefile;
+      int ruby_sourceline;
+
+      // Keeps track of lines that 'end' starters are on, to enable
+      // better error reporting.
+      std::list<StartPosition>* start_lines;
+
+      // Tracks quarks
+      quark_map* quark_indexes;
+      quark_vector* quarks;
+    } rb_parser_state;
+
+
+#define PARSER_STATE        ((rb_parser_state*)parser_state)
+#define PARSER_VAR(var)     (PARSER_STATE->var)
+
+#define end_seen            PARSER_VAR(end_seen)
+#define ruby__end__seen     PARSER_VAR(ruby__end__seen)
+#define ruby_debug_lines    PARSER_VAR(debug_lines)
+#define heredoc_end         PARSER_VAR(heredoc_end)
+#define command_start       PARSER_VAR(command_start)
+#define lex_strterm         PARSER_VAR(lex_strterm)
+#define paren_nest          PARSER_VAR(paren_nest)
+#define lpar_beg            PARSER_VAR(lpar_beg)
+#define class_nest          PARSER_VAR(class_nest)
+#define in_single           PARSER_VAR(in_single)
+#define in_def              PARSER_VAR(in_def)
+#define compile_for_eval    PARSER_VAR(compile_for_eval)
+#define cur_mid             PARSER_VAR(cur_mid)
+#define tokenbuf            PARSER_VAR(token_buffer)
+#define tokidx              PARSER_VAR(tokidx)
+#define toksiz              PARSER_VAR(toksiz)
+#define emit_warnings       PARSER_VAR(emit_warnings)
+#define lex_gets            PARSER_VAR(lex_gets)
+#define line_buffer         PARSER_VAR(line_buffer)
+#define line_count          PARSER_VAR(line_count)
+#define lex_io              PARSER_VAR(lex_io)
+#define lex_string          PARSER_VAR(lex_string)
+#define lex_gets_ptr        PARSER_VAR(lex_gets_ptr)
+#define lex_input           PARSER_VAR(lex_input)
+#define lex_lastline        PARSER_VAR(lex_lastline)
+#define lex_nextline        PARSER_VAR(lex_nextline)
+#define lex_pbeg            PARSER_VAR(lex_pbeg)
+#define lex_p               PARSER_VAR(lex_p)
+#define lex_pend            PARSER_VAR(lex_pend)
+#define lex_str_used        PARSER_VAR(lex_str_used)
+#define lex_state           PARSER_VAR(lex_state)
+#define in_defined          PARSER_VAR(in_defined)
+#define cond_stack          PARSER_VAR(cond_stack)
+#define cmdarg_stack        PARSER_VAR(cmdarg_stack)
+#define lval                PARSER_VAR(lval)
+#define eofp                PARSER_VAR(eofp)
+#define magic_comments      PARSER_VAR(magic_comments)
+#define column              PARSER_VAR(column)
+#define top_node            PARSER_VAR(top_node)
+#define variables           PARSER_VAR(variables)
+#define ternary_colon       PARSER_VAR(ternary_colon)
+#define memory_pools        PARSER_VAR(memory_pools)
+#define pool_size           PARSER_VAR(pool_size)
+#define current_pool        PARSER_VAR(current_pool)
+#define memory_cur          PARSER_VAR(memory_cur)
+#define memory_last_addr    PARSER_VAR(memory_last_addr)
+#define memory_size         PARSER_VAR(memory_size)
+#define verbose             PARSER_VAR(verbose)
+#define parse_error         PARSER_VAR(parse_error)
+#define processor           PARSER_VAR(processor)
+#define start_lines         PARSER_VAR(start_lines)
+#define ruby_sourcefile     PARSER_VAR(ruby_sourcefile)
+#define ruby_sourceline     PARSER_VAR(ruby_sourceline)
+#define quark_indexes       PARSER_VAR(quark_indexes)
+#define quarks              PARSER_VAR(quarks)
+
+#define node_newnode(t, a, b, c)  parser_node_newnode((rb_parser_state*)parser_state, t, a, b, c)
+
+    quark id_to_quark(rb_parser_state* parser_state, QUID id);
+  };  // namespace grammar18
+};  // namespace melbourne
+
+#endif