cast 0.0.1

data/lib/parse.rb

@@ -0,0 +1,233 @@
+###
+### ##################################################################
+###
+### C.default_parser and the parse_* methods.
+###
+### Yeah, this could be so much faster.
+###
+### ##################################################################
+###
+
+module C
+  @@default_parser = Parser.new
+  def self.default_parser
+    @@default_parser
+  end
+  def self.default_parser= val
+    @@default_parser = val
+  end
+
+  class Node
+    ###
+    ### Return true if `str' is parsed to something `==' to this Node.
+    ### str is first converted to a String using #to_s, then given to
+    ### self.class.parse (along with the optional `parser').
+    ###
+    def match? str, parser=nil
+      node = self.class.parse(str.to_s, parser) rescue (return false)
+      self == node
+    end
+    ###
+    ### Same as #match?.
+    ###
+    def =~ *args
+      match? *args
+    end
+    private
+  end
+  class NodeList
+    ###
+    ### As defined in Node.
+    ###
+    def match? arr, parser=nil
+      arr = arr.to_a
+      return false if arr.length != self.length
+      each_with_index do |node, i|
+        node.match?(arr[i], parser) or return false
+      end
+      return true
+    end
+  end
+
+  def self.parse s, parser=nil
+    TranslationUnit.parse(s, parser)
+  end
+
+  class TranslationUnit
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      parser.parse(s)
+    end
+  end
+
+  class Declaration
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse(s).entities
+      if ents.length == 1 &&          # int i; int j;
+          ents[0].is_a?(Declaration)  # void f() {}
+        return ents[0].detach
+      else
+        raise ParseError, "invalid Declaration"
+      end
+    end
+  end
+
+  class Parameter
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("void f(#{s}) {}").entities
+      if ents.length == 1              &&  # ) {} void (
+          ents[0].is_a?(FunctionDef)   &&  # ); void(
+          ents[0].type.params          &&  #
+          ents[0].type.params.length <= 1  # x,y
+        param = ents[0].type.params[0]
+        if param.nil?
+          return Parameter.new(Void.new)
+        else
+          return param.detach
+        end
+      else
+        raise ParseError, "invalid Parameter"
+      end
+    end
+  end
+
+  class Declarator
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("int #{s};").entities
+      if ents.length == 1 &&               # f; int f;
+          ents[0].declarators.length == 1  # i,j
+        return ents[0].declarators[0].detach
+      else
+        raise ParseError, "invalid Declarator"
+      end
+    end
+  end
+
+  class FunctionDef
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse(s).entities
+      if ents.length == 1 &&          # void f(); void g();
+          ents[0].is_a?(FunctionDef)  # int i;
+        return ents[0].detach
+      else
+        raise ParseError, "invalid FunctionDef"
+      end
+    end
+  end
+
+  class Enumerator
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("enum {#{s}};").entities
+      if ents.length == 1            &&     # } enum {
+          ents[0].is_a?(Declaration) &&     # } f() {
+          ents[0].type.members.length == 1  # X, Y
+        return ents[0].type.members[0].detach
+      else
+        raise ParseError, "invalid Enumerator"
+      end
+    end
+  end
+
+  class MemberInit
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("int f() {struct s x = {#{s}};}").entities
+      if ents.length == 1                              &&  # } int f() {
+          ents[0].def.stmts.length == 1                &&  # }} f() {{
+          ents[0].def.stmts[0].declarators.length == 1 &&  # 1}, y
+          ents[0].def.stmts[0].declarators[0].init.member_inits.length == 1 # 1, 2
+        return ents[0].def.stmts[0].declarators[0].init.member_inits[0].detach
+      else
+        raise ParseError, "invalid MemberInit"
+      end
+    end
+  end
+
+  class Member
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("int f() {struct s x = {#{s} = 1;};}").entities
+      if ents.length == 1                              &&  # };} int f() {struct s x = {a
+          ents[0].def.stmts.length == 1                &&  # }; x
+          #ents[0].def.stmts[0].length == 1            &&  # 1}, x = {.a
+          ents[0].def.stmts[0].declarators.length == 1 &&  # 1}, x = {.a
+          ents[0].def.stmts[0].declarators[0].init.member_inits.length == 1                  && # x = 1, y
+          ents[0].def.stmts[0].declarators[0].init.member_inits[0].member.length == 1        && # .a .b
+          ents[0].def.stmts[0].declarators[0].init.member_inits[0].member[0].is_a?(C::Member)   # [0]
+        return ents[0].def.stmts[0].declarators[0].init.member_inits[0].member[0].detach
+      else
+        raise ParseError, "invalid Member"
+      end
+    end
+  end
+
+  class Statement
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {#{s}}").entities
+      if ents.length == 1         &&      # } void f() {
+          ents[0].def.stmts.length == 1 &&      # ;;
+          ents[0].def.stmts[0].is_a?(self) # int i;
+        return ents[0].def.stmts[0].detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  class Label
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {switch (0) #{s};}").entities
+      if ents.length == 1                        &&  # } void f() {
+          ents[0].def.stmts.length == 1                &&  # ;
+          ents[0].def.stmts[0].stmt                    &&  #
+          ents[0].def.stmts[0].stmt.labels.length == 1 &&  # x
+          ents[0].def.stmts[0].stmt.labels[0].is_a?(self)
+        return ents[0].def.stmts[0].stmt.labels[0].detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  class Expression
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {#{s};}").entities
+      if ents.length == 1                  &&  # } void f() {
+          ents[0].def.stmts.length == 1          &&  # ;
+          ents[0].def.stmts[0].is_a?(ExpressionStatement) &&  # int i
+          ents[0].def.stmts[0].expr.is_a?(self)
+        return ents[0].def.stmts[0].expr.detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  class Type
+    def self.parse s, parser=nil
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {(#{s})x;}").entities
+      if ents.length == 1                  &&  # 1);} void f() {(int
+          ents[0].def.stmts.length == 1          &&  # 1); (int
+          ents[0].def.stmts[0].expr.type.is_a?(self)
+        return ents[0].def.stmts[0].expr.type.detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  #### Make sure we didn't miss any
+  CORE_C_NODE_CLASSES.each do |c|
+    c.methods.include? 'parse' or
+      raise "#{c}#parse not defined"
+  end
+end

data/lib/to_debug.rb

@@ -0,0 +1,59 @@
+###
+### ##################################################################
+###
+### Node#to_debug.
+###
+### ##################################################################
+###
+
+module C
+  class Node
+    TO_DEBUG_TAB = '    '
+    def to_debug
+      return Node.to_debug1(self)
+    end
+
+    def Node.to_debug1 x, prefix='', indent=0, is_child=true
+      case x
+      when NodeList
+        if x.empty?
+          return "#{TO_DEBUG_TAB*indent}#{prefix}[]\n"
+        else
+          str = "#{TO_DEBUG_TAB*indent}#{prefix}\n"
+          x.each do |el|
+            str << to_debug1(el, "- ", indent+1)
+          end
+          return str
+        end
+      when Node
+        classname = x.class.name.gsub(/^C::/, '')
+        str = "#{TO_DEBUG_TAB*indent}#{prefix}#{classname}"
+
+        fields = x.fields
+        bools, others = fields.partition{|field| field.reader.to_s[-1] == ??}
+        bools.delete_if{|field| !x.send(field.reader)}
+        bools.map!{|field| field.init_key}
+
+        unless bools == []
+          str << " (#{bools.join(' ')})"
+        end
+        str << "\n"
+
+        others.each do |field|
+          val = x.send(field.reader)
+          next if val == field.make_default ||
+            ## don't bother with non-child Nodes, since they may cause
+            ## loops in the tree
+            (val.is_a?(Node) && !field.child?)
+          str << to_debug1(val, "#{field.reader}: ", indent+1, field.child?)
+        end
+        return str
+      when Symbol
+        return "#{TO_DEBUG_TAB*indent}#{prefix}#{x}\n"
+      else
+        return "#{TO_DEBUG_TAB*indent}#{prefix}#{x.inspect}\n"
+      end
+      return s.string
+    end
+  end
+end

data/lib/to_s.rb

@@ -0,0 +1,538 @@
+###
+### ##################################################################
+###
+### The Node#to_s methods.
+###
+### Yeah, this could be so so *SO* much faster.
+###
+### ##################################################################
+###
+
+module C
+  ## undef the #to_s methods so we can check that we didn't forget to
+  ## define any
+  Node.send(:undef_method, :to_s)
+
+  INDENT = '    '
+  class Node
+    private
+    def indent s, levels=1
+      s.gsub(/^/, INDENT*levels)
+    end
+    def hang stmt, cont=false
+      if stmt.is_a? Block
+        return " #{stmt.to_s(:hanging)}" << (cont ? ' ' : '')
+      else
+        return "\n#{stmt.to_s}" << (cont ? "\n" : '')
+      end
+    end
+  end
+
+  class TranslationUnit
+    def to_s
+      entities.map{|n| n.to_s}.join("\n\n")
+    end
+  end
+  class Declaration
+    def to_s
+      str = ''
+      inline? and str << "inline "
+      storage and str << "#{storage} "
+      if declarators.empty?
+        return str << "#{type};"
+      else
+        return str << "#{type} " << declarators.join(', ') << ';'
+      end
+    end
+  end
+  class Declarator
+    def to_s
+      (indirect_type ? indirect_type.to_s(name) : name.dup) <<
+        (init ? " = #{init}" : '') <<
+        (num_bits ? " : #{num_bits}" : '')
+    end
+  end
+  class FunctionDef
+    def to_s
+      str = ''
+      static? and str << 'static '
+      inline? and str << 'inline '
+      if no_prototype?
+        str << "#{type.to_s(name)}\n"
+        type.params.each do |p|
+          str << indent("#{p.to_s};\n")
+        end
+        str << "#{self.def.to_s(:hanging)}"
+      else
+        str << "#{type.to_s(name)}#{hang(self.def)}"
+      end
+    end
+  end
+
+  ### Statements
+  class Statement
+    def label str
+      labels.map{|s| "#{s}:\n"}.join + indent(str)
+    end
+  end
+  class Block
+    def to_s hanging=false
+      str = stmts.map do |s|
+        if s.is_a? Statement
+          s.to_s
+        else
+          indent(s.to_s)
+        end
+      end.join("\n")
+      str << "\n" unless str == ''
+      str = "{\n" << str << "}"
+      if hanging
+        if labels.empty?
+          return str
+        else
+          return "\n" << label(str)
+        end
+      else
+        return label(str)
+      end
+    end
+  end
+  class If
+    def to_s
+      str = "if (#{cond})"
+      if self.else.nil?
+        str << hang(self.then)
+      else
+        str << hang(self.then, :cont) << 'else' << hang(self.else)
+      end
+      return label(str)
+    end
+  end
+  class Switch
+    def to_s
+      label("switch (#{cond})" << hang(stmt))
+    end
+  end
+  class While
+    def to_s
+      if do?
+        label('do' << hang(stmt, :cont) << "while (#{cond});")
+      else
+        label("while (#{cond})" << hang(stmt))
+      end
+    end
+  end
+  class For
+    def to_s
+      initstr =
+        case init
+        when nil
+          ';'
+        when Declaration
+          "#{init}"
+        else
+          "#{init};"
+        end
+      condstr = cond ? " #{cond};" : ';'
+      iterstr = iter ? " #{iter}"  : ''
+      label("for (#{initstr}#{condstr}#{iterstr})" << hang(stmt))
+    end
+  end
+  class Goto
+    def to_s
+      label("goto #{target};")
+    end
+  end
+  class Continue
+    def to_s
+      label("continue;")
+    end
+  end
+  class Break
+    def to_s
+      label("break;")
+    end
+  end
+  class Return
+    def to_s
+      label("return#{expr ? ' '+expr.to_s : ''};")
+    end
+  end
+  class ExpressionStatement
+    def to_s
+      label("#{expr};")
+    end
+  end
+
+  class PlainLabel
+    def to_s
+      name.to_s
+    end
+  end
+  class Default
+    def to_s
+      'default'
+    end
+  end
+  class Case
+    def to_s
+      "case #{expr}"
+    end
+  end
+
+  ### Expressions
+  precedence_table = {}
+  [[Comma],
+    [Assign, MultiplyAssign, DivideAssign, ModAssign, AddAssign,
+      SubtractAssign, ShiftLeftAssign, ShiftRightAssign, BitAndAssign,
+      BitXorAssign, BitOrAssign],
+    [Conditional],
+    [Or],
+    [And],
+    [BitOr],
+    [BitXor],
+    [BitAnd],
+    [Equal, NotEqual],
+    [Less, More, LessOrEqual, MoreOrEqual],
+    [ShiftLeft, ShiftRight],
+    [Add, Subtract],
+    [Multiply, Divide, Mod],
+    [PreInc, PreDec, Sizeof, Cast, Address, Dereference, Positive, Negative,
+      BitNot, Not],
+    [Index, Call, Arrow, Dot, PostInc, PostDec],
+    [Literal, Variable]
+  ].each_with_index do |klasses, prec|
+    klasses.each do |klass|
+      klass.send(:define_method, :to_s_precedence){|| prec}
+    end
+  end
+  ## check all Expression classes have a precedence
+  C::Expression.subclasses_recursive do |c|
+    next if !C::Node.subclasses_recursive.include? c
+    c.instance_methods.include? 'to_s_precedence' or
+      raise "#{c}#to_s_precedence not defined"
+  end
+
+  ## PrefixExpressions
+  [ [Cast       , lambda{"(#{self.type})"}],
+    [Address    , lambda{"&"             }],
+    [Dereference, lambda{"*"             }],
+    [Positive   , lambda{"+"             }],
+    [Negative   , lambda{"-"             }],
+    [PreInc     , lambda{"++"            }],
+    [PreDec     , lambda{"--"            }],
+    [BitNot     , lambda{"~"             }],
+    [Not        , lambda{"!"             }]
+  ].each do |c, proc|
+    c.send(:define_method, :to_s) do | |
+      if expr.to_s_precedence < self.to_s_precedence
+        return "#{instance_eval(&proc)}(#{expr})"
+      else
+        return "#{instance_eval(&proc)}#{expr}"
+      end
+    end
+  end
+  ## PostfixExpressions
+  [ [Arrow      , lambda{"->#{member}"}],
+    [Dot        , lambda{".#{member}" }],
+    [Index      , lambda{"[#{index}]" }],
+    [PostInc    , lambda{"++"         }],
+    [PostDec    , lambda{"--"         }]
+  ].each do |c, proc|
+    c.send(:define_method, :to_s) do | |
+      if expr.to_s_precedence < self.to_s_precedence
+        return "(#{expr})#{instance_eval(&proc)}"
+      else
+        return "#{expr}#{instance_eval(&proc)}"
+      end
+    end
+  end
+  ## BinaryExpressions
+  [ [Add        , '+' ],
+    [Subtract   , '-' ],
+    [Multiply   , '*' ],
+    [Divide     , '/' ],
+    [Mod        , '%' ],
+    [Equal      , '=='],
+    [NotEqual   , '!='],
+    [Less       , '<' ],
+    [More       , '>' ],
+    [LessOrEqual, '<='],
+    [MoreOrEqual, '>='],
+    [BitAnd     , '&' ],
+    [BitOr      , '|' ],
+    [BitXor     , '^' ],
+    [ShiftLeft  , '<<'],
+    [ShiftRight , '>>'],
+    [And        , '&&'],
+    [Or         , '||'],
+  ].each do |c, op|
+    c.send(:define_method, :to_s) do | |
+      if expr1.to_s_precedence < self.to_s_precedence
+        str1 = "(#{expr1})"
+      else
+        str1 = "#{expr1}"
+      end
+      ## all binary expressions are left associative
+      if expr2.to_s_precedence <= self.to_s_precedence
+        str2 = "(#{expr2})"
+      else
+        str2 = "#{expr2}"
+      end
+      "#{str1} #{op} #{str2}"
+    end
+  end
+  ## AssignmentExpressions
+  [ [Assign          , ''  ],
+    [MultiplyAssign  , '*' ],
+    [DivideAssign    , '/' ],
+    [ModAssign       , '%' ],
+    [AddAssign       , '+' ],
+    [SubtractAssign  , '-' ],
+    [ShiftLeftAssign , '<<'],
+    [ShiftRightAssign, '>>'],
+    [BitAndAssign    , '&' ],
+    [BitXorAssign    , '^' ],
+    [BitOrAssign     , '|' ]
+  ].each do |c, op|
+    c.send(:define_method, :to_s) do | |
+      if rval.to_s_precedence < self.to_s_precedence
+        rvalstr = "(#{rval})"
+      else
+        rvalstr = "#{rval}"
+      end
+      "#{lval} #{op}= #{rvalstr}"
+    end
+  end
+  ## Other Expressions
+  class Sizeof
+    def to_s
+      if expr.is_a? Expression
+        if expr.to_s_precedence < self.to_s_precedence
+          return "sizeof(#{expr})"
+        else
+          return "sizeof #{expr}"
+        end
+      else
+        return "sizeof(#{expr})"
+      end
+    end
+  end
+  ## DirectTypes
+  int_longnesses   = ['short ', '', 'long ', 'long long ']
+  float_longnesses = ['float', 'double', 'long double']
+  [ [Struct, lambda do
+        str = 'struct'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join("\n")) << "\n}"
+        str
+      end],
+    [Union, lambda do
+        str = 'union'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join("\n")) << "\n}"
+        str
+      end],
+    [Enum, lambda do
+        str = 'enum'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join(",\n")) << "\n}"
+        str
+      end],
+    [CustomType, lambda{name.dup    }],
+    [Void      , lambda{'void'      }],
+    [Int       , lambda do
+        longness_str = int_longnesses[longness+1].dup
+        "#{unsigned? ? 'unsigned ' : ''}#{longness_str}int"
+      end],
+    [Float     , lambda{float_longnesses[longness].dup}],
+    [Char      , lambda{"#{unsigned? ? 'unsigned ' : ''}char"}],
+    [Bool      , lambda{'_Bool'     }],
+    [Complex   , lambda{'_Complex'  }],
+    [Imaginary , lambda{'_Imaginary'}]
+  ].each do |c, x|
+    c.send(:define_method, :to_s) do |*args|
+      case args.length
+      when 0
+        namestr = nil
+      when 1
+        namestr = args[0]
+        namestr = nil if namestr == ''
+      else
+        raise ArgumentError, "wrong number of args (#{args.length} for 1)"
+      end
+      str = ''
+      const?    and str << 'const '
+      restrict? and str << 'restrict '
+      volatile? and str << 'volatile '
+      str << instance_eval(&x) << (namestr ? " #{namestr}" : '')
+    end
+  end
+
+  class Enumerator
+    def to_s
+      if val
+        "#{name} = #{val}"
+      else
+        "#{name}"
+      end
+    end
+  end
+
+  class Comma
+    def to_s
+      exprs.join(', ')
+    end
+  end
+
+  class Conditional
+    def to_s
+      strs = [:cond, :then, :else].map do |child|
+        val = send(child)
+        if val.to_s_precedence < self.to_s_precedence
+          "(#{val})"
+        else
+          "#{val}"
+        end
+      end
+      "#{strs[0]} ? #{strs[1]} : #{strs[2]}"
+    end
+  end
+
+  class Call
+    def to_s
+      argstrs = args.map do |arg|
+        if arg.is_a? Comma
+          "(#{arg})"
+        else
+          "#{arg}"
+        end
+      end
+      if expr.to_s_precedence < self.to_s_precedence
+        exprstr = "(#{expr})"
+      else
+        exprstr = "#{expr}"
+      end
+      "#{exprstr}(#{argstrs.join(', ')})"
+    end
+  end
+
+  ### IndirectTypes
+  class Pointer
+    def to_s name=nil
+      str = '*'
+      const?    and str << 'const '
+      restrict? and str << 'restrict '
+      volatile? and str << 'volatile '
+      str =
+        case type
+        when Function, Array
+          "(#{str}#{name})"
+        else
+          "#{str}#{name}"
+        end
+      if type
+        type.to_s(str)
+      else
+        str
+      end
+    end
+  end
+  class Array
+    def to_s name=nil
+      str = "#{name}[#{length}]"
+      if type
+        type.to_s(str)
+      else
+        str
+      end
+    end
+  end
+  class Function
+    def to_s name=nil
+      str =
+        if params.nil?
+          paramstr = ''
+        elsif params.empty?
+          paramstr = 'void'
+        else
+          paramstr = params.join(', ')
+        end
+      var_args? and paramstr << ', ...'
+      str = "#{name}(#{paramstr})"
+      if type
+        type.to_s(str)
+      else
+        str
+      end
+    end
+  end
+  class Parameter
+    def to_s
+      str = register? ? 'register ' : ''
+      str << type.to_s(name)
+    end
+  end
+
+  ### Literals
+  class StringLiteral
+    def to_s
+      "\"#{val}\""
+    end
+  end
+  class CharLiteral
+    def to_s
+      "'#{val}'"
+    end
+  end
+  class CompoundLiteral
+    def to_s
+      str = ''
+      type and
+        str << "(#{type}) "
+      str << "{\n" << indent(inits.join(",\n")) << "\n}"
+    end
+  end
+  class MemberInit
+    def to_s
+      str = ''
+      if member
+        memberstr = member.map do |m|
+          if m.is_a? Expression
+            "[#{m}]"
+          else
+            ".#{m}"
+          end
+        end
+        str << member.join(' ') << ' = '
+      end
+      return str << init.to_s
+    end
+  end
+  class Member
+    def to_s
+      name.dup
+    end
+  end
+  class IntLiteral
+    def to_s
+      val.to_s
+    end
+  end
+  class FloatLiteral
+    def to_s
+      val.to_s
+    end
+  end
+  class Variable
+    def to_s
+      name.dup
+    end
+  end
+
+  ## check we didn't miss any
+  CORE_C_NODE_CLASSES.each do |c|
+    c.method_defined? :to_s or
+      raise "#{c}#to_s not defined"
+  end
+end