cast 0.0.1 → 0.3.1

data/Rakefile

@@ -0,0 +1,29 @@
+require 'ritual'
+require 'rake/testtask'
+
+Rake::TestTask.new(test: [:ext, 'lib/cast/c.tab.rb']) do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.warning = false
+end
+
+extension
+
+file 'ext/cast.so' => FileList['ext/*.c', 'ext/yylex.c'] do |t|
+  FileUtils.cd 'ext' do
+    ruby 'extconf.rb'
+    sh 'make'
+  end
+end
+
+file 'ext/yylex.c' => 'ext/yylex.re' do |t|
+  sh "re2c #{t.prerequisites[0]} > #{t.name}"
+end
+
+file 'lib/cast/c.tab.rb' => 'lib/cast/c.y' do |t|
+  sh "racc #{t.prerequisites[0]}"
+end
+
+task :ext => 'ext/yylex.c'
+task 'gem:build' => ['ext/yylex.c', 'lib/cast/c.tab.rb']
+CLEAN.include('ext/yylex.c', 'lib/cast/c.tab.rb')

data/cast.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('lib', File.dirname(__FILE__))
+require 'cast/version'
+
+Gem::Specification.new do |gem|
+  gem.name = 'cast'
+  gem.version = C::VERSION
+  gem.authors = ["George Ogata"]
+  gem.email = ["george.ogata@gmail.com"]
+  gem.license = 'MIT'
+  gem.date = Time.now.strftime('%Y-%m-%d')
+  gem.summary = "C parser and AST constructor."
+  gem.homepage = 'http://github.com/oggy/cast'
+
+  gem.extensions    = ["ext/extconf.rb"]
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n") + ['ext/yylex.c', 'lib/cast/c.tab.rb']
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+end

data/ext/cast.c

@@ -0,0 +1,6 @@
+#include "cast.h"
+
+void Init_cast(void) {
+  cast_mC = rb_define_module("C");
+  cast_init_parser();
+}

data/ext/cast.h

