cast 0.0.1

data/lib/c_nodes.rb

@@ -0,0 +1,1301 @@
+###
+### ##################################################################
+###
+### All those Node classes.
+###
+### ##################################################################
+###
+
+module C
+  ###
+  ### ==================================================================
+  ###
+  ###                        Class declarations
+  ###
+  ### ==================================================================
+  ###
+  class Statement            < Node           ; abstract; end
+  class Label                < Node           ; abstract; end
+  class Expression           < Node           ; abstract; end
+  class UnaryExpression      < Expression     ; abstract; end
+  class PostfixExpression    < UnaryExpression; abstract; end
+  class PrefixExpression     < UnaryExpression; abstract; end
+  class BinaryExpression     < Expression     ; abstract; end
+  class AssignmentExpression < Expression     ; abstract; end
+  class Literal              < Expression     ; abstract; end
+  class Type                 < Node           ; abstract; end
+  class IndirectType         < Type           ; abstract; end
+  class DirectType           < Type           ; abstract; end
+  class PrimitiveType        < DirectType     ; abstract; end
+
+  class TranslationUnit      < Node                ; end
+  class Declaration          < Node                ; end
+  class Declarator           < Node                ; end
+  class FunctionDef          < Node                ; end
+  class Parameter            < Node                ; end
+  class Enumerator           < Node                ; end
+  class MemberInit           < Node                ; end
+  class Member               < Node                ; end
+
+  class Block                < Statement           ; end
+  class If                   < Statement           ; end
+  class Switch               < Statement           ; end
+  class While                < Statement           ; end
+  class For                  < Statement           ; end
+  class Goto                 < Statement           ; end
+  class Continue             < Statement           ; end
+  class Break                < Statement           ; end
+  class Return               < Statement           ; end
+  class ExpressionStatement  < Statement           ; end
+
+  class PlainLabel           < Label               ; end
+  class Default              < Label               ; end
+  class Case                 < Label               ; end
+
+  class Comma                < Expression          ; end
+  class Conditional          < Expression          ; end
+  class Variable             < Expression          ; end
+
+  class Index                < PostfixExpression   ; end
+  class Call                 < PostfixExpression   ; end
+  class Dot                  < PostfixExpression   ; end
+  class Arrow                < PostfixExpression   ; end
+  class PostInc              < PostfixExpression   ; end
+  class PostDec              < PostfixExpression   ; end
+
+  class Cast                 < PrefixExpression    ; end
+  class Address              < PrefixExpression    ; end
+  class Dereference          < PrefixExpression    ; end
+  class Sizeof               < PrefixExpression    ; end
+  class Positive             < PrefixExpression    ; end
+  class Negative             < PrefixExpression    ; end
+  class PreInc               < PrefixExpression    ; end
+  class PreDec               < PrefixExpression    ; end
+  class BitNot               < PrefixExpression    ; end
+  class Not                  < PrefixExpression    ; end
+
+  class Add                  < BinaryExpression    ; end
+  class Subtract             < BinaryExpression    ; end
+  class Multiply             < BinaryExpression    ; end
+  class Divide               < BinaryExpression    ; end
+  class Mod                  < BinaryExpression    ; end
+  class Equal                < BinaryExpression    ; end
+  class NotEqual             < BinaryExpression    ; end
+  class Less                 < BinaryExpression    ; end
+  class More                 < BinaryExpression    ; end
+  class LessOrEqual          < BinaryExpression    ; end
+  class MoreOrEqual          < BinaryExpression    ; end
+  class BitAnd               < BinaryExpression    ; end
+  class BitOr                < BinaryExpression    ; end
+  class BitXor               < BinaryExpression    ; end
+  class ShiftLeft            < BinaryExpression    ; end
+  class ShiftRight           < BinaryExpression    ; end
+  class And                  < BinaryExpression    ; end
+  class Or                   < BinaryExpression    ; end
+
+  class Assign               < AssignmentExpression; end
+  class MultiplyAssign       < AssignmentExpression; end
+  class DivideAssign         < AssignmentExpression; end
+  class ModAssign            < AssignmentExpression; end
+  class AddAssign            < AssignmentExpression; end
+  class SubtractAssign       < AssignmentExpression; end
+  class ShiftLeftAssign      < AssignmentExpression; end
+  class ShiftRightAssign     < AssignmentExpression; end
+  class BitAndAssign         < AssignmentExpression; end
+  class BitXorAssign         < AssignmentExpression; end
+  class BitOrAssign          < AssignmentExpression; end
+
+  class StringLiteral        < Literal             ; end
+  class CharLiteral          < Literal             ; end
+  class CompoundLiteral      < Literal             ; end
+  class IntLiteral           < Literal             ; end
+  class FloatLiteral         < Literal             ; end
+
+  class Pointer              < IndirectType        ; end
+  class Array                < IndirectType        ; end
+  class Function             < IndirectType        ; end
+
+  class Struct               < DirectType          ; end
+  class Union                < DirectType          ; end
+  class Enum                 < DirectType          ; end
+  class CustomType           < DirectType          ; end
+
+  class Void                 < PrimitiveType       ; end
+  class Int                  < PrimitiveType       ; end
+  class Float                < PrimitiveType       ; end
+  class Char                 < PrimitiveType       ; end
+  class Bool                 < PrimitiveType       ; end
+  class Complex              < PrimitiveType       ; end
+  class Imaginary            < PrimitiveType       ; end
+
+  ###
+  ### ==================================================================
+  ###
+  ###                      Class implementations
+  ###
+  ### ==================================================================
+  ###
+
+  ###
+  ### Node
+  ###
+  class Node
+    initializer
+  end
+  ###
+  ### TranslationUnit
+  ###
+  class TranslationUnit
+    child :entities, lambda{NodeChain.new}
+    initializer :entities
+  end
+  ###
+  ### Declaration
+  ###
+  class Declaration
+    field :storage
+    child :type
+    child :declarators, lambda{NodeArray.new}
+    field :inline?
+    initializer :type, :declarators
+    def typedef?
+      storage.equal? :typedef
+    end
+    def extern?
+      storage.equal? :extern
+    end
+    def static?
+      storage.equal? :static
+    end
+    def auto?
+      storage.equal? :auto
+    end
+    def register?
+      storage.equal? :register
+    end
+  end
+  ###
+  ### Declarator
+  ###
+  class Declarator
+    child :indirect_type
+    field :name
+    child :init
+    child :num_bits
+    initializer :indirect_type, :name, :init, :num_bits
+    def declaration
+      parent and parent.parent
+    end
+    ###
+    ### Return (a copy of) the type of the variable this Declarator
+    ### declares.
+    ###
+    def type
+      if indirect_type
+        ret = indirect_type.clone
+        ret.direct_type = declaration.type.clone
+        return ret
+      else
+        declaration.type.clone
+      end
+    end
+  end
+  ###
+  ### FunctionDef
+  ###
+  class FunctionDef
+    field :storage
+    field :inline?
+    child :type
+    field :name
+    child :def, lambda{Block.new}
+    field :no_prototype?
+    initializer :type, :name, :def
+    def extern?
+      storage.equal? :extern
+    end
+    def static?
+      storage.equal? :static
+    end
+    def prototype= val
+      self.no_prototype = !val
+    end
+    def prototype?
+      !no_prototype?
+    end
+  end
+  ###
+  ### Parameter
+  ###
+  class Parameter
+    field :register?
+    child :type
+    field :name
+    initializer :type, :name
+  end
+  ###
+  ### Enumerator
+  ###
+  class Enumerator
+    field :name
+    child :val
+    initializer :name, :val
+  end
+  ###
+  ### MemberInit
+  ###
+  class MemberInit
+    ## member is a _NodeList_ of:
+    ##   -- Member (for struct/union members)
+    ##   -- Expression (for array members)
+    child :member
+    child :init
+    initializer :member, :init
+  end
+  ###
+  ### Member
+  ###
+  class Member
+    field :name
+    initializer :name
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                            Statements
+  ### ----------------------------------------------------------------
+
+  ###
+  ### Block
+  ###
+  class Block
+    child :labels, lambda{NodeArray.new}
+    child :stmts, lambda{NodeChain.new}
+    initializer :stmts
+  end
+  ###
+  ### If
+  ###
+  class If
+    child :labels, lambda{NodeArray.new}
+    child :cond
+    child :then
+    child :else
+    initializer :cond, :then, :else
+  end
+  ###
+  ### Switch
+  ###
+  class Switch
+    child :labels, lambda{NodeArray.new}
+    child :cond
+    child :stmt
+    initializer :cond, :stmt
+  end
+  ###
+  ### While
+  ###
+  class While
+    child :labels, lambda{NodeArray.new}
+    field :do?
+    child :cond
+    child :stmt
+    initializer :cond, :stmt, :do?
+  end
+  ###
+  ### For
+  ###
+  class For
+    child :labels, lambda{NodeArray.new}
+    child :init
+    child :cond
+    child :iter
+    child :stmt
+    initializer :init, :cond, :iter, :stmt
+  end
+  ###
+  ### Goto
+  ###
+  class Goto
+    child :labels, lambda{NodeArray.new}
+    field :target
+    initializer :target
+  end
+  ###
+  ### Continue
+  ###
+  class Continue
+    child :labels, lambda{NodeArray.new}
+  end
+  ###
+  ### Break
+  ###
+  class Break
+    child :labels, lambda{NodeArray.new}
+  end
+  ###
+  ### Return
+  ###
+  class Return
+    child :labels, lambda{NodeArray.new}
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### ExpressionStatement
+  ###
+  class ExpressionStatement
+    child :labels, lambda{NodeArray.new}
+    child :expr
+    initializer :expr
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                              Labels
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### PlainLabel
+  ###
+  class PlainLabel
+    field :name
+    initializer :name
+  end
+
+  ###
+  ### Default
+  ###
+  class Default
+  end
+
+  ###
+  ### Case
+  ###
+  class Case
+    child :expr
+    initializer :expr
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                           Expressions
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### Comma
+  ###
+  class Comma
+    child :exprs, lambda{NodeArray.new}
+    initializer :exprs
+  end
+  ###
+  ### Conditional
+  ###
+  class Conditional
+    child :cond
+    child :then
+    child :else
+    initializer :cond, :then, :else
+  end
+  ###
+  ### Sizeof
+  ###
+  class Sizeof
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### Variable
+  ###
+  class Variable
+    field :name
+    initializer :name
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                        PrefixExpressions
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### Cast
+  ###
+  class Cast
+    child :type
+    child :expr
+    initializer :type, :expr
+  end
+  ###
+  ### Address
+  ###
+  class Address
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### Dereference
+  ###
+  class Dereference
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### Positive
+  ###
+  class Positive
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### Negative
+  ###
+  class Negative
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### PreInc
+  ###
+  class PreInc
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### PreDec
+  ###
+  class PreDec
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### BitNot
+  ###
+  class BitNot
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### Not
+  ###
+  class Not
+    child :expr
+    initializer :expr
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                        PostfixExpressions
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### Index
+  ###
+  class Index
+    child :expr
+    child :index
+    initializer :expr, :index
+  end
+  ###
+  ### Call
+  ###
+  class Call
+    child :expr
+    child :args, lambda{NodeArray.new}
+    initializer :expr, :args
+  end
+  ###
+  ### Dot
+  ###
+  class Dot
+    child :expr
+    child :member
+    initializer :expr, :member
+  end
+  ###
+  ### Arrow
+  ###
+  class Arrow
+    child :expr
+    child :member
+    initializer :expr, :member
+  end
+  ###
+  ### PostInc
+  ###
+  class PostInc
+    child :expr
+    initializer :expr
+  end
+  ###
+  ### PostDec
+  ###
+  class PostDec
+    child :expr
+    initializer :expr
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                        BinaryExpressions
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### BinaryExpression (abstract)
+  ###
+  class BinaryExpression
+    class << self
+      ###
+      ### The operator (a String) pertaining to the class (e.g.,
+      ### Add.operator is '+').
+      ###
+      attr_accessor :operator
+    end
+  end
+  ###
+  ### Add
+  ###
+  class Add
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '+'
+  end
+  ###
+  ### Subtract
+  ###
+  class Subtract
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '-'
+  end
+  ###
+  ### Multiply
+  ###
+  class Multiply
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '*'
+  end
+  ###
+  ### Divide
+  ###
+  class Divide
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '/'
+  end
+  ###
+  ### Mod
+  ###
+  class Mod
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '%'
+  end
+  ###
+  ### Equal
+  ###
+  class Equal
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '=='
+  end
+  ###
+  ### NotEqual
+  ###
+  class NotEqual
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '!='
+  end
+  ###
+  ### Less
+  ###
+  class Less
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '<'
+  end
+  ###
+  ### More
+  ###
+  class More
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '>'
+  end
+  ###
+  ### LessOrEqual
+  ###
+  class LessOrEqual
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '<='
+  end
+  ###
+  ### MoreOrEqual
+  ###
+  class MoreOrEqual
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '>='
+  end
+  ###
+  ### BitAnd
+  ###
+  class BitAnd
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '&'
+  end
+  ###
+  ### BitOr
+  ###
+  class BitOr
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '|'
+  end
+  ###
+  ### BitXor
+  ###
+  class BitXor
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '^'
+  end
+  ###
+  ### ShiftLeft
+  ###
+  class ShiftLeft
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '<<'
+  end
+  ###
+  ### ShiftRight
+  ###
+  class ShiftRight
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '>>'
+  end
+  ###
+  ### And
+  ###
+  class And
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '&&'
+  end
+  ###
+  ### Or
+  ###
+  class Or
+    child :expr1
+    child :expr2
+    initializer :expr1, :expr2
+    self.operator = '||'
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                      AssignmentExpressions
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### AssignmentExpression (abstract)
+  ###
+  class AssignmentExpression
+    class << self
+      ###
+      ### The operator (a String) pertaining to the class (e.g.,
+      ### Assign.operator is '=').
+      ###
+      attr_accessor :operator
+    end
+  end
+  ###
+  ### Assign
+  ###
+  class Assign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '='
+  end
+  ###
+  ### MultiplyAssign
+  ###
+  class MultiplyAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '*='
+  end
+  ###
+  ### DivideAssign
+  ###
+  class DivideAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '/='
+  end
+  ###
+  ### ModAssign
+  ###
+  class ModAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '%='
+  end
+  ###
+  ### AddAssign
+  ###
+  class AddAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '+='
+  end
+  ###
+  ### SubtractAssign
+  ###
+  class SubtractAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '-='
+  end
+  ###
+  ### ShiftLeftAssign
+  ###
+  class ShiftLeftAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '<<='
+  end
+  ###
+  ### ShiftRightAssign
+  ###
+  class ShiftRightAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '>>='
+  end
+  ###
+  ### BitAndAssign
+  ###
+  class BitAndAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '&='
+  end
+  ###
+  ### BitXorAssign
+  ###
+  class BitXorAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '^='
+  end
+  ###
+  ### BitOrAssign
+  ###
+  class BitOrAssign
+    child :lval
+    child :rval
+    initializer :lval, :rval
+    self.operator = '|='
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                            Literals
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### StringLiteral
+  ###
+  class StringLiteral
+    field :val
+    initializer :val
+  end
+  ###
+  ### CharLiteral
+  ###
+  class CharLiteral
+    field :val
+    initializer :val
+  end
+  ###
+  ### CompoundLiteral
+  ###
+  class CompoundLiteral
+    child :type
+    child :member_inits, lambda{NodeArray.new}
+    initializer :type, :member_inits
+  end
+  ###
+  ### IntLiteral
+  ###
+  class IntLiteral
+    field :val
+    field :format, :dec
+    initializer :val
+    def dec?
+      format.equal? :dec
+    end
+    def hex?
+      format.equal? :hex
+    end
+    def oct?
+      format.equal? :oct
+    end
+  end
+  ###
+  ### FloatLiteral
+  ###
+  class FloatLiteral
+    field :val
+    initializer :val
+  end
+
+  ###
+  ### ----------------------------------------------------------------
+  ###                              Types
+  ### ----------------------------------------------------------------
+  ###
+
+  ###
+  ### DirectType (abstract)
+  ###
+  class DirectType
+    def direct_type
+      self
+    end
+    def indirect_type
+      nil
+    end
+  end
+  ###
+  ### IndirectType (abstract)
+  ###
+  class IndirectType
+    def direct_type
+      if type.is_a? IndirectType
+        type.direct_type
+      else
+        type
+      end
+    end
+    def direct_type= val
+      if type.is_a? IndirectType
+        type.direct_type = val
+      else
+        self.type = val
+      end
+    end
+    def indirect_type
+      ret = self.clone
+      t = ret
+      while t.type.is_a? IndirectType
+        t = t.type
+      end
+      t.type = nil
+      return ret
+    end
+  end
+  ###
+  ### Pointer
+  ###
+  class Pointer
+    field :const?
+    field :restrict?
+    field :volatile?
+    child :type
+    initializer :type
+  end
+  ###
+  ### Array
+  ###
+  class Array
+    field :const?
+    field :restrict?
+    field :volatile?
+    child :type
+    child :length
+    initializer :type, :length
+  end
+  ###
+  ### Function
+  ###
+  class Function
+    field :const?
+    field :restrict?
+    field :volatile?
+    child :type
+    child :params
+    field :var_args?
+    initializer :type, :params
+  end
+  ###
+  ### Struct
+  ###
+  class Struct
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :name
+    child :members
+    initializer :name, :members
+  end
+  ###
+  ### Union
+  ###
+  class Union
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :name
+    child :members
+    initializer :name, :members
+  end
+  ###
+  ### Enum
+  ###
+  class Enum
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :name
+    child :members
+    initializer :name, :members
+  end
+  ###
+  ### CustomType
+  ###
+  class CustomType
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :name
+    initializer :name
+  end
+  ###
+  ### Void
+  ###
+  class Void
+    field :const?
+    field :restrict?
+    field :volatile?
+  end
+  ###
+  ### Int
+  ###
+  class Int
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :longness, 0
+    field :unsigned?, false
+    initializer :longness
+    def signed?
+      !unsigned?
+    end
+    def signed= val
+      self.unsigned = !val
+    end
+    def short?
+      longness.equal? -1
+    end
+    def plain?
+      longness.equal? 0
+    end
+    def long?
+      longness.equal? 1
+    end
+    def long_long?
+      longness.equal? 2
+    end
+  end
+  ###
+  ### Float
+  ###
+  class Float
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :longness, 0
+    initializer :longness
+    def plain?
+      longness.equal? 0
+    end
+    def double?
+      longness.equal? 1
+    end
+    def long_double?
+      longness.equal? 2
+    end
+  end
+  ###
+  ### Char
+  ###
+  class Char
+    field :const?
+    field :restrict?
+    field :volatile?
+    ## 6.2.5p15: `char', `signed char', and `unsigned char' are
+    ## distinct types
+    field :signed
+    def signed?
+      signed.equal? true
+    end
+    def unsigned?
+      signed.equal? false
+    end
+    def plain?
+      signed.nil?
+    end
+  end
+  ###
+  ### Bool
+  ###
+  class Bool
+    field :const?
+    field :restrict?
+    field :volatile?
+  end
+  ###
+  ### Complex
+  ###
+  class Complex
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :longness, 0
+    initializer :longness
+    def plain?
+      longness.equal? 0
+    end
+    def double?
+      longness.equal? 1
+    end
+    def long_double?
+      longness.equal? 2
+    end
+  end
+  ###
+  ### Imaginary
+  ###
+  class Imaginary
+    field :const?
+    field :restrict?
+    field :volatile?
+    field :longness, 0
+    initializer :longness
+    def plain?
+      longness.equal? 0
+    end
+    def double?
+      longness.equal? 1
+    end
+    def long_double?
+      longness.equal? 2
+    end
+  end
+
+  ###
+  ### ================================================================
+  ###
+  ###                           Tag classes
+  ###
+  ### ================================================================
+  ###
+
+  ## classify the node classes by including modules
+  tagger = lambda do |included, *includers|
+    includers.each{|mod| mod.send(:include, included)}
+  end
+
+  ## expression classes
+  module ArithmeticExpression; end
+  module BitwiseExpression   ; end
+  module LogicalExpression   ; end
+  module RelationalExpression; end
+  module ShiftExpression     ; end
+  ##
+  tagger.call(ArithmeticExpression,
+              PostInc, PostDec, Positive, Negative, PreInc, PreDec, Add,
+              Subtract, Multiply, Divide, Mod)
+  tagger.call(BitwiseExpression,
+              BitNot, BitAnd, BitOr, BitXor)
+  tagger.call(LogicalExpression,
+              Not, And, Or)
+  tagger.call(RelationalExpression,
+              Equal, NotEqual, Less, More, LessOrEqual, MoreOrEqual)
+  tagger.call(ShiftExpression,
+              ShiftLeft, ShiftRight)
+
+  ###
+  ### ================================================================
+  ###
+  ###                       CORE_C_NODE_CLASSES
+  ###
+  ### ================================================================
+  ###
+
+  CORE_C_NODE_CLASSES = [
+    TranslationUnit,
+    Declaration,
+    Declarator,
+    FunctionDef,
+    Parameter,
+    Enumerator,
+    MemberInit,
+    Member,
+
+    Block,
+    If,
+    Switch,
+    While,
+    For,
+    Goto,
+    Continue,
+    Break,
+    Return,
+    ExpressionStatement,
+
+    PlainLabel,
+    Default,
+    Case,
+
+    Comma,
+    Conditional,
+    Variable,
+
+    Index,
+    Call,
+    Dot,
+    Arrow,
+    PostInc,
+    PostDec,
+
+    Cast,
+    Address,
+    Dereference,
+    Sizeof,
+    Positive,
+    Negative,
+    PreInc,
+    PreDec,
+    BitNot,
+    Not,
+
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Mod,
+    Equal,
+    NotEqual,
+    Less,
+    More,
+    LessOrEqual,
+    MoreOrEqual,
+    BitAnd,
+    BitOr,
+    BitXor,
+    ShiftLeft,
+    ShiftRight,
+    And,
+    Or,
+
+    Assign,
+    MultiplyAssign,
+    DivideAssign,
+    ModAssign,
+    AddAssign,
+    SubtractAssign,
+    ShiftLeftAssign,
+    ShiftRightAssign,
+    BitAndAssign,
+    BitXorAssign,
+    BitOrAssign,
+
+    StringLiteral,
+    CharLiteral,
+    CompoundLiteral,
+    IntLiteral,
+    FloatLiteral,
+
+    Pointer,
+    Array,
+    Function,
+
+    Struct,
+    Union,
+    Enum,
+    CustomType,
+
+    Void,
+    Int,
+    Float,
+    Char,
+    Bool,
+    Complex,
+    Imaginary
+  ]
+
+  ## check we didn't miss any
+  expected_classes = Node.subclasses_recursive.sort_by{|c| c.name}
+  expected_classes -= NodeList.subclasses_recursive
+  expected_classes -= [NodeList]
+  expected_classes -= [
+    Statement,
+    Label,
+    Expression,
+    UnaryExpression,
+    PostfixExpression,
+    PrefixExpression,
+    BinaryExpression,
+    AssignmentExpression,
+    Literal,
+    Type,
+    IndirectType,
+    DirectType,
+    PrimitiveType
+  ]
+  ##
+  CORE_C_NODE_CLASSES.sort_by{|c| c.name} == expected_classes or raise
+end