mutant-melbourne 2.0.1

data/ext/melbourne/parser_state19.hpp

@@ -0,0 +1,251 @@
+#ifndef MEL_PARSER_STATE19_HPP
+#define MEL_PARSER_STATE19_HPP
+
+#include "node19.hpp"
+#include "node_types19.hpp"
+#include "var_table19.hpp"
+#include "encoding_compat.hpp"
+
+#include "bstrlib.h"
+
+#include <vector>
+#include <list>
+
+namespace melbourne {
+  namespace grammar19 {
+
+    enum lex_state_e {
+      EXPR_BEG,       /* ignore newline, +/- is a sign. */
+      EXPR_END,       /* newline significant, +/- is an operator. */
+      EXPR_ENDARG,    /* ditto, and unbound braces. */
+      EXPR_ENDFN,     /* ditto, and unbound braces. */
+      EXPR_ARG,       /* newline significant, +/- is an operator. */
+      EXPR_CMDARG,    /* newline significant, +/- is an operator. */
+      EXPR_MID,       /* newline significant, +/- is an operator. */
+      EXPR_FNAME,     /* ignore newline, no reserved words. */
+      EXPR_DOT,       /* right after `.' or `::', no reserved words. */
+      EXPR_CLASS,     /* immediate after `class', no here document. */
+      EXPR_VALUE,     /* like EXPR_BEG but label is disallowed. */
+      EXPR_MAX_STATE
+    };
+
+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 ruby__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.
+       */
+      VALUE (*lex_gets)(rb_parser_state*, VALUE);
+
+      /* If this is set, we use the io method. */
+      int lex_io;
+      char* lex_io_buf;
+      ssize_t lex_io_index;
+      ssize_t lex_io_total;
+      long lex_io_count;
+
+      /* Otherwise, we use this. */
+      long lex_gets_ptr;
+      VALUE lex_input;
+      VALUE lex_lastline;
+      VALUE 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;
+
+      int column;
+      NODE *top_node;
+
+      struct local_vars* locals_table;
+
+      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;
+
+      // Reference to the object to call methods on to convert the
+      // C parse tree into a Ruby AST.
+      VALUE processor;
+
+      // Keep track of any object literals created in the parser.
+      VALUE references;
+
+      // Keeps track of lines that 'end' starters are on, to enable
+      // better error reporting.
+      std::list<StartPosition>* start_lines;
+
+      int line_count;
+      bool has_shebang;
+
+      char *ruby_sourcefile;
+      int ruby_sourceline;
+
+      rb_encoding *enc;
+      rb_encoding *utf8;
+    } 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 has_shebang         PARSER_VAR(has_shebang)
+#define lex_io              PARSER_VAR(lex_io)
+#define lex_io_buf          PARSER_VAR(lex_io_buf)
+#define lex_io_index        PARSER_VAR(lex_io_index)
+#define lex_io_total        PARSER_VAR(lex_io_total)
+#define lex_io_count        PARSER_VAR(lex_io_count)
+#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 column              PARSER_VAR(column)
+#define top_node            PARSER_VAR(top_node)
+#define locals_table        PARSER_VAR(locals_table)
+#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 references          PARSER_VAR(references)
+#define start_lines         PARSER_VAR(start_lines)
+#define ruby_sourcefile     PARSER_VAR(ruby_sourcefile)
+#define ruby_sourceline     PARSER_VAR(ruby_sourceline)
+
+#define node_newnode(t, a, b, c)  \
+    parser_node_newnode((rb_parser_state*)parser_state, t, a, b, c)
+#define node_add_reference(obj)   \
+    parser_add_reference((rb_parser_state*)parser_state, obj)
+
+    NODE *parser_node_newnode(rb_parser_state*, enum node_type, VALUE, VALUE, VALUE);
+    VALUE parser_add_reference(rb_parser_state* parser_state, VALUE obj);
+
+#undef ID_SCOPE_SHIFT
+#undef ID_SCOPE_MASK
+#undef ID_LOCAL
+#undef ID_INSTANCE
+#undef ID_GLOBAL
+#undef ID_ATTRSET
+#undef ID_CONST
+#undef ID_CLASS
+#undef ID_JUNK
+#undef ID_INTERNAL
+
+    ID parser_intern(const char*);
+    ID parser_intern2(const char*, long);
+    ID parser_intern3(const char*, long, rb_encoding*);
+    ID parser_intern_str(VALUE);
+    char* parser_id2name(ID);
+
+#undef ID2SYM
+#undef SYMBOL_FLAG
+
+/* ID_SCOPE_SHIFT must be at least 4 because at 3 the values will overlap
+ * the values of the tokens, causing the parser to mistake the symbol for
+ * '*' with the token tAREF. Hilarity ensues when Fixnum * Fixnum ends up
+ * parsed as Fixnum[Fixnum].
+ */
+#define ID_SCOPE_SHIFT  7
+#define ID_SCOPE_MASK   0x0f
+#define ID_LOCAL        0x00
+#define ID_INSTANCE     0x01
+#define ID_GLOBAL       0x03
+#define ID_ATTRSET      0x04
+#define ID_CONST        0x05
+#define ID_CLASS        0x06
+#define ID_JUNK         0x07
+#define ID_INTERNAL     ID_JUNK
+
+#ifdef RUBINIUS
+#define ID2SYM(id)  (VALUE)((long)(id >> ID_SCOPE_SHIFT))
+#else
+#define SYMBOL_FLAG     0xe
+#define ID2SYM(id)  ((VALUE)(((long)(id >> ID_SCOPE_SHIFT))<<8|SYMBOL_FLAG))
+#endif
+
+#define INTERNAL_ID_P(a)  ((a & ID_INTERNAL) == ID_INTERNAL)
+
+  };  // namespace grammar19
+};  // namespace melbourne
+
+#endif

