casty 0.3.1

data/lib/casty/version.rb

@@ -0,0 +1,11 @@
+module C
+  VERSION = [0, 3, 1]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
+end

data/test/all.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+Dir["#{ROOT}/test/**/*_test.rb"].each do |path|
+  require path
+end

data/test/c_nodes_test.rb

@@ -0,0 +1,224 @@
+######################################################################
+#
+# Tests for miscellaneous methods specific to individual Node classes.
+#
+######################################################################
+
+require 'test_helper'
+
+class MiscTests < Test::Unit::TestCase
+
+  # ------------------------------------------------------------------
+  #                    Declarator#declaration type
+  # ------------------------------------------------------------------
+
+  def test_declarator_declaration
+    tor = C::Declarator.new(nil, 'x')
+    assert_nil(tor.declaration)
+
+    list = C::NodeArray[tor]
+    assert_nil(tor.declaration)
+
+    tion = C::Declaration.new(C::Int.new, list)
+    assert_same(tion, tor.declaration)
+
+    list.detach
+    assert_nil(tor.declaration)
+  end
+
+  def test_declarator_type
+    # int i, *j, k[], l(), *m[10];
+    decl = C::Declaration.new(C::Int.new)
+    decl.declarators << C::Declarator.new(nil, 'i')
+    decl.declarators << C::Declarator.new(C::Pointer.new, 'j')
+    decl.declarators << C::Declarator.new(C::Array.new, 'k')
+    decl.declarators << C::Declarator.new(C::Function.new, 'l')
+    arr = C::Array.new(C::Pointer.new, C::IntLiteral.new(10))
+    decl.declarators << C::Declarator.new(arr, 'm')
+
+    assert_equal_inspect_strs(decl.declarators[0].type.inspect, <<EOS)
+Int
+EOS
+    assert_equal_inspect_strs(decl.declarators[1].type.inspect, <<EOS)
+Pointer
+    type: Int
+EOS
+    assert_equal_inspect_strs(decl.declarators[2].type.inspect, <<EOS)
+Array
+    type: Int
+EOS
+    assert_equal_inspect_strs(decl.declarators[3].type.inspect, <<EOS)
+Function
+    type: Int
+EOS
+    assert_equal_inspect_strs(decl.declarators[4].type.inspect, <<EOS)
+Array
+    type: Pointer
+        type: Int
+    length: IntLiteral
+        val: 10
+EOS
+  end
+
+  # ------------------------------------------------------------------
+  #                            FunctionDef
+  # ------------------------------------------------------------------
+
+  def test_function_def_initialize
+    fd = C::FunctionDef.new
+    assert fd.def.Block?
+    assert fd.def.stmts.empty?
+  end
+
+  # ------------------------------------------------------------------
+  #                          BlockExpression
+  # ------------------------------------------------------------------
+
+  def test_function_def_initialize
+    expr = C::BlockExpression.new
+    assert expr.block.Block?
+    assert expr.block.stmts.empty?
+  end
+
+  # ------------------------------------------------------------------
+  #                      DirectType, IndirectType
+  # ------------------------------------------------------------------
+
+  def test_type_direct_type
+    d = C::Int.new
+    t = C::Pointer.new(d)
+    assert_same(d, t.direct_type)
+
+    d = C::Float.new
+    t = C::Pointer.new(C::Pointer.new(d))
+    assert_same(d, t.direct_type)
+
+    d = C::Struct.new('S')
+    t = C::Array.new(d)
+    assert_same(d, t.direct_type)
+
+    d = C::CustomType.new('T')
+    t = C::Function.new(d)
+    assert_same(d, t.direct_type)
+
+    t = C::Pointer.new(nil)
+    assert_nil(t.direct_type)
+
+    t = C::Int.new
+    assert_same(t, t.direct_type)
+  end
+
+  def test_type_indirect_type
+    d = C::Int.new
+    t = C::Pointer.new(d)
+    assert_equal(C::Pointer.new, t.indirect_type)
+
+    d = C::Float.new
+    t = C::Pointer.new(C::Pointer.new(d))
+    assert_equal(C::Pointer.new(C::Pointer.new), t.indirect_type)
+
+    d = C::Struct.new('S')
+    t = C::Array.new(d, C::IntLiteral.new(10))
+    assert_equal(C::Array.new(nil, C::IntLiteral.new(10)), t.indirect_type)
+
+    d = C::CustomType.new('T')
+    t = C::Function.new(d)
+    assert_equal(C::Function.new, t.indirect_type)
+
+    t = C::Pointer.new(nil)
+    assert_copy(t, t.indirect_type)
+
+    t = C::Int.new
+    assert_nil(t.indirect_type)
+  end
+
+  def test_type_set_direct_type
+    d = C::Int.new
+    t = C::Pointer.new(d)
+    x = C::Int.new
+    t.direct_type = x
+    assert_same(x, t.type)
+
+    d = C::Float.new
+    t = C::Pointer.new(C::Pointer.new(d))
+    x = C::Float.new
+    t.direct_type = x
+    assert_same(x, t.type.type)
+
+    d = C::Struct.new('S')
+    t = C::Array.new(d)
+    x = C::Struct.new('T')
+    t.direct_type = x
+    assert_same(x, t.type)
+
+    d = C::CustomType.new('T')
+    t = C::Function.new(d)
+    x = C::Void.new
+    t.direct_type = x
+    assert_same(x, t.type)
+
+    t = C::Pointer.new(nil)
+    x = C::Imaginary.new
+    t.direct_type = x
+    assert_same(x, t.type)
+
+    t = C::Int.new
+    x = C::Void.new
+    assert_raise(NoMethodError){t.direct_type = x}
+  end
+
+  # ------------------------------------------------------------------
+  #                     CharLiteral StringLiteral
+  # ------------------------------------------------------------------
+
+  def test_char_literal_wide
+    c = C::CharLiteral.new('abc', 'L')
+    assert(c.wide?)
+    assert_equal('L', c.prefix)
+
+    c.prefix = nil
+    assert(!c.wide?)
+    assert_nil(c.prefix)
+
+    c.prefix = 'x'
+    assert(!c.wide?)
+    assert_equal('x', c.prefix)
+
+    c.wide = false
+    assert(!c.wide?)
+    assert_equal('x', c.prefix)
+
+    c.wide = true
+    assert(c.wide?)
+    assert_equal('L', c.prefix)
+
+    c.wide = false
+    assert(!c.wide?)
+    assert_equal(nil, c.prefix)
+  end
+  def test_string_literal_wide
+    s = C::StringLiteral.new('abc', 'L')
+    assert(s.wide?)
+    assert_equal('L', s.prefix)
+
+    s.prefix = nil
+    assert(!s.wide?)
+    assert_nil(s.prefix)
+
+    s.prefix = 'x'
+    assert(!s.wide?)
+    assert_equal('x', s.prefix)
+
+    s.wide = false
+    assert(!s.wide?)
+    assert_equal('x', s.prefix)
+
+    s.wide = true
+    assert(s.wide?)
+    assert_equal('L', s.prefix)
+
+    s.wide = false
+    assert(!s.wide?)
+    assert_equal(nil, s.prefix)
+  end
+end

