rubinius-melbourne 1.0.0.8

data/ext/rubinius/melbourne/parser_state.hpp

@@ -0,0 +1,180 @@
+#ifndef MEL_PARSER_STATE_HPP
+#define MEL_PARSER_STATE_HPP
+
+#include "namespace.h"
+#include "node.hpp"
+#include "node_types.hpp"
+#include "local_state.hpp"
+
+#include <vector>
+#include <list>
+
+namespace MELBOURNE {
+
+  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 *sourcefile;
+    int 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 sourcefile          PARSER_VAR(sourcefile)
+#define sourceline          PARSER_VAR(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);
+};
+
+#endif

data/ext/rubinius/melbourne/quark.cpp

@@ -0,0 +1,43 @@
+#include "namespace.h"
+#include "quark.hpp"
+#include "parser_state.hpp"
+
+#include <string.h>
+#include <stdlib.h>
+
+using namespace MELBOURNE;
+
+quark MELBOURNE::quark_from_string(rb_parser_state* parser_state, const char* str) {
+  if (str == NULL) {
+    return QUARK_NOT_FOUND;
+  }
+
+  /* attempt to find it in our cache */
+  quark_map::iterator it = quark_indexes->find(str);
+  if (it != quark_indexes->end()) {
+    return it->second;
+  }
+
+  /* otherwise, we need to duplicate and store the string */
+  const char* new_quark = strdup(str);
+  quarks->push_back(new_quark);
+  size_t index = quarks->size() - 1;
+  quark_indexes->insert(quark_map::value_type(new_quark,index));
+  return index;
+}
+
+const char* MELBOURNE::quark_to_string(rb_parser_state* parser_state, quark q) {
+  if (q >= quarks->size())
+    return NULL;
+  return quarks->at(q);
+}
+
+void MELBOURNE::quark_cleanup(rb_parser_state* parser_state) {
+  delete quark_indexes;
+
+  for (quark_vector::iterator it = quarks->begin(); it != quarks->end(); ++it) {
+    free((char *)*it);
+  }
+
+  delete quarks;
+}

data/ext/rubinius/melbourne/quark.hpp

@@ -0,0 +1,49 @@
+#ifndef MEL_QUARK_HPP
+#define MEL_QUARK_HPP
+
+#include <stddef.h>
+#include <cmath>
+#include <vector>
+#include <string.h>
+
+#if defined(__APPLE_CC__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1090
+#include <unordered_map>
+#define std_unordered_map std::unordered_map
+#else
+#include <tr1/unordered_map>
+#define std_unordered_map std::tr1::unordered_map
+#endif
+
+namespace MELBOURNE {
+
+  typedef size_t quark;
+
+  struct ConstCharHash {
+    size_t operator() (const char* value) const {
+      size_t length = strlen(value);
+      quark hash = 0;
+      for (size_t i = 0; i < length; i++) {
+        hash = hash * 5 + value[i];
+      }
+      return hash;
+    }
+  };
+
+  struct ConstCharEqualTo {
+    bool operator() ( const char* lhs, const char* rhs) const {
+      return strcmp(lhs, rhs) == 0;
+    }
+  };
+
+  struct rb_parser_state;
+  enum {QUARK_NOT_FOUND = ~0L};
+
+  quark quark_from_string(rb_parser_state* parser_state, const char* str);
+  const char* quark_to_string(rb_parser_state* parser_state, const quark quark);
+  void quark_cleanup(rb_parser_state* parser_state);
+
+  typedef std_unordered_map<const char*, quark, ConstCharHash, ConstCharEqualTo> quark_map;
+  typedef std::vector<const char*> quark_vector;
+};
+#endif
+

data/ext/rubinius/melbourne/symbols.cpp

