cast 0.0.1 → 0.3.1

data/lib/{parse.rb → cast/parse.rb}

@@ -1,45 +1,43 @@
-###
-### ##################################################################
-###
-### C.default_parser and the parse_* methods.
-###
-### Yeah, this could be so much faster.
-###
-### ##################################################################
-###
+######################################################################
+#
+# 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
+  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
+    #
+    # 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
+    #
+    # Same as #match?.
+    #
+    def =~(*args)
+      match?(*args)
     end
     private
   end
   class NodeList
-    ###
-    ### As defined in Node.
-    ###
-    def match? arr, parser=nil
+    #
+    # 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|
@@ -49,19 +47,19 @@ module C
     end
   end
 
-  def self.parse s, parser=nil
+  def self.parse(s, parser=nil)
     TranslationUnit.parse(s, parser)
   end
 
   class TranslationUnit
-    def self.parse s, parser=nil
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       parser.parse(s)
     end
   end
 
   class Declaration
-    def self.parse s, parser=nil
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       ents = parser.parse(s).entities
       if ents.length == 1 &&          # int i; int j;
@@ -74,7 +72,7 @@ module C
   end
 
   class Parameter
-    def self.parse s, parser=nil
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       ents = parser.parse("void f(#{s}) {}").entities
       if ents.length == 1              &&  # ) {} void (
@@ -94,20 +92,29 @@ module C
   end
 
   class Declarator
-    def self.parse s, parser=nil
+    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
+      # 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
-        raise ParseError, "invalid Declarator"
+        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
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       ents = parser.parse(s).entities
       if ents.length == 1 &&          # void f(); void g();
@@ -120,7 +127,7 @@ module C
   end
 
   class Enumerator
-    def self.parse s, parser=nil
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       ents = parser.parse("enum {#{s}};").entities
       if ents.length == 1            &&     # } enum {
@@ -134,7 +141,7 @@ module C
   end
 
   class MemberInit
-    def self.parse s, parser=nil
+    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() {
@@ -149,16 +156,16 @@ module C
   end
 
   class Member
-    def self.parse s, parser=nil
+    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]
+      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"
@@ -167,12 +174,12 @@ module C
   end
 
   class Statement
-    def self.parse s, parser=nil
+    def self.parse(s, parser=nil)
       parser ||= C.default_parser
       ents = parser.parse("void f() {#{s}}").entities
-      if ents.length == 1         &&      # } void f() {
+      if ents.length == 1               &&      # } void f() {
           ents[0].def.stmts.length == 1 &&      # ;;
-          ents[0].def.stmts[0].is_a?(self) # int i;
+          ents[0].def.stmts[0].is_a?(self)      # int i;
         return ents[0].def.stmts[0].detach
       else
         raise ParseError, "invalid #{self}"
@@ -181,10 +188,10 @@ module C
   end
 
   class Label
