melbourne 1.0.0

data/ext/melbourne/node_types.cpp

@@ -0,0 +1,245 @@
+/* This file is generated by node_types.rb. Do not edit. */
+
+#include "node_types.hpp"
+
+namespace melbourne {
+
+  static const char node_types[] = {
+    "method\0"
+    "fbody\0"
+    "cfunc\0"
+    "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"
+    "not\0"
+    "masgn\0"
+    "lasgn\0"
+    "dasgn\0"
+    "dasgn_curr\0"
+    "gasgn\0"
+    "iasgn\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"
+    "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"
+    "argscat\0"
+    "argspush\0"
+    "splat\0"
+    "to_ary\0"
+    "svalue\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"
+    "cref\0"
+    "dot2\0"
+    "dot3\0"
+    "flip2\0"
+    "flip3\0"
+    "attrset\0"
+    "self\0"
+    "nil\0"
+    "true\0"
+    "false\0"
+    "defined\0"
+    "newline\0"
+    "postexe\0"
+    "dmethod\0"
+    "bmethod\0"
+    "memo\0"
+    "ifunc\0"
+    "dsym\0"
+    "attrasgn\0"
+    "regex\0"
+    "fixnum\0"
+    "number\0"
+    "hexnum\0"
+    "binnum\0"
+    "octnum\0"
+    "float\0"
+    "negate\0"
+    "last\0"
+    "file\0"
+    "end_data\0"
+  };
+
+  static const unsigned short node_types_offsets[] = {
+    0,
+    7,
+    13,
+    19,
+    25,
+    31,
+    34,
+    39,
+    44,
+    50,
+    56,
+    62,
+    67,
+    71,
+    77,
+    82,
+    87,
+    93,
+    99,
+    106,
+    114,
+    121,
+    125,
+    128,
+    132,
+    138,
+    144,
+    150,
+    161,
+    167,
+    173,
+    179,
+    186,
+    193,
+    202,
+    211,
+    223,
+    234,
+    239,
+    245,
+    251,
+    257,
+    264,
+    270,
+    277,
+    282,
+    289,
+    295,
+    300,
+    305,
+    310,
+    315,
+    321,
+    326,
+    334,
+    343,
+    349,
+    356,
+    363,
+    367,
+    371,
+    376,
+    381,
+    387,
+    393,
+    399,
+    410,
+    415,
+    423,
+    432,
+    438,
+    445,
+    452,
+    462,
+    473,
+    478,
+    483,
+    489,
+    496,
+    502,
+    508,
+    515,
+    522,
+    529,
+    536,
+    541,
+    546,
+    551,
+    557,
+    563,
+    571,
+    576,
+    580,
+    585,
+    591,
+    599,
+    607,
+    615,
+    623,
+    631,
+    636,
+    642,
+    647,
+    656,
+    662,
+    669,
+    676,
+    683,
+    690,
+    697,
+    703,
+    710,
+    715,
+    720
+  };
+
+  const char *get_node_type_string(enum node_type nt) {
+    return node_types + node_types_offsets[nt];
+  }
+
+};  // namespace melbourne

data/ext/melbourne/node_types.hpp