@@ -0,0 +1,225 @@
+#include "namespace.h"
+#include "melbourne.hpp"
+#include "symbols.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace MELBOURNE {
+  ID rb_sAlias;
+  ID rb_sAnd;
+  ID rb_sArgs;
+  ID rb_sArgsCat;
+  ID rb_sArgsPush;
+  ID rb_sArray;
+  ID rb_sAttrAsgn;
+  ID rb_sBackRef;
+  ID rb_sBegin;
+  ID rb_sBlock;
+  ID rb_sBlockArg;
+  ID rb_sBlockPass;
+  ID rb_sBreak;
+  ID rb_sCall;
+  ID rb_sCase;
+  ID rb_sCDecl;
+  ID rb_sClass;
+  ID rb_sColon2;
+  ID rb_sColon3;
+  ID rb_sConst;
+  ID rb_sCVar;
+  ID rb_sCVAsgn;
+  ID rb_sCVDecl;
+  ID rb_sData;
+  ID rb_sDefined;
+  ID rb_sDefn;
+  ID rb_sDefs;
+  ID rb_sDot2;
+  ID rb_sDot3;
+  ID rb_sDRegx;
+  ID rb_sDRegxOnce;
+  ID rb_sDStr;
+  ID rb_sDSym;
+  ID rb_sDXStr;
+  ID rb_sEncoding;
+  ID rb_sEnsure;
+  ID rb_sEvStr;
+  ID rb_sFalse;
+  ID rb_sFCall;
+  ID rb_sFile;
+  ID rb_sFixnum;
+  ID rb_sFlip2;
+  ID rb_sFlip3;
+  ID rb_sFloat;
+  ID rb_sFor;
+  ID rb_sGAsgn;
+  ID rb_sGVar;
+  ID rb_sHash;
+  ID rb_sIAsgn;
+  ID rb_sIf;
+  ID rb_sIter;
+  ID rb_sIVar;
+  ID rb_sLAsgn;
+  ID rb_sLambda;
+  ID rb_sLit;
+  ID rb_sLVar;
+  ID rb_sMAsgn;
+  ID rb_sMatch;
+  ID rb_sMatch2;
+  ID rb_sMatch3;
+  ID rb_sModule;
+  ID rb_sNegate;
+  ID rb_sNext;
+  ID rb_sNil;
+  ID rb_sNot;
+  ID rb_sNthRef;
+  ID rb_sNumber;
+  ID rb_sOpAsgn1;
+  ID rb_sOpAsgn2;
+  ID rb_sOpAsgnAnd;
+  ID rb_sOpAsgnOr;
+  ID rb_sOptArg;
+  ID rb_sOr;
+  ID rb_sPostExe;
+  ID rb_sPostArg;
+  ID rb_sPreExe;
+  ID rb_sRedo;
+  ID rb_sRegex;
+  ID rb_sResbody;
+  ID rb_sRescue;
+  ID rb_sRetry;
+  ID rb_sReturn;
+  ID rb_sSClass;
+  ID rb_sScope;
+  ID rb_sSelf;
+  ID rb_sSplat;
+  ID rb_sStr;
+  ID rb_sSuper;
+  ID rb_sSValue;
+  ID rb_sToAry;
+  ID rb_sTrue;
+  ID rb_sUndef;
+  ID rb_sUntil;
+  ID rb_sVAlias;
+  ID rb_sValues;
+  ID rb_sVCall;
+  ID rb_sWhen;
+  ID rb_sWhile;
+  ID rb_sXStr;
+  ID rb_sYield;
+  ID rb_sZArray;
+  ID rb_sZSuper;
+
+};
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+namespace MELBOURNE {
+
+  void init_symbols() {
+    rb_sAlias       = rb_intern("process_alias");
+    rb_sAnd         = rb_intern("process_and");
+    rb_sArgs        = rb_intern("process_args");
+    rb_sArgsCat     = rb_intern("process_argscat");
+    rb_sArgsPush    = rb_intern("process_argspush");
+    rb_sArray       = rb_intern("process_array");
+    rb_sAttrAsgn    = rb_intern("process_attrasgn");
+    rb_sBackRef     = rb_intern("process_back_ref");
+    rb_sBegin       = rb_intern("process_begin");
+    rb_sBlock       = rb_intern("process_block");
+    rb_sBlockArg    = rb_intern("process_block_arg");
+    rb_sBlockPass   = rb_intern("process_block_pass");
+    rb_sBreak       = rb_intern("process_break");
+    rb_sCall        = rb_intern("process_call");
+    rb_sCase        = rb_intern("process_case");
+    rb_sCDecl       = rb_intern("process_cdecl");
+    rb_sClass       = rb_intern("process_class");
+    rb_sColon2      = rb_intern("process_colon2");
+    rb_sColon3      = rb_intern("process_colon3");
+    rb_sConst       = rb_intern("process_const");
+    rb_sCVar        = rb_intern("process_cvar");
+    rb_sCVAsgn      = rb_intern("process_cvasgn");
+    rb_sCVDecl      = rb_intern("process_cvdecl");
+    rb_sData        = rb_intern("process_data");
+    rb_sDefined     = rb_intern("process_defined");
+    rb_sDefn        = rb_intern("process_defn");
+    rb_sDefs        = rb_intern("process_defs");
+    rb_sDot2        = rb_intern("process_dot2");
+    rb_sDot3        = rb_intern("process_dot3");
+    rb_sDRegx       = rb_intern("process_dregx");
+    rb_sDRegxOnce   = rb_intern("process_dregx_once");
+    rb_sDStr        = rb_intern("process_dstr");
+    rb_sDSym        = rb_intern("process_dsym");
+    rb_sDXStr       = rb_intern("process_dxstr");
+    rb_sEncoding    = rb_intern("process_encoding");
+    rb_sEnsure      = rb_intern("process_ensure");
+    rb_sEvStr       = rb_intern("process_evstr");
+    rb_sFalse       = rb_intern("process_false");
+    rb_sFCall       = rb_intern("process_fcall");
+    rb_sFile        = rb_intern("process_file");
+    rb_sFixnum      = rb_intern("process_fixnum");
+    rb_sFlip2       = rb_intern("process_flip2");
+    rb_sFlip3       = rb_intern("process_flip3");
+    rb_sFloat       = rb_intern("process_float");
+    rb_sFor         = rb_intern("process_for");
+    rb_sGAsgn       = rb_intern("process_gasgn");
+    rb_sGVar        = rb_intern("process_gvar");
+    rb_sHash        = rb_intern("process_hash");
+    rb_sIAsgn       = rb_intern("process_iasgn");
+    rb_sIf          = rb_intern("process_if");
+    rb_sIter        = rb_intern("process_iter");
+    rb_sIVar        = rb_intern("process_ivar");
+    rb_sLAsgn       = rb_intern("process_lasgn");
+    rb_sLambda      = rb_intern("process_lambda");
+    rb_sLit         = rb_intern("process_lit");
+    rb_sLVar        = rb_intern("process_lvar");
+    rb_sMAsgn       = rb_intern("process_masgn");
+    rb_sMatch       = rb_intern("process_match");
+    rb_sMatch2      = rb_intern("process_match2");
+    rb_sMatch3      = rb_intern("process_match3");
+    rb_sModule      = rb_intern("process_module");
+    rb_sNegate      = rb_intern("process_negate");
+    rb_sNext        = rb_intern("process_next");
+    rb_sNil         = rb_intern("process_nil");
+    rb_sNot         = rb_intern("process_not");
+    rb_sNthRef      = rb_intern("process_nth_ref");
+    rb_sNumber      = rb_intern("process_number");
+    rb_sOpAsgn1     = rb_intern("process_op_asgn1");
+    rb_sOpAsgn2     = rb_intern("process_op_asgn2");
+    rb_sOpAsgnAnd   = rb_intern("process_op_asgn_and");
+    rb_sOpAsgnOr    = rb_intern("process_op_asgn_or");
+    rb_sOptArg      = rb_intern("process_opt_arg");
+    rb_sOr          = rb_intern("process_or");
+    rb_sPostExe     = rb_intern("process_postexe");
+    rb_sPostArg     = rb_intern("process_postarg");
+    rb_sPreExe      = rb_intern("process_preexe");
+    rb_sRedo        = rb_intern("process_redo");
+    rb_sRegex       = rb_intern("process_regex");
+    rb_sResbody     = rb_intern("process_resbody");
+    rb_sRescue      = rb_intern("process_rescue");
+    rb_sRetry       = rb_intern("process_retry");
+    rb_sReturn      = rb_intern("process_return");
+    rb_sSClass      = rb_intern("process_sclass");
+    rb_sScope       = rb_intern("process_scope");
+    rb_sSelf        = rb_intern("process_self");
+    rb_sSplat       = rb_intern("process_splat");
+    rb_sStr         = rb_intern("process_str");
+    rb_sSuper       = rb_intern("process_super");
+    rb_sSValue      = rb_intern("process_svalue");
+    rb_sToAry       = rb_intern("process_to_ary");
+    rb_sTrue        = rb_intern("process_true");
+    rb_sUndef       = rb_intern("process_undef");
+    rb_sUntil       = rb_intern("process_until");
+    rb_sVAlias      = rb_intern("process_valias");
+    rb_sValues      = rb_intern("process_values");
+    rb_sVCall       = rb_intern("process_vcall");
+    rb_sWhen        = rb_intern("process_when");
+    rb_sWhile       = rb_intern("process_while");
+    rb_sXStr        = rb_intern("process_xstr");
+    rb_sYield       = rb_intern("process_yield");
+    rb_sZArray      = rb_intern("process_zarray");
+    rb_sZSuper      = rb_intern("process_zsuper");
+  }
+};