-    def self.parse s, parser=nil
+    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() {
+      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
@@ -197,25 +204,39 @@ module C
   end
 
   class Expression
-    def self.parse s, parser=nil
+    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
+      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
-        raise ParseError, "invalid #{self}"
+        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
+    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
+      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
@@ -225,9 +246,9 @@ module C
     end
   end
 
-  #### Make sure we didn't miss any
+  # Make sure we didn't miss any
   CORE_C_NODE_CLASSES.each do |c|
-    c.methods.include? 'parse' or
-      raise "#{c}#parse not defined"
+    c.respond_to? :parse or
+      raise "#{c}.parse not defined"
   end
 end

data/lib/cast/preprocessor.rb

@@ -0,0 +1,59 @@
+require 'rbconfig'
+require 'shellwords'
+
+######################################################################
+#
+# 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
+
+    def initialize(quiet: false)
+      @include_path = []
+      @macros = {}
+      @quiet = quiet
+    end
+    def preprocess(text)
+      filename = nil
+      Tempfile.open(['cast-preprocessor-input.', '.c'], File.expand_path(pwd || '.')) do |file|
+        filename = file.path
+        file.puts text
+      end
+      output = `#{full_command(filename)} #{'2> /dev/null' if @quiet}`
+      if $? == 0
+        return output
+      else
+        raise Error, output
+      end
+    end
+    def preprocess_file(file_name)
+      file_name = File.expand_path(file_name)
+      dir = File.dirname(file_name)
+      FileUtils.cd(dir) do
+        return preprocess(File.read(file_name))
+      end
+    end
+
+    private  # -------------------------------------------------------
+
+    def full_command(filename)
+      include_args = include_path.map { |path| "-I#{path}" }
+      macro_args = macros.sort.map { |key, val| "-D#{key}" + (val ? "=#{val}" : '') }
+      [*Preprocessor.command.shellsplit, *include_args, *macro_args, filename].shelljoin
+    end
+  end
+end

data/lib/cast/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/{to_s.rb → cast/to_s.rb}

@@ -1,26 +1,24 @@
-###
-### ##################################################################
-###
-### The Node#to_s methods.
-###
-### Yeah, this could be so so *SO* much faster.
-###
-### ##################################################################
-###
+######################################################################
+#
+# 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
+  # 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
+    def indent(s, levels=1)
       s.gsub(/^/, INDENT*levels)
     end
-    def hang stmt, cont=false
-      if stmt.is_a? Block
+    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" : '')
@@ -58,7 +56,7 @@ module C
       static? and str << 'static '
       inline? and str << 'inline '
       if no_prototype?
-        str << "#{type.to_s(name)}\n"
+        str << "#{type.to_s(name, true)}\n"
         type.params.each do |p|
           str << indent("#{p.to_s};\n")
         end
@@ -69,14 +67,17 @@ module C
     end
   end
 
-  ### Statements
+  # ------------------------------------------------------------------
+  #                             Statements
+  # ------------------------------------------------------------------
+
   class Statement
-    def label str
-      labels.map{|s| "#{s}:\n"}.join + indent(str)
+    def label(str)
+      labels.map{|s| "#{s}\n"}.join + indent(str)
     end
   end
   class Block
-    def to_s hanging=false
+    def to_s(hanging=false)
       str = stmts.map do |s|
         if s.is_a? Statement
           s.to_s
@@ -166,21 +167,24 @@ module C
 
   class PlainLabel
     def to_s
-      name.to_s
+      "#{name}:"
     end
   end
   class Default
     def to_s
-      'default'
+      'default:'
     end
   end
   class Case
     def to_s
-      "case #{expr}"
+      "case #{expr}:"
     end
   end
 
-  ### Expressions
+  # ------------------------------------------------------------------
+  #                            Expressions
+  # ------------------------------------------------------------------
+
   precedence_table = {}
   [[Comma],
     [Assign, MultiplyAssign, DivideAssign, ModAssign, AddAssign,
@@ -206,38 +210,40 @@ module C
       klass.send(:define_method, :to_s_precedence){|| prec}
     end
   end
-  ## check all Expression classes have a precedence
+  # 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|
+  # 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      , lambda{"->#{member}"}],
-    [Dot        , lambda{".#{member}" }],
-    [Index      , lambda{"[#{index}]" }],
-    [PostInc    , lambda{"++"         }],
-    [PostDec    , lambda{"--"         }]
+  # 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
@@ -247,7 +253,7 @@ module C
       end
     end
   end
-  ## BinaryExpressions
+  # BinaryExpressions
   [ [Add        , '+' ],
     [Subtract   , '-' ],
     [Multiply   , '*' ],
@@ -273,7 +279,7 @@ module C
       else
         str1 = "#{expr1}"
       end
-      ## all binary expressions are left associative
+      # all binary expressions are left associative
       if expr2.to_s_precedence <= self.to_s_precedence
         str2 = "(#{expr2})"
       else
@@ -282,7 +288,7 @@ module C
       "#{str1} #{op} #{str2}"
     end
   end
-  ## AssignmentExpressions
+  # AssignmentExpressions
   [ [Assign          , ''  ],
     [MultiplyAssign  , '*' ],
     [DivideAssign    , '/' ],
@@ -301,55 +307,52 @@ module C
       else
         rvalstr = "#{rval}"
       end
-      "#{lval} #{op}= #{rvalstr}"
+      if lval.to_s_precedence < self.to_s_precedence
+        lvalstr = "(#{lval})"
+      else
+        lvalstr = "#{lval}"
+      end
+      "#{lvalstr} #{op}= #{rvalstr}"
     end
   end
-  ## Other Expressions
+  # 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
+      "sizeof(#{expr})"
     end
   end
-  ## DirectTypes
+  # DirectTypes
   int_longnesses   = ['short ', '', 'long ', 'long long ']
   float_longnesses = ['float', 'double', 'long double']
-  [ [Struct, lambda do
+  [ [Struct, proc do
         str = 'struct'
         name    and str << " #{name}"
         members and str << " {\n" << indent(members.join("\n")) << "\n}"
         str
       end],
-    [Union, lambda do
+    [Union, proc do
         str = 'union'
         name    and str << " #{name}"
         members and str << " {\n" << indent(members.join("\n")) << "\n}"
         str
       end],
-    [Enum, lambda do
+    [Enum, proc 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
+    [CustomType, proc{name.dup    }],
+    [Void      , proc{'void'      }],
+    [Int       , proc 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'}]
+    [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
@@ -389,7 +392,7 @@ module C
     def to_s
       strs = [:cond, :then, :else].map do |child|
         val = send(child)
-        if val.to_s_precedence < self.to_s_precedence
+        if val.to_s_precedence <= self.to_s_precedence
           "(#{val})"
         else
           "#{val}"
@@ -417,9 +420,9 @@ module C
     end
   end
 
-  ### IndirectTypes
+  ## IndirectTypes
   class Pointer
-    def to_s name=nil
+    def to_s(name=nil)
       str = '*'
       const?    and str << 'const '
       restrict? and str << 'restrict '
@@ -439,7 +442,7 @@ module C
     end
   end
   class Array
-    def to_s name=nil
+    def to_s(name=nil)
       str = "#{name}[#{length}]"
       if type
         type.to_s(str)
@@ -449,14 +452,18 @@ module C
     end
   end
   class Function
-    def to_s name=nil
+    def to_s(name=nil, no_types=false)
       str =
         if params.nil?
           paramstr = ''
         elsif params.empty?
           paramstr = 'void'
         else
-          paramstr = params.join(', ')
+          if no_types
+            paramstr = params.map{|p| p.name}.join(', ')
+          else
+            paramstr = params.join(', ')
+          end
         end
       var_args? and paramstr << ', ...'
       str = "#{name}(#{paramstr})"
@@ -470,11 +477,15 @@ module C
   class Parameter
     def to_s
       str = register? ? 'register ' : ''
-      str << type.to_s(name)
+      if type
+        str << type.to_s(name)
+      else
+        str << name.to_s
+      end
     end
   end
 
-  ### Literals
+  ## Literals
   class StringLiteral
     def to_s
       "\"#{val}\""
@@ -490,7 +501,7 @@ module C
       str = ''
       type and
         str << "(#{type}) "
-      str << "{\n" << indent(inits.join(",\n")) << "\n}"
+      str << "{\n" << indent(member_inits.join(",\n")) << "\n}"
     end
   end
   class MemberInit
@@ -504,7 +515,7 @@ module C
             ".#{m}"
           end
         end
-        str << member.join(' ') << ' = '
+        str << memberstr.join(' ') << ' = '
       end
       return str << init.to_s
     end
@@ -516,12 +527,48 @@ module C
   end
   class IntLiteral
     def to_s
-      val.to_s
+      case format
+      when :dec
+        "#{val.to_s}#{suffix}"
+      when :hex
+        "0x#{val.to_s(16)}#{suffix}"
+      when :oct
+        "0#{val.to_s(8)}#{suffix}"
+      else
+        raise "invalid C::IntLiteral format: #{format}"
+      end
     end
   end
   class FloatLiteral
     def to_s
-      val.to_s
+      case format
+      when :dec
+        if exponent
+          "#{val / 10**exponent}e#{exponent}#{suffix}"
+        else
+          "#{val}#{suffix}"
+        end
+      when :hex
+        "0x#{float_hex(val / 2**exponent)}p#{exponent || 0}#{suffix}"
+      else
+        raise "invalid C::FloatLiteral format: #{format}"
+      end
+    end
+
+    private
+
+    HEX_DIGITS = %w[0 1 2 3 4 5 6 7 8 9 a b c d e f]
+
+    def float_hex(value)
+      int, frac = value.divmod(1)
+      string = "#{int.to_s(16)}."
+      # 64-bit floats have 53 bits of significand ~ 14 hex digits.
+      14.times do
+        break if frac < 1e-17
+        int, frac = (frac * 16).divmod(1)
+        string << HEX_DIGITS[int]
+      end
+      string
     end
   end
   class Variable
@@ -529,8 +576,14 @@ module C
       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
+  # 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"