@@ -0,0 +1,141 @@
+#include <assert.h>
+#include "ruby.h"
+
+/* Modules and classes.
+ */
+extern VALUE cast_mC;
+extern VALUE cast_cParser;
+extern VALUE cast_eParseError;
+
+/*
+ * -------------------------------------------------------------------
+ *                               Helpers
+ * -------------------------------------------------------------------
+ */
+
+#define Get_Struct(value, type, sval) do {          \
+  sval = (cast_##type *)DATA_PTR(value);            \
+} while (0)
+
+#define Find_Struct(value, type, sval) do {                             \
+  if (!rb_obj_is_kind_of(value, cast_c##type))                          \
+    rb_raise(rb_eTypeError, #type " expected, got %s", rb_obj_classname(value)); \
+  sval = (cast_##type *)DATA_PTR(value);                                \
+} while (0)
+
+#define Wrap_Struct(ptr, type, klass) \
+  Data_Wrap_Struct(klass, cast_##type##_mark, cast_##type##_free, ptr)
+
+/*
+ * -------------------------------------------------------------------
+ *                               Parser
+ * -------------------------------------------------------------------
+ */
+
+typedef struct {
+  /* stuff used by yylex */
+  char *bot, *tok, *ptr, *cur, *pos, *lim, *top, *eof;
+  long  lineno;      /* line number */
+  VALUE token;       /* last token (2-element array) */
+} cast_Parser;
+
+VALUE cast_Parser_alloc(VALUE klass);
+void  cast_Parser_mark(cast_Parser *parser);
+void  cast_Parser_free(cast_Parser *parser);
+VALUE cast_Parser_next_token(VALUE self);
+void yylex(VALUE self, cast_Parser *p);
+void cast_init_parser(void);
+
+/* Lexer symbols. */
+extern VALUE cast_sym_AUTO;
+extern VALUE cast_sym_BREAK;
+extern VALUE cast_sym_CASE;
+extern VALUE cast_sym_CHAR;
+extern VALUE cast_sym_CONST;
+extern VALUE cast_sym_CONTINUE;
+extern VALUE cast_sym_DEFAULT;
+extern VALUE cast_sym_DO;
+extern VALUE cast_sym_DOUBLE;
+extern VALUE cast_sym_ELSE;
+extern VALUE cast_sym_ENUM;
+extern VALUE cast_sym_EXTERN;
+extern VALUE cast_sym_FLOAT;
+extern VALUE cast_sym_FOR;
+extern VALUE cast_sym_GOTO;
+extern VALUE cast_sym_IF;
+extern VALUE cast_sym_INT;
+extern VALUE cast_sym_LONG;
+extern VALUE cast_sym_REGISTER;
+extern VALUE cast_sym_RETURN;
+extern VALUE cast_sym_SHORT;
+extern VALUE cast_sym_SIGNED;
+extern VALUE cast_sym_SIZEOF;
+extern VALUE cast_sym_STATIC;
+extern VALUE cast_sym_STRUCT;
+extern VALUE cast_sym_SWITCH;
+extern VALUE cast_sym_TYPEDEF;
+extern VALUE cast_sym_UNION;
+extern VALUE cast_sym_UNSIGNED;
+extern VALUE cast_sym_VOID;
+extern VALUE cast_sym_VOLATILE;
+extern VALUE cast_sym_WHILE;
+extern VALUE cast_sym_INLINE;
+extern VALUE cast_sym_RESTRICT;
+extern VALUE cast_sym_BOOL;
+extern VALUE cast_sym_COMPLEX;
+extern VALUE cast_sym_IMAGINARY;
+
+extern VALUE cast_sym_FCON;
+extern VALUE cast_sym_ICON;
+extern VALUE cast_sym_ID;
+extern VALUE cast_sym_SCON;
+extern VALUE cast_sym_CCON;
+extern VALUE cast_sym_TYPENAME;
+
+extern VALUE cast_sym_ADDEQ;
+extern VALUE cast_sym_ANDAND;
+extern VALUE cast_sym_ANDEQ;
+extern VALUE cast_sym_DEC;
+extern VALUE cast_sym_ARROW;
+extern VALUE cast_sym_DIVEQ;
+extern VALUE cast_sym_ELLIPSIS;
+extern VALUE cast_sym_EQEQ;
+extern VALUE cast_sym_GEQ;
+extern VALUE cast_sym_INC;
+extern VALUE cast_sym_LEQ;
+extern VALUE cast_sym_LSHIFT;
+extern VALUE cast_sym_LSHIFTEQ;
+extern VALUE cast_sym_MODEQ;
+extern VALUE cast_sym_MULEQ;
+extern VALUE cast_sym_NEQ;
+extern VALUE cast_sym_OREQ;
+extern VALUE cast_sym_OROR;
+extern VALUE cast_sym_RSHIFT;
+extern VALUE cast_sym_RSHIFTEQ;
+extern VALUE cast_sym_SUBEQ;
+extern VALUE cast_sym_XOREQ;
+
+extern VALUE cast_sym_SEMICOLON;
+extern VALUE cast_sym_LBRACE;
+extern VALUE cast_sym_RBRACE;
+extern VALUE cast_sym_COMMA;
+extern VALUE cast_sym_COLON;
+extern VALUE cast_sym_EQ;
+extern VALUE cast_sym_LPAREN;
+extern VALUE cast_sym_RPAREN;
+extern VALUE cast_sym_LBRACKET;
+extern VALUE cast_sym_RBRACKET;
+extern VALUE cast_sym_DOT;
+extern VALUE cast_sym_AND;
+extern VALUE cast_sym_BANG;
+extern VALUE cast_sym_NOT;
+extern VALUE cast_sym_SUB;
+extern VALUE cast_sym_ADD;
+extern VALUE cast_sym_MUL;
+extern VALUE cast_sym_DIV;
+extern VALUE cast_sym_MOD;
+extern VALUE cast_sym_LT;
+extern VALUE cast_sym_GT;
+extern VALUE cast_sym_XOR;
+extern VALUE cast_sym_OR;
+extern VALUE cast_sym_QUESTION;

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'cast/cast'

data/ext/parser.c

@@ -0,0 +1,287 @@
+#include "cast.h"
+
+/* Modules and classes.
+ */
+VALUE cast_mC;
+VALUE cast_cParser;
+VALUE cast_eParseError;
+
+/* Lexer symbols.
+ */
+VALUE cast_sym_AUTO;
+VALUE cast_sym_BREAK;
+VALUE cast_sym_CASE;
+VALUE cast_sym_CHAR;
+VALUE cast_sym_CONST;
+VALUE cast_sym_CONTINUE;
+VALUE cast_sym_DEFAULT;
+VALUE cast_sym_DO;
+VALUE cast_sym_DOUBLE;
+VALUE cast_sym_ELSE;
+VALUE cast_sym_ENUM;
+VALUE cast_sym_EXTERN;
+VALUE cast_sym_FLOAT;
+VALUE cast_sym_FOR;
+VALUE cast_sym_GOTO;
+VALUE cast_sym_IF;
+VALUE cast_sym_INT;
+VALUE cast_sym_LONG;
+VALUE cast_sym_REGISTER;
+VALUE cast_sym_RETURN;
+VALUE cast_sym_SHORT;
+VALUE cast_sym_SIGNED;
+VALUE cast_sym_SIZEOF;
+VALUE cast_sym_STATIC;
+VALUE cast_sym_STRUCT;
+VALUE cast_sym_SWITCH;
+VALUE cast_sym_TYPEDEF;
+VALUE cast_sym_UNION;
+VALUE cast_sym_UNSIGNED;
+VALUE cast_sym_VOID;
+VALUE cast_sym_VOLATILE;
+VALUE cast_sym_WHILE;
+VALUE cast_sym_INLINE;
+VALUE cast_sym_RESTRICT;
+VALUE cast_sym_BOOL;
+VALUE cast_sym_COMPLEX;
+VALUE cast_sym_IMAGINARY;
+
+VALUE cast_sym_FCON;
+VALUE cast_sym_ICON;
+VALUE cast_sym_ID;
+VALUE cast_sym_SCON;
+VALUE cast_sym_CCON;
+VALUE cast_sym_TYPENAME;
+
+VALUE cast_sym_ADDEQ;
+VALUE cast_sym_ANDAND;
+VALUE cast_sym_ANDEQ;
+VALUE cast_sym_DEC;
+VALUE cast_sym_ARROW;
+VALUE cast_sym_DIVEQ;
+VALUE cast_sym_ELLIPSIS;
+VALUE cast_sym_EQEQ;
+VALUE cast_sym_GEQ;
+VALUE cast_sym_INC;
+VALUE cast_sym_LEQ;
+VALUE cast_sym_LSHIFT;
+VALUE cast_sym_LSHIFTEQ;
+VALUE cast_sym_MODEQ;
+VALUE cast_sym_MULEQ;
+VALUE cast_sym_NEQ;
+VALUE cast_sym_OREQ;
+VALUE cast_sym_OROR;
+VALUE cast_sym_RSHIFT;
+VALUE cast_sym_RSHIFTEQ;
+VALUE cast_sym_SUBEQ;
+VALUE cast_sym_XOREQ;
+
+VALUE cast_sym_SEMICOLON;
+VALUE cast_sym_LBRACE;
+VALUE cast_sym_RBRACE;
+VALUE cast_sym_COMMA;
+VALUE cast_sym_COLON;
+VALUE cast_sym_EQ;
+VALUE cast_sym_LPAREN;
+VALUE cast_sym_RPAREN;
+VALUE cast_sym_LBRACKET;
+VALUE cast_sym_RBRACKET;
+VALUE cast_sym_DOT;
+VALUE cast_sym_AND;
+VALUE cast_sym_BANG;
+VALUE cast_sym_NOT;
+VALUE cast_sym_SUB;
+VALUE cast_sym_ADD;
+VALUE cast_sym_MUL;
+VALUE cast_sym_DIV;
+VALUE cast_sym_MOD;
+VALUE cast_sym_LT;
+VALUE cast_sym_GT;
+VALUE cast_sym_XOR;
+VALUE cast_sym_OR;
+VALUE cast_sym_QUESTION;
+
+VALUE cast_Parser_alloc(VALUE klass) {
+  VALUE ret;
+  cast_Parser *ret_p;
+  ret_p = ALLOC(cast_Parser);
+  memset(ret_p, 0, sizeof(cast_Parser));
+  ret = Wrap_Struct(ret_p, Parser, klass);
+  ret_p->lineno = 1;
+  ret_p->token = rb_ary_new2(2);
+  rb_ary_push(ret_p->token, Qnil);
+  rb_ary_push(ret_p->token, Qnil);
+  return ret;
+}
+
+void cast_Parser_mark(cast_Parser *parser) {
+  rb_gc_mark(parser->token);
+}
+
+void cast_Parser_free(cast_Parser *parser) {
+  /* nothing to do */
+}
+
+/* (Private.)  Called by #parse to prepare for lexing.
+ */
+VALUE cast_Parser_prepare_lexer(VALUE self, VALUE string) {
+  cast_Parser *self_p;
+  char *b, *e;
+
+  Get_Struct(self, Parser, self_p);
+  string = rb_convert_type(string, T_STRING, "String", "to_s");
+
+  b = RSTRING_PTR(string);
+  e = b + RSTRING_LEN(string) + 1;
+
+  self_p->bot = b;
+  self_p->tok = b;
+  self_p->ptr = b;
+  self_p->cur = b;
+  self_p->pos = b;
+  self_p->lim = e;
+  self_p->top = e;
+  self_p->eof = e;
+  self_p->lineno = 1;
+
+  return Qnil;
+}
+
+/* (Private.)  Called by #parse to get the next token (as required by
+ * racc).  Returns a 2-element array: [TOKEN_SYM, VALUE].
+ */
+VALUE cast_Parser_next_token(VALUE self) {
+  cast_Parser *self_p;
+  VALUE token, pos;
+  Get_Struct(self, Parser, self_p);
+
+  /* clear the token val */
+  rb_ary_store(self_p->token, 1, Qnil);
+
+  /* call the lexer */
+  yylex(self, self_p);
+
+  /* return nil if EOF */
+  if (rb_ary_entry(self_p->token, 0) == Qnil)
+    return Qnil;
+
+  /* set self.pos */
+  pos = rb_iv_get(self, "@pos");
+  rb_funcall(pos, rb_intern("line_num="), 1, LONG2NUM(self_p->lineno));
+  /* make token */
+  token = rb_funcall(rb_const_get(cast_cParser, rb_intern("Token")),
+                     rb_intern("new"), 2,
+                     rb_funcall2(pos, rb_intern("dup"), 0, NULL),
+                     rb_ary_entry(self_p->token, 1));
+  /* put the token in the array */
+  rb_ary_store(self_p->token, 1, token);
+  return self_p->token;
+}
+
+/* Called from Init_cast_ext to initialize the Parser section.
+ */
+void cast_init_parser(void) {
+  VALUE cRaccParser;
+  rb_require("racc/parser");
+  cRaccParser = rb_const_get(rb_const_get(rb_cObject, rb_intern("Racc")),
+                             rb_intern("Parser"));
+  cast_cParser = rb_define_class_under(cast_mC, "Parser", cRaccParser);
+  rb_define_alloc_func(cast_cParser, cast_Parser_alloc);
+  cast_eParseError = rb_define_class_under(cast_mC, "ParseError", rb_eStandardError);
+
+  rb_define_private_method(cast_cParser, "next_token", cast_Parser_next_token, 0);
+  rb_define_private_method(cast_cParser, "prepare_lexer", cast_Parser_prepare_lexer, 1);
+
+  cast_sym_AUTO        = ID2SYM(rb_intern("AUTO"));
+  cast_sym_BREAK       = ID2SYM(rb_intern("BREAK"));
+  cast_sym_CASE        = ID2SYM(rb_intern("CASE"));
+  cast_sym_CHAR        = ID2SYM(rb_intern("CHAR"));
+  cast_sym_CONST       = ID2SYM(rb_intern("CONST"));
+  cast_sym_CONTINUE    = ID2SYM(rb_intern("CONTINUE"));
+  cast_sym_DEFAULT     = ID2SYM(rb_intern("DEFAULT"));
+  cast_sym_DO          = ID2SYM(rb_intern("DO"));
+  cast_sym_DOUBLE      = ID2SYM(rb_intern("DOUBLE"));
+  cast_sym_ELSE        = ID2SYM(rb_intern("ELSE"));
+  cast_sym_ENUM        = ID2SYM(rb_intern("ENUM"));
+  cast_sym_EXTERN      = ID2SYM(rb_intern("EXTERN"));
+  cast_sym_FLOAT       = ID2SYM(rb_intern("FLOAT"));
+  cast_sym_FOR         = ID2SYM(rb_intern("FOR"));
+  cast_sym_GOTO        = ID2SYM(rb_intern("GOTO"));
+  cast_sym_IF          = ID2SYM(rb_intern("IF"));
+  cast_sym_INT         = ID2SYM(rb_intern("INT"));
+  cast_sym_LONG        = ID2SYM(rb_intern("LONG"));
+  cast_sym_REGISTER    = ID2SYM(rb_intern("REGISTER"));
+  cast_sym_RETURN      = ID2SYM(rb_intern("RETURN"));
+  cast_sym_SHORT       = ID2SYM(rb_intern("SHORT"));
+  cast_sym_SIGNED      = ID2SYM(rb_intern("SIGNED"));
+  cast_sym_SIZEOF      = ID2SYM(rb_intern("SIZEOF"));
+  cast_sym_STATIC      = ID2SYM(rb_intern("STATIC"));
+  cast_sym_STRUCT      = ID2SYM(rb_intern("STRUCT"));
+  cast_sym_SWITCH      = ID2SYM(rb_intern("SWITCH"));
+  cast_sym_TYPEDEF     = ID2SYM(rb_intern("TYPEDEF"));
+  cast_sym_UNION       = ID2SYM(rb_intern("UNION"));
+  cast_sym_UNSIGNED    = ID2SYM(rb_intern("UNSIGNED"));
+  cast_sym_VOID        = ID2SYM(rb_intern("VOID"));
+  cast_sym_VOLATILE    = ID2SYM(rb_intern("VOLATILE"));
+  cast_sym_WHILE       = ID2SYM(rb_intern("WHILE"));
+  cast_sym_INLINE      = ID2SYM(rb_intern("INLINE"));
+  cast_sym_RESTRICT    = ID2SYM(rb_intern("RESTRICT"));
+  cast_sym_BOOL        = ID2SYM(rb_intern("BOOL"));
+  cast_sym_COMPLEX     = ID2SYM(rb_intern("COMPLEX"));
+  cast_sym_IMAGINARY   = ID2SYM(rb_intern("IMAGINARY"));
+
+  cast_sym_FCON        = ID2SYM(rb_intern("FCON"));
+  cast_sym_ICON        = ID2SYM(rb_intern("ICON"));
+  cast_sym_ID          = ID2SYM(rb_intern("ID"));
+  cast_sym_SCON        = ID2SYM(rb_intern("SCON"));
+  cast_sym_CCON        = ID2SYM(rb_intern("CCON"));
+  cast_sym_TYPENAME    = ID2SYM(rb_intern("TYPENAME"));
+
+  cast_sym_ADDEQ       = ID2SYM(rb_intern("ADDEQ"));
+  cast_sym_ANDAND      = ID2SYM(rb_intern("ANDAND"));
+  cast_sym_ANDEQ       = ID2SYM(rb_intern("ANDEQ"));
+  cast_sym_DEC         = ID2SYM(rb_intern("DEC"));
+  cast_sym_ARROW       = ID2SYM(rb_intern("ARROW"));
+  cast_sym_DIVEQ       = ID2SYM(rb_intern("DIVEQ"));
+  cast_sym_ELLIPSIS    = ID2SYM(rb_intern("ELLIPSIS"));
+  cast_sym_EQEQ        = ID2SYM(rb_intern("EQEQ"));
+  cast_sym_GEQ         = ID2SYM(rb_intern("GEQ"));
+  cast_sym_INC         = ID2SYM(rb_intern("INC"));
+  cast_sym_LEQ         = ID2SYM(rb_intern("LEQ"));
+  cast_sym_LSHIFT      = ID2SYM(rb_intern("LSHIFT"));
+  cast_sym_LSHIFTEQ    = ID2SYM(rb_intern("LSHIFTEQ"));
+  cast_sym_MODEQ       = ID2SYM(rb_intern("MODEQ"));
+  cast_sym_MULEQ       = ID2SYM(rb_intern("MULEQ"));
+  cast_sym_NEQ         = ID2SYM(rb_intern("NEQ"));
+  cast_sym_OREQ        = ID2SYM(rb_intern("OREQ"));
+  cast_sym_OROR        = ID2SYM(rb_intern("OROR"));
+  cast_sym_RSHIFT      = ID2SYM(rb_intern("RSHIFT"));
+  cast_sym_RSHIFTEQ    = ID2SYM(rb_intern("RSHIFTEQ"));
+  cast_sym_SUBEQ       = ID2SYM(rb_intern("SUBEQ"));
+  cast_sym_XOREQ       = ID2SYM(rb_intern("XOREQ"));
+
+  cast_sym_SEMICOLON   = ID2SYM(rb_intern("SEMICOLON"));
+  cast_sym_LBRACE      = ID2SYM(rb_intern("LBRACE"));
+  cast_sym_RBRACE      = ID2SYM(rb_intern("RBRACE"));
+  cast_sym_COMMA       = ID2SYM(rb_intern("COMMA"));
+  cast_sym_COLON       = ID2SYM(rb_intern("COLON"));
+  cast_sym_EQ          = ID2SYM(rb_intern("EQ"));
+  cast_sym_LPAREN      = ID2SYM(rb_intern("LPAREN"));
+  cast_sym_RPAREN      = ID2SYM(rb_intern("RPAREN"));
+  cast_sym_LBRACKET    = ID2SYM(rb_intern("LBRACKET"));
+  cast_sym_RBRACKET    = ID2SYM(rb_intern("RBRACKET"));
+  cast_sym_DOT         = ID2SYM(rb_intern("DOT"));
+  cast_sym_AND         = ID2SYM(rb_intern("AND"));
+  cast_sym_BANG        = ID2SYM(rb_intern("BANG"));
+  cast_sym_NOT         = ID2SYM(rb_intern("NOT"));
+  cast_sym_SUB         = ID2SYM(rb_intern("SUB"));
+  cast_sym_ADD         = ID2SYM(rb_intern("ADD"));
+  cast_sym_MUL         = ID2SYM(rb_intern("MUL"));
+  cast_sym_DIV         = ID2SYM(rb_intern("DIV"));
+  cast_sym_MOD         = ID2SYM(rb_intern("MOD"));
+  cast_sym_LT          = ID2SYM(rb_intern("LT"));
+  cast_sym_GT          = ID2SYM(rb_intern("GT"));
+  cast_sym_XOR         = ID2SYM(rb_intern("XOR"));
+  cast_sym_OR          = ID2SYM(rb_intern("OR"));
+  cast_sym_QUESTION    = ID2SYM(rb_intern("QUESTION"));
+}