data/ext/melbourne/quark.cpp

@@ -0,0 +1,42 @@
+#include "quark.hpp"
+#include "parser_state18.hpp"
+
+#include <string.h>
+#include <stdlib.h>
+
+using namespace melbourne::grammar18;
+
+quark melbourne::grammar18::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::grammar18::quark_to_string(rb_parser_state* parser_state, quark q) {
+  if (q >= quarks->size())
+    return NULL;
+  return quarks->at(q);
+}
+
+void melbourne::grammar18::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/melbourne/quark.hpp

@@ -0,0 +1,45 @@
+#ifndef MEL_QUARK_HPP
+#define MEL_QUARK_HPP
+
+#include <stddef.h>
+#include <cmath>
+#include <vector>
+#include <tr1/unordered_map>
+#include <string.h>
+
+namespace melbourne {
+
+  namespace grammar18 {
+
+    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::tr1::unordered_map<const char*, quark, ConstCharHash, ConstCharEqualTo> quark_map;
+    typedef std::vector<const char*> quark_vector;
+  };
+};
+#endif
+

data/ext/melbourne/symbols.cpp

@@ -0,0 +1,224 @@
+#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_symbols20() {
+    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");
+  }
+};

data/ext/melbourne/symbols.hpp

@@ -0,0 +1,119 @@
+#ifndef MEL_SYMBOLS_HPP
+#define MEL_SYMBOLS_HPP
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace melbourne {
+  extern ID rb_sAlias;
+  extern ID rb_sAnd;
+  extern ID rb_sArgs;
+  extern ID rb_sArgsCat;
+  extern ID rb_sArgsPush;
+  extern ID rb_sArray;
+  extern ID rb_sAttrAsgn;
+  extern ID rb_sBackRef;
+  extern ID rb_sBegin;
+  extern ID rb_sBlock;
+  extern ID rb_sBlockArg;
+  extern ID rb_sBlockPass;
+  extern ID rb_sBreak;
+  extern ID rb_sCall;
+  extern ID rb_sCase;
+  extern ID rb_sCDecl;
+  extern ID rb_sClass;
+  extern ID rb_sColon2;
+  extern ID rb_sColon3;
+  extern ID rb_sConst;
+  extern ID rb_sCVar;
+  extern ID rb_sCVAsgn;
+  extern ID rb_sCVDecl;
+  extern ID rb_sData;
+  extern ID rb_sDefined;
+  extern ID rb_sDefn;
+  extern ID rb_sDefs;
+  extern ID rb_sDot2;
+  extern ID rb_sDot3;
+  extern ID rb_sDRegx;
+  extern ID rb_sDRegxOnce;
+  extern ID rb_sDStr;
+  extern ID rb_sDSym;
+  extern ID rb_sDXStr;
+  extern ID rb_sEncoding;
+  extern ID rb_sEnsure;
+  extern ID rb_sEvStr;
+  extern ID rb_sFalse;
+  extern ID rb_sFCall;
+  extern ID rb_sFile;
+  extern ID rb_sFixnum;
+  extern ID rb_sFlip2;
+  extern ID rb_sFlip3;
+  extern ID rb_sFloat;
+  extern ID rb_sFor;
+  extern ID rb_sGAsgn;
+  extern ID rb_sGVar;
+  extern ID rb_sHash;
+  extern ID rb_sIAsgn;
+  extern ID rb_sIf;
+  extern ID rb_sIter;
+  extern ID rb_sIVar;
+  extern ID rb_sLAsgn;
+  extern ID rb_sLambda;
+  extern ID rb_sLit;
+  extern ID rb_sLVar;
+  extern ID rb_sMAsgn;
+  extern ID rb_sMatch;
+  extern ID rb_sMatch2;
+  extern ID rb_sMatch3;
+  extern ID rb_sModule;
+  extern ID rb_sNegate;
+  extern ID rb_sNext;
+  extern ID rb_sNil;
+  extern ID rb_sNot;
+  extern ID rb_sNthRef;
+  extern ID rb_sNumber;
+  extern ID rb_sOpAsgn1;
+  extern ID rb_sOpAsgn2;
+  extern ID rb_sOpAsgnAnd;
+  extern ID rb_sOpAsgnOr;
+  extern ID rb_sOptArg;
+  extern ID rb_sOr;
+  extern ID rb_sPostExe;
+  extern ID rb_sPostArg;
+  extern ID rb_sPreExe;
+  extern ID rb_sRedo;
+  extern ID rb_sRegex;
+  extern ID rb_sResbody;
+  extern ID rb_sRescue;
+  extern ID rb_sRetry;
+  extern ID rb_sReturn;
+  extern ID rb_sSClass;
+  extern ID rb_sScope;
+  extern ID rb_sSelf;
+  extern ID rb_sSplat;
+  extern ID rb_sStr;
+  extern ID rb_sSuper;
+  extern ID rb_sSValue;
+  extern ID rb_sToAry;
+  extern ID rb_sTrue;
+  extern ID rb_sUndef;
+  extern ID rb_sUntil;
+  extern ID rb_sVAlias;
+  extern ID rb_sValues;
+  extern ID rb_sVCall;
+  extern ID rb_sWhen;
+  extern ID rb_sWhile;
+  extern ID rb_sXStr;
+  extern ID rb_sYield;
+  extern ID rb_sZArray;
+  extern ID rb_sZSuper;
+
+  void init_symbols20();
+};
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+#endif