cast19 0.1.0 → 0.1.1

data/ext/cast19/extconf.rb

@@ -1,2 +1,2 @@
 require 'mkmf'
-create_makefile('cast_ext')
+create_makefile('cast19/cast_ext')

data/ext/cast19/yylex.re

@@ -0,0 +1,330 @@
+/* -*- mode: c -*- */
+/* Given to re2c to generate the lexer `yylex'.
+ *
+ * Based on c.re in the exmaples distributed with re2c.
+ */
+#include <string.h>
+#include "cast.h"
+
+/*
+ * -------------------------------------------------------------------
+ *                               Helpers
+ * -------------------------------------------------------------------
+ */
+
+#define new_func(Foo)                                       \
+VALUE cast_new_##Foo##_at(long pos) {                       \
+  VALUE c##Foo;                                             \
+  c##Foo = rb_const_get(cast_mC, rb_intern(#Foo));          \
+  return rb_funcall2(c##Foo, rb_intern("new"), 0, NULL);    \
+}
+#define set_func(Foo, field)                                    \
+VALUE cast_##Foo##_set_##field(VALUE self, VALUE value) {       \
+  return rb_funcall2(self, rb_intern(#field "="), 1, &value);   \
+}
+
+new_func(IntLiteral);
+set_func(IntLiteral, format);
+set_func(IntLiteral, val);
+set_func(IntLiteral, suffix);
+
+new_func(FloatLiteral);
+set_func(FloatLiteral, format);
+set_func(FloatLiteral, val);
+set_func(FloatLiteral, suffix);
+
+new_func(CharLiteral);
+set_func(CharLiteral, wide);
+set_func(CharLiteral, val);
+
+new_func(StringLiteral);
+set_func(StringLiteral, wide);
+set_func(StringLiteral, val);
+
+/*
+ * -------------------------------------------------------------------
+ *                                yylex
+ * -------------------------------------------------------------------
+ */
+#define BSIZE     8192
+
+#define YYLTYPE VALUE
+
+#define YYCTYPE   char
+#define YYCURSOR  cursor
+#define YYLIMIT   p->lim
+#define YYMARKER  p->ptr
+#define YYFILL(n) {}
+
+#define RET(sym)      {p->cur = cursor; rb_ary_store(p->token, 0, sym); rb_ary_store(p->token, 1, sym  ); return;}
+#define RETVALUE(sym) {p->cur = cursor; rb_ary_store(p->token, 0, sym); rb_ary_store(p->token, 1, value); return;}
+
+/* Raise a ParseError.  `s' is the format string for the exception
+ * message, which must contain exactly one '%s', which is replaced by
+ * the string delimited by `b' and `e'.
+ */
+static void error1(char *s, char *b, char *e) {
+  char *str;
+  str = ALLOCA_N(char, e - b + 1);
+  memcpy(str, b, e-b);
+  str[e-b] = '\0';
+  rb_raise(cast_eParseError, s, str);
+}
+
+/* `token' is assumed to be a two element array, which is filled in.
+ */
+void yylex(VALUE self, cast_Parser *p) {
+  char *cursor = p->cur;
+  char *cp;
+  VALUE value;
+ std:
+  p->tok = cursor;
+  /*!re2c
+    any      = [\000-\377];
+    O        = [0-7];
+    D        = [0-9];
+    H        = [a-fA-F0-9];
+    N        = [1-9];
+    L        = [a-zA-Z_];
+    E        = [Ee] [+-]? D+;
+    P        = [Pp] [+-]? D+;
+    FS       = [fFlL];
+    IS       = [uUlL]+;
+
+    ESC      = [\\] ([abfnrtv?'"\\] | O (O O?)? | "x" H+);
+  */
+  /*!re2c
+    "/*"         { goto comment; }
+    "//"         { goto comment2; }
+
+    "auto"       { RET(cast_sym_AUTO); }
+    "break"      { RET(cast_sym_BREAK); }
+    "case"       { RET(cast_sym_CASE); }
+    "char"       { RET(cast_sym_CHAR); }
+    "const"      { RET(cast_sym_CONST); }
+    "continue"   { RET(cast_sym_CONTINUE); }
+    "default"    { RET(cast_sym_DEFAULT); }
+    "do"         { RET(cast_sym_DO); }
+    "double"     { RET(cast_sym_DOUBLE); }
+    "else"       { RET(cast_sym_ELSE); }
+    "enum"       { RET(cast_sym_ENUM); }
+    "extern"     { RET(cast_sym_EXTERN); }
+    "float"      { RET(cast_sym_FLOAT); }
+    "for"        { RET(cast_sym_FOR); }
+    "goto"       { RET(cast_sym_GOTO); }
+    "if"         { RET(cast_sym_IF); }
+    "int"        { RET(cast_sym_INT); }
+    "long"       { RET(cast_sym_LONG); }
+    "register"   { RET(cast_sym_REGISTER); }
+    "return"     { RET(cast_sym_RETURN); }
+    "short"      { RET(cast_sym_SHORT); }
+    "signed"     { RET(cast_sym_SIGNED); }
+    "sizeof"     { RET(cast_sym_SIZEOF); }
+    "static"     { RET(cast_sym_STATIC); }
+    "struct"     { RET(cast_sym_STRUCT); }
+    "switch"     { RET(cast_sym_SWITCH); }
+    "typedef"    { RET(cast_sym_TYPEDEF); }
+    "union"      { RET(cast_sym_UNION); }
+    "unsigned"   { RET(cast_sym_UNSIGNED); }
+    "void"       { RET(cast_sym_VOID); }
+    "volatile"   { RET(cast_sym_VOLATILE); }
+    "while"      { RET(cast_sym_WHILE); }
+    "inline"     { RET(cast_sym_INLINE); }
+    "restrict"   { RET(cast_sym_RESTRICT); }
+    "_Bool"      { RET(cast_sym_BOOL); }
+    "_Complex"   { RET(cast_sym_COMPLEX); }
+    "_Imaginary" { RET(cast_sym_IMAGINARY); }
+
+    L (L|D)* {
+        value = rb_str_new(p->tok, cursor - p->tok);
+        if (rb_funcall2(rb_funcall2(self, rb_intern("type_names"), 0, NULL),
+                       rb_intern("include?"), 1, &value) == Qtrue) {
+          RETVALUE(cast_sym_TYPENAME);
+        } else {
+          RETVALUE(cast_sym_ID);
+        }
+    }
+
+    SUF = L(L|D)*;
+
+    "0" [xX] H+ SUF? {
+        value = cast_new_IntLiteral_at(p->lineno);
+        cast_IntLiteral_set_format(value, ID2SYM(rb_intern("hex")));
+        cast_IntLiteral_set_val(value, LONG2NUM(strtol(p->tok, (char **)&cp, 16)));
+        if (cp < cursor)
+            cast_IntLiteral_set_suffix(value, rb_str_new(cp, cursor - cp));
+        RETVALUE(cast_sym_ICON);
+    }
+    "0" D+ SUF? {
+        value = cast_new_IntLiteral_at(p->lineno);
+        cast_IntLiteral_set_format(value, ID2SYM(rb_intern("oct")));
+        cast_IntLiteral_set_val(value, LONG2NUM(strtol(p->tok, (char **)&cp, 8)));
+        if (cp < cursor) {
+            if (cp[0] == '8' || cp[0] == '9')
+                rb_raise(cast_eParseError, "bad octal digit: %c", cp[0]);
+            cast_IntLiteral_set_suffix(value, rb_str_new(cp, cursor - cp));
+        }
+        RETVALUE(cast_sym_ICON);
+    }
+    ( "0" | [1-9] D* ) SUF?  {
+        value = cast_new_IntLiteral_at(p->lineno);
+        cast_IntLiteral_set_format(value, ID2SYM(rb_intern("dec")));
+        cast_IntLiteral_set_val(value, LONG2NUM(strtol(p->tok, (char **)&cp, 10)));
+        if (cp < cursor)
+            cast_IntLiteral_set_suffix(value, rb_str_new(cp, cursor - cp));
+        RETVALUE(cast_sym_ICON);
+    }
+
+    ( D+ E | D* "." D+ E? | D+ "." D* E? ) SUF? {
+        value = cast_new_FloatLiteral_at(p->lineno);
+        cast_FloatLiteral_set_format(value, ID2SYM(rb_intern("dec")));
+        cast_FloatLiteral_set_val(value, rb_float_new(strtod(p->tok, (char **)&cp)));
+        if (cp < cursor)
+            cast_FloatLiteral_set_suffix(value, rb_str_new(cp, cursor - cp));
+        RETVALUE(cast_sym_FCON);
+    }
+    ( "0" [Xx] (H+ P | H* "." H+ P? | H+ "." H* P?) ) SUF? {
+        value = cast_new_FloatLiteral_at(p->lineno);
+        cast_FloatLiteral_set_format(value, ID2SYM(rb_intern("hex")));
+        cast_FloatLiteral_set_val(value, rb_float_new(strtod(p->tok, (char **)&cp)));
+        if (cp < cursor)
+            cast_FloatLiteral_set_suffix(value, rb_str_new(cp, cursor - cp));
+        RETVALUE(cast_sym_FCON);
+    }
+
+    L? ['] (ESC|any\[\n\\'])+ ['] {
+        value = cast_new_CharLiteral_at(p->lineno);
+        if (p->tok[0] == 'L') {
+            cast_CharLiteral_set_wide(value, Qtrue);
+            cp = p->tok + 1;
+        } else {
+            cast_CharLiteral_set_wide(value, Qfalse);
+            cp = p->tok;
+        }
+        cast_CharLiteral_set_val(value, rb_str_new(cp + 1, cursor - cp - 2));
+        RETVALUE(cast_sym_CCON);
+    }
+    L? ["] (ESC|any\[\n\\"])* ["] {
+        value = cast_new_StringLiteral_at(p->lineno);
+        if (p->tok[0] == 'L') {
+            cast_StringLiteral_set_wide(value, Qtrue);
+            cp = p->tok + 1;
+        } else {
+            cast_StringLiteral_set_wide(value, Qfalse);
+            cp = p->tok;
+        }
+        cast_StringLiteral_set_val(value, rb_str_new(cp + 1, cursor - cp - 2));
+        RETVALUE(cast_sym_SCON);
+    }
+
+    "..."       { RET(cast_sym_ELLIPSIS); }
+    ">>="       { RET(cast_sym_RSHIFTEQ); }
+    "<<="       { RET(cast_sym_LSHIFTEQ); }
+    "+="        { RET(cast_sym_ADDEQ); }
+    "-="        { RET(cast_sym_SUBEQ); }
+    "*="        { RET(cast_sym_MULEQ); }
+    "/="        { RET(cast_sym_DIVEQ); }
+    "%="        { RET(cast_sym_MODEQ); }
+    "&="        { RET(cast_sym_ANDEQ); }
+    "^="        { RET(cast_sym_XOREQ); }
+    "|="        { RET(cast_sym_OREQ); }
+    ">>"        { RET(cast_sym_RSHIFT); }
+    "<<"        { RET(cast_sym_LSHIFT); }
+    "++"        { RET(cast_sym_INC); }
+    "--"        { RET(cast_sym_DEC); }
+    "->"        { RET(cast_sym_ARROW); }
+    "&&"        { RET(cast_sym_ANDAND); }
+    "||"        { RET(cast_sym_OROR); }
+    "<="        { RET(cast_sym_LEQ); }
+    ">="        { RET(cast_sym_GEQ); }
+    "=="        { RET(cast_sym_EQEQ); }
+    "!="        { RET(cast_sym_NEQ); }
+    ";"         { RET(cast_sym_SEMICOLON); }
+    "{"         { RET(cast_sym_LBRACE); }
+    "}"         { RET(cast_sym_RBRACE); }
+    ","         { RET(cast_sym_COMMA); }
+    ":"         { RET(cast_sym_COLON); }
+    "="         { RET(cast_sym_EQ); }
+    "("         { RET(cast_sym_LPAREN); }
+    ")"         { RET(cast_sym_RPAREN); }
+    "["         { RET(cast_sym_LBRACKET); }
+    "]"         { RET(cast_sym_RBRACKET); }
+    "."         { RET(cast_sym_DOT); }
+    "&"         { RET(cast_sym_AND); }
+    "!"         { RET(cast_sym_BANG); }
+    "~"         { RET(cast_sym_NOT); }
+    "-"         { RET(cast_sym_SUB); }
+    "+"         { RET(cast_sym_ADD); }
+    "*"         { RET(cast_sym_MUL); }
+    "/"         { RET(cast_sym_DIV); }
+    "%"         { RET(cast_sym_MOD); }
+    "<"         { RET(cast_sym_LT); }
+    ">"         { RET(cast_sym_GT); }
+    "^"         { RET(cast_sym_XOR); }
+    "|"         { RET(cast_sym_OR); }
+    "?"         { RET(cast_sym_QUESTION); }
+
+    "<:"        { RET(cast_sym_LBRACKET); }
+    "<%"        { RET(cast_sym_LBRACE); }
+    ":>"        { RET(cast_sym_RBRACKET); }
+    "%>"        { RET(cast_sym_RBRACE); }
+
+    [ \t\v\f]+  { goto std; }
+
+    [\000]
+        {
+            if(cursor == p->eof) RET(Qnil);
+            goto std;
+        }
+
+    "\n"
+        {
+            p->pos = cursor; ++p->lineno;
+            goto std;
+        }
+
+    any
+        {
+            //printf("unexpected character: %c\n", *p->tok);
+            rb_raise(cast_eParseError, "%d: unexpected character: %c (ASCII %d)\n", p->lineno, *p->tok, (int)*p->tok);
+            goto std;
+        }
+  */
+
+ comment:
+  /*!re2c
+    "*" "/"                    { goto std; }
+    "\n"
+        {
+            p->tok = p->pos = cursor; ++p->lineno;
+            goto comment;
+        }
+
+    [\000]
+        {
+            if (cursor == p->eof)
+              rb_raise(cast_eParseError,
+                       "%d: unclosed multiline comment",
+                       p->lineno);
+        }
+
+    any                        { goto comment; }
+  */
+
+ comment2:
+  /*!re2c
+    "\n"
+        {
+            p->tok = p->pos = cursor; ++p->lineno;
+            goto std;
+        }
+
+    [\000]
+        {
+            if (cursor == p->eof) RET(Qnil);
+            goto std;
+        }
+
+    any                        { goto comment2; }
+  */
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cast19
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -24,6 +24,7 @@ files:
 - ext/cast19/yylex.c
 - ext/cast19/cast.h
 - ext/cast19/extconf.rb
+- ext/cast19/yylex.re
 - lib/cast19/c.tab.rb
 - lib/cast19/c_nodes.rb
 - lib/cast19/inspect.rb