casty 0.3.1

data/lib/casty/parse.rb

@@ -0,0 +1,254 @@
+######################################################################
+#
+# 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
+      # if there's a ':', declare in a struct so we can populate num_bits
+      if s =~ /:/
+        ents = parser.parse("struct {int #{s};};").entities
+        if ents.length == 1 &&                              # i:1;}; struct {int i
+            ents[0].type.members.length == 1 &&             # i:1; int j
+            ents[0].type.members[0].declarators.length == 1 # i:1,j
+          return ents[0].type.members[0].declarators[0].detach
+        end
+      else
+        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
+        end
+      end
+      raise ParseError, "invalid Declarator"
+    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                              &&  # a = 1};} int f() {struct s x = {a
+          ents[0].def.stmts.length == 1                &&  # a = 1}; struct s y = {.a
+          #ents[0].def.stmts[0].length == 1            &&  # a = 1}, x = {.a
+          ents[0].def.stmts[0].declarators.length == 1 &&  # a = 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   &&        # 1
+          ents[0].def.stmts[0].declarators[0].init.member_inits[0].member.length == 1 # a .b
+        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
+      if s =~ /\A(\s*(\/\*.*?\*\/)?)*\{/
+        # starts with a brace -- must be a CompoundLiteral.  in this
+        # case, use a Declarator since only those can handle typeless
+        # CompoundLiterals.
+        ents = parser.parse("int i = #{s};").entities
+        if ents.length == 1                 &&  # 1; int i = 1
+            ents[0].declarators.length == 1 &&  # 1, j = 2
+            ents[0].declarators[0].init.is_a?(self)
+          return ents[0].declarators[0].init.detach
+        else
+          raise ParseError, "invalid #{self}"
+        end
+      else
+        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
+  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.respond_to? :parse or
+      raise "#{c}.parse not defined"
+  end
+end

data/lib/casty/preprocessor.rb

@@ -0,0 +1,92 @@
+require 'rbconfig'
+
+######################################################################
+#
+# A C preprocessor that wraps the command in Config::CONFIG['CPP'].
+#
+# Assumes a POSIX-style cpp command line interface, in particular, -I
+# and -D options.
+#
+######################################################################
+
+module C
+  class Preprocessor
+    class Error < StandardError
+    end
+
+    class << self
+      attr_accessor :command
+    end
+    self.command = (defined?(RbConfig) ? RbConfig : Config)::CONFIG['CPP']
+
+    attr_accessor :pwd, :include_path, :macros, :undef_macros
+
+    def initialize
+      @include_path = []
+      @macros = {}
+      @undef_macros = Set.new
+    end
+    def preprocess(text)
+      filename = nil
+      temp_file = nil
+      Tempfile.open(['cast-preprocessor-input.', '.c'], File.expand_path(pwd || '.')) do |file|
+        temp_file = file
+        filename = file.path
+        file.puts text
+      end
+      return preprocess_file(filename);
+    ensure
+      if temp_file
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+    def preprocess_file(file_name, options={})
+      file_name = File.expand_path(file_name)
+      dir = File.dirname(file_name)
+      stderr_buf = Tempfile.new('cast-preprocessor-stderr.txt')
+      FileUtils.cd(dir) do
+        output = `#{full_command(file_name)} 2>#{shellquote(stderr_buf.path)}`
+        if $? == 0 || options[:force] && !output.empty?
+          return output
+        else
+          raise Error, stderr_buf.read
+        end
+      end
+    ensure
+      stderr_buf.close
+      stderr_buf.unlink
+    end
+
+    private  # -------------------------------------------------------
+
+    def shellquote(arg)
+      if arg !~ /[\"\'\\$&<>\(\)|\s]/
+        return arg
+      elsif arg !~ /\'/
+        return "'#{arg}'"
+      else
+        arg.gsub!(/([\"\\$&<>|])/, '\\\\\\1')
+        return "\"#{arg}\""
+      end
+    end
+    def full_command(filename)
+      include_args = include_path.map do |path|
+        "#{shellquote('-I'+path)}"
+      end.join(' ')
+      macro_args   = (undef_macros.map{|m| shellquote "-U#{m}"} +
+        macros.map do |key, val|
+          case key
+          when :@imacros
+            "-imacros" + shellquote(File.expand_path(val))
+          when :@include
+            "-include" + shellquote(File.expand_path(val))
+          else
+            shellquote("-D#{key}#{"=#{val}" if val}")
+          end
+        end).join(' ')
+      filename = shellquote(filename)
+      "#{Preprocessor.command} #{include_args} #{macro_args} #{filename}"
+    end
+  end
+end

data/lib/casty/tempfile.rb

@@ -0,0 +1,33 @@
+######################################################################
+#
+# Alternative to the standard ruby tempfile library, which lets you
+# specify a filename suffix.
+#
+######################################################################
+
+require 'delegate'
+require 'tmpdir'
+require 'tempfile'
+
+#
+# Setting the extension of a temp file has only been possible since
+# Ruby 1.8.7.
+#
+module C
+  if RUBY_VERSION >= '1.8.7'
+    Tempfile = ::Tempfile
+  else
+    class Tempfile < ::Tempfile
+      def initialize(basename, tmpdir=Dir::tmpdir)
+        if basename.is_a?(::Array)
+          basename, @suffix = *basename
+        end
+        super(basename, tmpdir)
+      end
+
+      def make_tmpname(basename, n)
+        sprintf('%s%d.%d%s', basename, $$, n, @suffix)
+      end
+    end
+  end
+end

data/lib/casty/to_s.rb

@@ -0,0 +1,555 @@
+######################################################################
+#
+# 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) && stmt.labels.empty?
+        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, true)}\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}:"
+    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       , proc{"(#{self.type})"}, false],
+    [Address    , proc{"&"             }, true ],
+    [Dereference, proc{"*"             }, false],
+    [Positive   , proc{"+"             }, true ],
+    [Negative   , proc{"-"             }, true ],
+    [PreInc     , proc{"++"            }, false],
+    [PreDec     , proc{"--"            }, false],
+    [BitNot     , proc{"~"             }, false],
+    [Not        , proc{"!"             }, false]
+  ].each do |c, proc, space_needed|
+    c.send(:define_method, :to_s) do | |
+      if expr.to_s_precedence < self.to_s_precedence
+        return "#{instance_eval(&proc)}(#{expr})"
+      elsif space_needed && expr.class == self.class
+        return "#{instance_eval(&proc)} #{expr}"
+      else
+        return "#{instance_eval(&proc)}#{expr}"
+      end
+    end
+  end
+  # PostfixExpressions
+  [ [Arrow      , proc{"->#{member}"}],
+    [Dot        , proc{".#{member}" }],
+    [Index      , proc{"[#{index}]" }],
+    [PostInc    , proc{"++"         }],
+    [PostDec    , proc{"--"         }]
+  ].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
+      if lval.to_s_precedence < self.to_s_precedence
+        lvalstr = "(#{lval})"
+      else
+        lvalstr = "#{lval}"
+      end
+      "#{lvalstr} #{op}= #{rvalstr}"
+    end
+  end
+  # Other Expressions
+  class Sizeof
+    def to_s
+      "sizeof(#{expr})"
+    end
+  end
+  # DirectTypes
+  int_longnesses   = ['short ', '', 'long ', 'long long ']
+  float_longnesses = ['float', 'double', 'long double']
+  [ [Struct, proc do
+        str = 'struct'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join("\n")) << "\n}"
+        str
+      end],
+    [Union, proc do
+        str = 'union'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join("\n")) << "\n}"
+        str
+      end],
+    [Enum, proc do
+        str = 'enum'
+        name    and str << " #{name}"
+        members and str << " {\n" << indent(members.join(",\n")) << "\n}"
+        str
+      end],
+    [CustomType, proc{name.dup    }],
+    [Void      , proc{'void'      }],
+    [Int       , proc do
+        longness_str = int_longnesses[longness+1].dup
+        "#{unsigned? ? 'unsigned ' : ''}#{longness_str}int"
+      end],
+    [Float     , proc{float_longnesses[longness].dup}],
+    [Char      , proc{"#{unsigned? ? 'unsigned ' : signed? ? 'signed ' : ''}char"}],
+    [Bool      , proc{"_Bool"     }],
+    [Complex   , proc{"_Complex #{float_longnesses[longness]}"}],
+    [Imaginary , proc{"_Imaginary #{float_longnesses[longness]}"}]
+  ].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, no_types=false)
+      str =
+        if params.nil?
+          paramstr = ''
+        elsif params.empty?
+          paramstr = 'void'
+        else
+          if no_types
+            paramstr = params.map{|p| p.name}.join(', ')
+          else
+            paramstr = params.join(', ')
+          end
+        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 ' : ''
+      if type
+        str << type.to_s(name)
+      else
+        str << name.to_s
+      end
+    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(member_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 << memberstr.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
+  class BlockExpression
+    def to_s
+      # note that the grammar does not allow the block to have a label
+      "(#{block.to_s(:hanging)})"
+    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