rubinius-melbourne 1.0.0.8

data/ext/rubinius/melbourne/node_types.cpp

@@ -0,0 +1,254 @@
+/* This file is generated by node_types.rb. Do not edit. */
+
+#include "namespace.h"
+#include "node_types.hpp"
+
+#include <stdio.h>
+
+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"
+    "preexe\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,
+    727
+  };
+
+  const char *get_node_type_string(enum node_type node) {
+    if(node < 114) {
+      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;
+    }
+  }
+};

data/ext/rubinius/melbourne/node_types.hpp

@@ -0,0 +1,127 @@
+#ifndef MEL_NODE_TYPES_HPP
+#define MEL_NODE_TYPES_HPP
+/* This file is generated by node_types.rb. Do not edit. */
+
+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_PREEXE
+  };
+
+  const char *get_node_type_string(enum node_type nt);
+
+};
+
+#endif

data/ext/rubinius/melbourne/node_types.rb

@@ -0,0 +1,185 @@
+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
+  preexe
+]
+
+def write_node_types(list)
+  File.open("node_types.cpp", "wb") do |f|
+    f.puts <<EOF
+/* This file is generated by node_types.rb. Do not edit. */
+
+#include "node_types.hpp"
+
+#include <stdio.h>
+
+namespace MELBOURNE {
+  static const char node_types[] = {
+EOF
+
+    indexes = [0]
+    list.each do |type|
+      f.puts("    \"#{type}\\0\"")
+      indexes.push indexes.last + type.size + 1
+    end
+
+    f.puts("  };")
+    f.puts
+
+    f.puts("  static const unsigned short node_types_offsets[] = {")
+
+    f.puts indexes.map { |i| "    #{i}" }.join(",\n")
+
+    f.puts <<EOF
+  };
+
+  const char *get_node_type_string(enum node_type node) {
+    if(node < #{list.size}) {
+      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;
+    }
+  }
+};
+EOF
+  end
+
+  File.open("node_types.hpp", "wb") 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. */
+
+namespace MELBOURNE {
+  enum node_type {
+EOF
+
+  f.puts list.map { |x| "    NODE_#{x.upcase}" }.join(",\n")
+
+  f.puts <<EOF
+  };
+
+  const char *get_node_type_string(enum node_type nt);
+
+};
+
+#endif
+EOF
+  end
+end
+
+write_node_types node_types