@@ -0,0 +1,135 @@
+#ifndef MEL_NODE_TYPES_HPP
+#define MEL_NODE_TYPES_HPP
+/* This file is generated by node_types.rb. Do not edit. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace melbourne {
+
+  enum node_type {
+    NODE_METHOD,
+    NODE_FBODY,
+    NODE_CFUNC,
+    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_NOT,
+    NODE_MASGN,
+    NODE_LASGN,
+    NODE_DASGN,
+    NODE_DASGN_CURR,
+    NODE_GASGN,
+    NODE_IASGN,
+    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_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_ARGSCAT,
+    NODE_ARGSPUSH,
+    NODE_SPLAT,
+    NODE_TO_ARY,
+    NODE_SVALUE,
+    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_CREF,
+    NODE_DOT2,
+    NODE_DOT3,
+    NODE_FLIP2,
+    NODE_FLIP3,
+    NODE_ATTRSET,
+    NODE_SELF,
+    NODE_NIL,
+    NODE_TRUE,
+    NODE_FALSE,
+    NODE_DEFINED,
+    NODE_NEWLINE,
+    NODE_POSTEXE,
+    NODE_DMETHOD,
+    NODE_BMETHOD,
+    NODE_MEMO,
+    NODE_IFUNC,
+    NODE_DSYM,
+    NODE_ATTRASGN,
+    NODE_REGEX,
+    NODE_FIXNUM,
+    NODE_NUMBER,
+    NODE_HEXNUM,
+    NODE_BINNUM,
+    NODE_OCTNUM,
+    NODE_FLOAT,
+    NODE_NEGATE,
+    NODE_LAST,
+    NODE_FILE,
+    NODE_END_DATA
+  };
+
+  const char *get_node_type_string(enum node_type nt);
+
+};  // namespace melbourne
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif

data/ext/melbourne/node_types.rb

@@ -0,0 +1,190 @@
+node_types = %w{
+  method
+  fbody
+  cfunc
+  scope
+  block
+  if
+  case
+  when
+  opt_n
+  while
+  until
+  iter
+  for
+  break
+  next
+  redo
+  retry
+  begin
+  rescue
+  resbody
+  ensure
+  and
+  or
+  not
+  masgn
+  lasgn
+  dasgn
+  dasgn_curr
+  gasgn
+  iasgn
+  cdecl
+  cvasgn
+  cvdecl
+  op_asgn1
+  op_asgn2
+  op_asgn_and
+  op_asgn_or
+  call
+  fcall
+  vcall
+  super
+  zsuper
+  array
+  zarray
+  hash
+  return
+  yield
+  lvar
+  dvar
+  gvar
+  ivar
+  const
+  cvar
+  nth_ref
+  back_ref
+  match
+  match2
+  match3
+  lit
+  str
+  dstr
+  xstr
+  dxstr
+  evstr
+  dregx
+  dregx_once
+  args
+  argscat
+  argspush
+  splat
+  to_ary
+  svalue
+  block_arg
+  block_pass
+  defn
+  defs
+  alias
+  valias
+  undef
+  class
+  module
+  sclass
+  colon2
+  colon3
+  cref
+  dot2
+  dot3
+  flip2
+  flip3
+  attrset
+  self
+  nil
+  true
+  false
+  defined
+  newline
+  postexe
+  dmethod
+  bmethod
+  memo
+  ifunc
+  dsym
+  attrasgn
+  regex
+  fixnum
+  number
+  hexnum
+  binnum
+  octnum
+  float
+  negate
+  last
+  file
+  end_data
+}
+
+File.open("node_types.cpp", "w") do |f|
+  f.puts <<EOF
+/* This file is generated by node_types.rb. Do not edit. */
+
+#include "node_types.hpp"
+
+namespace melbourne {
+
+  static const char node_types[] = {
+EOF
+
+  node_types.each do |type|
+    f.puts("    \"#{type}\\0\"")
+  end
+
+  f.puts("  };")
+  f.puts
+
+  f.puts("  static const unsigned short node_types_offsets[] = {")
+  offset = 0
+
+  node_types.each_with_index do |type, index|
+    f.puts(",") if index > 0
+    f.write("    #{offset}")
+    offset += node_types[index].length + 1
+  end
+
+  f.puts <<EOF
+
+  };
+
+  const char *get_node_type_string(enum node_type nt) {
+    return node_types + node_types_offsets[nt];
+  }
+
+};  // namespace melbourne
+EOF
+end
+
+File.open("node_types.hpp", "w") do |f|
+  f.puts <<EOF
+#ifndef MEL_NODE_TYPES_HPP
+#define MEL_NODE_TYPES_HPP
+/* This file is generated by node_types.rb. Do not edit. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace melbourne {
+
+  enum node_type {
+EOF
+
+  node_types.each_with_index do |type, index|
+    f.puts(",") if index > 0
+    f.write("    NODE_#{type.upcase}")
+  end
+
+  f.puts <<EOF
+
+  };
+
+  const char *get_node_type_string(enum node_type nt);
+
+};  // namespace melbourne
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif
+EOF
+end

data/ext/melbourne/quark.cpp

@@ -0,0 +1,52 @@
+#include "quark.hpp"
+#include <tr1/unordered_map>
+#include <vector>
+#include <string.h>
+
+using namespace melbourne;
+
+struct ConstCharHash {
+  size_t operator() (const char* value) const {
+    size_t length = strlen(value);
+    size_t 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;
+  }
+};
+
+typedef std::tr1::unordered_map<const char*, int, ConstCharHash, ConstCharEqualTo> quark_map;
+typedef std::vector<const char*> quark_vector;
+
+static quark_map quark_indexes;
+static quark_vector quarks;
+
+quark melbourne::quark_from_string(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(quark q) {
+  if (q >= quarks.size())
+    return NULL;
+  return quarks[q];
+}

data/ext/melbourne/quark.hpp

@@ -0,0 +1,14 @@
+#ifndef MEL_QUARK_HPP
+#define MEL_QUARK_HPP
+
+#include <cstddef>
+
+namespace melbourne {
+  typedef size_t quark;
+  enum {QUARK_NOT_FOUND = ~0L};
+
+  quark quark_from_string(const char* str);
+  const char* quark_to_string(const quark quark);
+}
+#endif
+