data/test/lexer_test.rb

@@ -0,0 +1,355 @@
+######################################################################
+#
+# Lexer routine tests.  We only test nontrivial tokens, as things like
+# operators are exercised sufficiently in the parser tests
+# (test_parser.rb).
+#
+######################################################################
+
+require 'test_helper'
+
+class LexerTest < Test::Unit::TestCase
+  def check(s)
+    check_ast(s){|inp| C::Parser.new.parse(inp)}
+  end
+
+  def test_id_and_typename
+    check <<EOS
+typedef int Mytype;
+void f() {
+  mytype * a;
+  Mytype * a;
+  _1234, _a1234, _1234L;
+}
+----
+TranslationUnit
+    entities:
+        - Declaration
+            storage: typedef
+            type: Int
+            declarators:
+                - Declarator
+                    name: "Mytype"
+        - FunctionDef
+            type: Function
+                type: Void
+            name: "f"
+            def: Block
+                stmts:
+                    - ExpressionStatement
+                        expr: Multiply
+                            expr1: Variable
+                                name: "mytype"
+                            expr2: Variable
+                                name: "a"
+                    - Declaration
+                        type: CustomType
+                            name: "Mytype"
+                        declarators:
+                            - Declarator
+                                indirect_type: Pointer
+                                name: "a"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - Variable
+                                    name: "_1234"
+                                - Variable
+                                    name: "_a1234"
+                                - Variable
+                                    name: "_1234L"
+EOS
+  end
+  def test_int_literal
+    check <<EOS
+void f() {
+  0, 00, 000, 0x0, 0x00;
+  1234, 1234l, 1234ll;
+  01234u, 01234ul, 01234ull;
+  0x1234U, 0x1234L, 0x1234ULL;
+}
+----
+TranslationUnit
+    entities:
+        - FunctionDef
+            type: Function
+                type: Void
+            name: "f"
+            def: Block
+                stmts:
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - IntLiteral
+                                    val: 0
+                                - IntLiteral
+                                    format: oct
+                                    val: 0
+                                - IntLiteral
+                                    format: oct
+                                    val: 0
+                                - IntLiteral
+                                    format: hex
+                                    val: 0
+                                - IntLiteral
+                                    format: hex
+                                    val: 0
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - IntLiteral
+                                    val: 1234
+                                - IntLiteral
+                                    val: 1234
+                                    suffix: "l"
+                                - IntLiteral
+                                    val: 1234
+                                    suffix: "ll"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - IntLiteral
+                                    format: oct
+                                    val: 668
+                                    suffix: "u"
+                                - IntLiteral
+                                    format: oct
+                                    val: 668
+                                    suffix: "ul"
+                                - IntLiteral
+                                    format: oct
+                                    val: 668
+                                    suffix: "ull"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - IntLiteral
+                                    format: hex
+                                    val: 4660
+                                    suffix: "U"
+                                - IntLiteral
+                                    format: hex
+                                    val: 4660
+                                    suffix: "L"
+                                - IntLiteral
+                                    format: hex
+                                    val: 4660
+                                    suffix: "ULL"
+EOS
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12lll;}')}
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12ulL;}')}
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {12lul;}')}
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {123_4;}')}
+  end
+  def test_float_literal
+    check <<EOS
+void f() {
+  123e4, 123E-4;
+  123.4e10, .123E-4;
+  123.4e5, 123.E-10;
+
+  0xabp2, 0xabcP-10;
+  0xabc.dp3, 0xabcP-11;
+  0xabc.dp4, 0xabc.P-12;
+}
+----
+TranslationUnit
+    entities:
+        - FunctionDef
+            type: Function
+                type: Void
+            name: "f"
+            def: Block
+                stmts:
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    val: 1230000.0
+                                - FloatLiteral
+                                    val: 0.0123
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    val: 1234000000000.0
+                                - FloatLiteral
+                                    val: 1.23e-05
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    val: 12340000.0
+                                - FloatLiteral
+                                    val: 1.23e-08
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    format: hex
+                                    val: 684.0
+                                - FloatLiteral
+                                    format: hex
+                                    val: 2.68359375
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    format: hex
+                                    val: 21990.5
+                                - FloatLiteral
+                                    format: hex
+                                    val: 1.341796875
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - FloatLiteral
+                                    format: hex
+                                    val: 43981.0
+                                - FloatLiteral
+                                    format: hex
+                                    val: 0.6708984375
+EOS
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {0x123.4pa;}')}
+  end
+  def test_string_literal
+    check <<EOS
+void f() {
+  "ab", L"ab", x"ab";
+  "a\\0b", L"a\\x0fb", "a\\vb";
+  "a	b", L"a	b";
+  "a
+b", L"a
+b";
+}
+----
+TranslationUnit
+    entities:
+        - FunctionDef
+            type: Function
+                type: Void
+            name: "f"
+            def: Block
+                stmts:
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - StringLiteral
+                                    val: "ab"
+                                - StringLiteral
+                                    prefix: "L"
+                                    val: "ab"
+                                - StringLiteral
+                                    prefix: "x"
+                                    val: "ab"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - StringLiteral
+                                    val: "a\\\\0b"
+                                - StringLiteral
+                                    prefix: "L"
+                                    val: "a\\\\x0fb"
+                                - StringLiteral
+                                    val: "a\\\\vb"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - StringLiteral
+                                    val: "a\\tb"
+                                - StringLiteral
+                                    prefix: "L"
+                                    val: "a\\tb"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - StringLiteral
+                                    val: "a\\nb"
+                                - StringLiteral
+                                    prefix: "L"
+                                    val: "a\\nb"
+EOS
+    assert_raise(C::ParseError){C::Parser.new.parse('void f() {xy"ab";}')}
+  end
+  def test_char_literal
+    check <<EOS
+void f() {
+  'a', L'a', x'a';
+  '\\0', L'\\xf', '\\v';
+  '	', L'
+';
+}
+----
+TranslationUnit
+    entities:
+        - FunctionDef
+            type: Function
+                type: Void
+            name: "f"
+            def: Block
+                stmts:
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - CharLiteral
+                                    val: "a"
+                                - CharLiteral
+                                    prefix: "L"
+                                    val: "a"
+                                - CharLiteral
+                                    prefix: "x"
+                                    val: "a"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - CharLiteral
+                                    val: "\\\\0"
+                                - CharLiteral
+                                    prefix: "L"
+                                    val: "\\\\xf"
+                                - CharLiteral
+                                    val: "\\\\v"
+                    - ExpressionStatement
+                        expr: Comma
+                            exprs:
+                                - CharLiteral
+                                    val: "\\t"
+                                - CharLiteral
+                                    prefix: "L"
+                                    val: "\\n"
+EOS
+    assert_raise(C::ParseError){C::Parser.new.parse("void f() {xy'ab';}")}
+  end
+
+  def test_directive_at_file_start
+    check <<EOS
+# 12 gcc stuff
+int a;
+----
+TranslationUnit
+    entities:
+        - Declaration
+            type: Int
+            declarators:
+                - Declarator
+                    name: "a"
+EOS
+  end
+
+  def test_directive
+    check <<EOS
+int a;
+# 12 gcc stuff
+----
+TranslationUnit
+    entities:
+        - Declaration
+            type: Int
+            declarators:
+                - Declarator
+                    name: "a"
+EOS
+    assert_raise(C::ParseError){C::Parser.new.parse("#define a b\nint a;")}
+  end
+
+end