chelsy 0.0.3 → 0.0.4

data/lib/chelsy/ast.rb

@@ -1,4 +1,5 @@
 require "chelsy/syntax"
+require "forwardable"
 
 module Chelsy
 
@@ -7,41 +8,87 @@ module Chelsy
     end
   end
 
-  # The class must provide a method `items` and `validate_node`
+  # The class must provide a method validate_node`
   module NodeList
     include Enumerable
+    extend Forwardable
+
+    def_delegators :@items, :size, :empty?, :[]
+
+    def initialize(items=[], **rest)
+      @items = items.map {|element| validate_node(element) }
+      super(**rest)
+    end
 
     def each(&block)
-      items.each(&block)
+      @items.each(&block)
       self
     end
 
-    def size; items.size end
-    def empty?; items.empty? end
-
     def <<(node)
-      items << validate_node(node)
+      @items << validate_node(node)
       self
     end
+
+    def concat(enumerable)
+      enumerable.each {|it| @items << validate_node(it) }
+      self
+    end
+
+    def []=(*args)
+      value = args[-1]
+      value = case value
+              when Enumerable
+                value.map {|v| validate_node(v) }
+              else
+                validate_node(value)
+              end
+      args[-1] = value
+      @items.send(:[]=, *args)
+    end
   end
 
   class Fragment < Node
   end
 
+  module Comment
+    class Base < Fragment
+    end
+
+    # `// ...`
+    class Single < Base
+      attr_reader :body
+
+      def initialize(body, **rest)
+        @body = body.dup
+        super **rest
+      end
+    end
+
+    # `/* ... */`
+    class Multi < Base
+      attr_reader :lines
+
+      def initialize(body, **rest)
+        @lines = case body
+                 when String
+                   body.split(/\n/)
+                 else
+                   body.to_a
+                 end
+        super **rest
+      end
+    end
+
+  end
+
   module Syntax
-    Fragment = Any.new('Fragment', [Fragment, String])
   end
 
   class FragmentList < Node
     include NodeList
 
-    def initialize(**rest)
-      @fragments = []
-      super(**rest)
-    end
-
     private
-    def items; @fragments end
     def validate_node(node); Syntax::Fragment.ensure(node) end
   end
 
@@ -60,19 +107,98 @@ module Chelsy
     end
   end
 
-  class Declaration < Element
-  end
+  class Declarative < Element
+    attr_reader :storage
 
-  class Definition < Element
-    def initialize(extern: false, static: false, **rest)
-      @extern = !!extern
-      @static = !!static
+    def initialize(storage: nil, **rest)
+      @storage = Syntax::Storage.ensure(storage) if storage
 
       super(**rest)
     end
 
-    def extern?; @extern end
-    def static?; @static end
+    def extern?; @storage == :extern end
+    def static?; @storage == :static end
+    def init; nil end
+  end
+
+  # Struct or Union member with bit-field
+  #
+  # Unnamed bit-field ::
+  #     A bit-field declaration with no declarator, but only a colon and a width
+  class BitField < Element
+    attr_reader :declaration, :bits
+
+    def initialize(bits, declaration=nil, **rest)
+      @declaration = Syntax::Declaration.ensure(declaration) if declaration
+      @bits = bits && Syntax::BitField.ensure(bits)
+
+      super **rest
+    end
+  end
+
+  class EnumMember < Element
+    attr_reader :name, :init
+
+    def initialize(name, init=nil, **rest)
+      @name = name.to_sym
+      @init = init
+      super **rest
+    end
+  end
+
+  class StructOrUnionMemberList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::StructOrUnionMember.ensure(node) end
+  end
+
+  class EnumMemberList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::EnumMember.ensure(node) end
+  end
+
+  # === 6.7.8 Initialization
+  class Designator < Element
+  end
+
+  # { [1] = 10, [2] = 20, ...}
+  class IndexDesignator < Designator
+    attr_reader :index
+
+    def initialize(index, **rest)
+      @index = Syntax::Expr.ensure(index)
+      super **rest
+    end
+  end
+
+  # { .a = 10, .b = 20, ...}
+  class MemberDesignator < Designator
+    attr_reader :name
+
+    def initialize(name, **rest)
+      @name = Syntax::Ident.ensure(name)
+      super **rest
+    end
+  end
+
+  class Initializer < Element
+    attr_reader :designator, :value
+
+    def initialize(value, designator=nil, **rest)
+      @value = value
+      @designator = designator
+      super **rest
+    end
+  end
+
+  class InitializerList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::Initializer.ensure(node) end
   end
 
   class Expr < Element
@@ -82,45 +208,76 @@ module Chelsy
   end
 
   module Syntax
-    Ident    = Any.new('Identifier', [Symbol])
-    Expr     = Any.new('Expression', [Expr, Symbol])
-    TopLevel = Any.new('TopLevel', [Definition, Declaration])
   end
 
   # `Document` represents a _translation unit_ (file).
   class Document < Element
     include NodeList
 
-    def initialize(**rest)
-      @items = []
-      super(**rest)
-    end
-
     private
-    def items; @items end
     def validate_node(node); Syntax::TopLevel.ensure(node) end
   end
 
   # = 6.2.5 Types
   module Type
     class Base < Element
-      def initialize(const: false, restrict: false, volatile: false, **rest)
+      def initialize(const: false, volatile: false, **rest)
         @const = !!const
-        @restrict = !!restrict
         @volatile = !!volatile
 
         super(**rest)
       end
 
       def const?;    @const end
-      def restrict?; @restrict end
       def volatile?; @volatile end
 
       def qualified?
-        @const || @restrict || @volatile
+        @const || @volatile
       end
     end
 
+  end
+
+  module Syntax
+  end
+
+  # Function and prototype params
+  class Param < Element
+    attr_reader :name, :type
+
+    def initialize(name, type, register: false, **rest)
+      @name = Syntax::Ident.ensure(name)
+      @type = Syntax::Type.ensure(type)
+
+      super(**rest)
+    end
+  end
+
+  module Syntax
+  end
+
+  class IdentList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::Ident.ensure(node) end
+  end
+
+  class ParamList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::Param.ensure(node) end
+  end
+
+  class ProtoParamList < Element
+    include NodeList
+
+    private
+    def validate_node(node); Syntax::ProtoParam.ensure(node) end
+  end
+
+  module Type
     class Numeric < Base
     end
 
@@ -186,33 +343,108 @@ module Chelsy
     class Pointer < Derived
       attr_reader :pointee
 
-      def initialize(pointee, **rest)
+      def initialize(pointee, restrict: false, **rest)
         @pointee = Syntax::Type.ensure(pointee)
+        @restrict = !!restrict
+
         super(**rest)
       end
+
+      def restrict?; @restrict end
+
+      def qualified?
+        @restrict || super
+      end
+
+      def termination_type
+        pointee = self.pointee
+        while pointee.is_a?(Type::Pointer)
+          pointee = pointee.pointee
+        end
+        pointee
+      end
     end
 
+    # From: 6.7.5.3 Function declarators (including prototypes)
+    #
+    # qualifier in parameter array declarator
+    #
+    # > A declaration of a parameter as ‘‘array of type’’ shall be adjusted to
+    # > ‘‘qualified pointer to type’’, where the type qualifiers (if any) are
+    # > those specified within the [ and ] of the array type derivation.
+    #
+    # `static` in parameter array declarator
+    #
+    # > If the keyword static also appears within the [ and ] of the array type derivation,
+    # > then for each call to the function, the value of the corresponding actual argument shall
+    # > provide access to the first element of an array with at least as many elements as
+    # > specified by the size expression.
     class Array < Derived
       attr_reader :element_type, :size
 
-      def initialize(element_type, size = nil, **rest)
+      def initialize(element_type, size = nil, static: false, **rest)
         @element_type = element_type
-        @size = size
+        @size = size && Syntax::ArraySize.ensure(size)
+        @static = !!static
 
         super(**rest)
       end
 
       # An array type of unknown size is an incomplete type.
       def incomplete?; @size.nil? end
+      def variable?; @size == :* end
+
+      def static?; @static end
     end
 
-    # TODO Function
-    # TODO Struct
-    # TODO Union
-  end
+    class Function < Derived
+      attr_reader :return_type, :params
+
+      def initialize(return_type, params, **rest)
+        @return_type = Syntax::Type.ensure(return_type)
+        @params = ProtoParamList.new(params)
+
+        super(**rest)
+      end
+    end
+
+    # Struct, Unicon, Enum
+
+    class Taggable < Derived
+      attr_reader :tag
+
+      def initialize(tag, **rest)
+        @tag = tag.to_sym
+        super **rest
+      end
+    end
+
+    module StructOrUnion
+      attr_reader :members
+
+      def initialize(tag, members=nil, **rest)
+        @members = StructOrUnionMemberList.new(members) if members
+        super tag, **rest
+      end
+    end
+
+    class Struct < Taggable
+      include StructOrUnion
+    end
+
+    class Union < Taggable
+      include StructOrUnion
+    end
+
+    class Enum < Taggable
+      attr_reader :members
+
+      def initialize(tag, members=nil, **rest)
+        @members = EnumMemberList.new(members) if members
+        super tag, **rest
+      end
+    end
 
-  module Syntax
-    Type = Any.new('TypeSpecifier', [Chelsy::Type::Base, :void])
   end
 
   # 6.4.4.1 Integer constants
@@ -247,6 +479,9 @@ module Chelsy
 
   end
 
+  module Syntax
+  end
+
   # 6.4.5 String literals
   module Constant
 
@@ -267,20 +502,420 @@ module Chelsy
 
   end
 
-  # 6.5.2.2 Function calls
-  class FunctionCall < Expr
-    attr_reader :callee, :args
+  module Operator
+    class Base < Expr
+      def self.operator; nil end
+    end
 
-    def initialize(callee, args, **rest)
-      @callee = Syntax::Expr.ensure(callee)
-      @args = args.map {|a| Syntax::Expr.ensure(a) }
+    class Unary < Base
+      attr_reader :operand
 
-      super(**rest)
+      def initialize(operand, **rest)
+        # `sizeof` operator accepts expr or type as its operand.
+        @operand = operand
+        super **rest
+      end
+    end
+
+    class Postfix < Unary
+      def initialize(operand, **rest)
+        super Syntax::Expr.ensure(operand), **rest
+      end
+    end
+
+    class Prefix < Unary
+      def initialize(operand, **rest)
+        super Syntax::Expr.ensure(operand), **rest
+      end
+    end
+
+    class Binary < Base
+      attr_reader :lhs, :rhs
+
+      def initialize(lhs, rhs, **rest)
+        @lhs = Syntax::Expr.ensure(lhs)
+        @rhs = Syntax::Expr.ensure(rhs)
+        super **rest
+      end
+    end
+
+    # Ternary conditional
+    class Conditional < Base
+      attr_reader :condition, :then, :else
+
+      def self.operator; :"?:" end
+
+      def initialize(condition, then_expr, else_expr, **rest)
+        @condition = Syntax::Expr.ensure(condition)
+        @then = Syntax::Expr.ensure(then_expr)
+        @else = Syntax::Expr.ensure(else_expr)
+
+        super **rest
+      end
+    end
+
+    # === 6.5.2.1 Array subscripting
+    class Subscription < Postfix
+      attr_reader :index
+
+      def self.operator; :"[]" end
+
+      def initialize(subscriptee, index, **rest)
+        @index = Syntax::Expr.ensure(index)
+        super subscriptee, **rest
+      end
+
+      def subscriptee; operand end
+    end
+
+    # === 6.5.2.2 Function calls
+    class Call < Postfix
+      attr_reader :args
+
+      def self.operator; :"()" end
+
+      def initialize(callee, args, **rest)
+        @args = args.map {|a| Syntax::Expr.ensure(a) }
+
+        super callee, **rest
+      end
+
+      def callee; operand end
+    end
+
+    # === 6.5.2.3 Structure and union members
+    class Access < Postfix
+      attr_reader :name
+
+      def self.operator; :"." end
+
+      def initialize(object, name, **rest)
+        @name = Syntax::Ident.ensure(name)
+        super object, **rest
+      end
+
+      def object; operand end
+    end
+
+    class IndirectAccess < Access
+      def self.operator; :"->" end
+    end
+
+    # === 6.5.2.4 Postfix increment and decrement operators
+    class PostfixIncrement < Postfix
+      def self.operator; :"++" end
+    end
+
+    class PostfixDecrement < Postfix
+      def self.operator; :"--" end
+    end
+
+    # === 6.5.3 Unary operators
+    class PrefixIncrement < Prefix
+      def self.operator; :"++" end
+    end
+
+    class PrefixDecrement < Prefix
+      def self.operator; :"--" end
+    end
+
+    # Unary plus
+    class Plus < Prefix
+      def self.operator; :"+" end
+    end
+
+    # Unary minus
+    class Minus < Prefix
+      def self.operator; :"-" end
+    end
+
+    # Logical NOT
+    class Not < Prefix
+      def self.operator; :"!" end
+    end
+
+    # Bitwise NOT
+    class BitwiseNot < Prefix
+      def self.operator; :"~" end
+    end
+
+    # Indirection (dereference)
+    class Dereference < Prefix
+      def self.operator; :"*" end
+    end
+
+    # Address-of
+    class Address < Prefix
+      def self.operator; :"&" end
+    end
+
+    # Type cast
+    class Cast < Prefix
+      attr_reader :type
+
+      def self.operator; :"()" end
+
+      def initialize(operand, type, **rest)
+        @type = Syntax::Type.ensure(type)
+        super operand, **rest
+      end
+    end
+
+    # Size-of
+    class SizeOf < Unary
+      def self.operator; :"sizeof" end
+
+      def initialize(operand, **rest)
+        super Syntax::ExprOrType.ensure(operand), **rest
+      end
+    end
+
+    # `defined` unary operator in conditional macro.
+    class Defined < Unary
+      def self.operator; :"defined" end
+
+      def initialize(operand, **rest)
+        super Syntax::Ident.ensure(operand), **rest
+      end
+    end
+
+    # == 6.5.5 Multiplicative operators
+
+    # Multiplication
+    class Mul < Binary
+      def self.operator; :* end
+    end
+
+    # Division
+    class Div < Binary
+      def self.operator; :/ end
+    end
+
+    # Remainder
+    class Rem < Binary
+      def self.operator; :% end
+    end
+
+    # Addition
+    class Add < Binary
+      def self.operator; :+ end
+    end
+
+    # Subtraction
+    class Sub < Binary
+      def self.operator; :- end
+    end
+
+    # Bitwise left shift and right shift
+    class BitwiseLeftShift < Binary
+      def self.operator; :<< end
+    end
+
+    class BitwiseRightShift < Binary
+      def self.operator; :>> end
+    end
+
+    # For relational operators < and ≤ respectively
+    class LessThan < Binary
+      def self.operator; :< end
+    end
+
+    class LessThanOrEqual < Binary
+      def self.operator; :<= end
+    end
+
+    # For relational operators > and ≥ respectively
+    class GreaterThan < Binary
+      def self.operator; :> end
+    end
+
+    class GreaterThanOrEqual < Binary
+      def self.operator; :>= end
+    end
+
+    # For relational = and ≠ respectively
+    class Equal < Binary
+      def self.operator; :== end
+    end
+
+    class NotEqual < Binary
+      def self.operator; :"!=" end
+    end
+
+    # Bitwise AND, XOR, OR
+    class BitwiseAnd < Binary
+      def self.operator; :& end
+    end
+
+    class BitwiseXor < Binary
+      def self.operator; :"^" end
+    end
+
+    class BitwiseOr < Binary
+      def self.operator; :"|" end
+    end
+
+    # Logical AND, OR
+    class And < Binary
+      def self.operator; :"&&" end
+    end
+
+    class Or < Binary
+      def self.operator; :"||" end
+    end
+
+    # === 6.5.16 Assignment operators
+
+    class Assign < Binary
+      def self.operator; :"=" end
+    end
+
+    class AssignAdd < Binary
+      def self.operator; :"+=" end
+    end
+
+    class AssignSub < Binary
+      def self.operator; :"-=" end
+    end
+
+    class AssignMul < Binary
+      def self.operator; :"*=" end
+    end
+
+    class AssignDiv < Binary
+      def self.operator; :"/=" end
+    end
+
+    class AssignRem < Binary
+      def self.operator; :"%=" end
+    end
+
+    class AssignBitwiseLeftShift < Binary
+      def self.operator; :"<<=" end
+    end
+
+    class AssignBitwiseLeftRight < Binary
+      def self.operator; :">>=" end
+    end
+
+    class AssignBitwiseAnd < Binary
+      def self.operator; :"&=" end
+    end
+
+    class AssignBitwiseXor < Binary
+      def self.operator; :"^=" end
+    end
+
+    class AssignBitwiseOr < Binary
+      def self.operator; :"|=" end
+    end
+
+    class Comma < Binary
+      def self.operator; :"," end
+    end
+
+  end
+
+  module Operator
+    # --- Operator precedence
+    # The following table lists the precedence of operators.
+    # Operators are listed top to bottom, in descending precedence.
+
+    PRECEDENCE_TABLE = [
+      # -- highest
+      [
+        PostfixIncrement, PostfixDecrement,
+        Call,
+        Subscription,
+        Access,
+        # Compound Literal
+      ],
+      [
+        PrefixIncrement, PrefixDecrement,
+        Plus, Minus,
+        Not, BitwiseNot,
+        Cast,
+        Dereference,
+        Address,
+        SizeOf,
+        Defined,
+      ],
+      [
+        Mul, Div, Rem,
+      ],
+      [
+        Add, Sub,
+      ],
+      [
+        BitwiseLeftShift, BitwiseRightShift,
+      ],
+      [
+        LessThan, LessThanOrEqual,
+        GreaterThan, GreaterThanOrEqual,
+      ],
+      [
+        Equal, NotEqual,
+      ],
+      [
+        BitwiseAnd,
+      ],
+      [
+        BitwiseXor,
+      ],
+      [
+        BitwiseOr,
+      ],
+      [
+        And,
+      ],
+      [
+        Or,
+      ],
+      [
+        Conditional,
+      ],
+      [
+        Assign,
+        AssignAdd, AssignSub,
+        AssignMul, AssignDiv, AssignRem,
+        AssignBitwiseLeftShift, AssignBitwiseLeftRight,
+        AssignBitwiseAnd, AssignBitwiseXor, AssignBitwiseOr,
+      ],
+      [
+        Comma,
+      ],
+    ]
+
+    # This hash contains precedence value (Fixnum) by Operator::Base classes.
+    # Higher precedence has higher value.
+    OPERATOR_PRECEDENCE = {}.tap do |table|
+      PRECEDENCE_TABLE.reverse.each_with_index do |op_classes, precedence|
+        op_classes.each do |klass|
+          table[klass] = precedence
+        end
+      end
+    end
+
+    class Base
+      def self.precedence
+        OPERATOR_PRECEDENCE[self] or raise NotImplementedError
+      end
     end
   end
 
   # = 6.8 Statements and blocks
 
+  # == 6.8.1 Labeled statements
+  class Labeled < Stmt
+    attr_reader :label, :stmt
+
+    def initialize(label, stmt, **rest)
+      @label = Syntax::Ident.ensure(label)
+      @stmt = Syntax::Stmt.ensure(stmt)
+      super **rest
+    end
+  end
+
   # == 6.8.3 Expression and null statements
 
   # A null statement (consisting of just a semicolon) performs no operations.
@@ -298,31 +933,102 @@ module Chelsy
   end
 
   # == 6.8.2 Compound statement
-  module Syntax
-    BlockItem = Any.new('BlockItem', [Stmt, Declaration])
-  end
 
   class Block < Stmt
     include NodeList
 
-    def initialize(**rest)
-      @items = []
-      super(**rest)
-    end
-
     private
-    def items; @items end
 
-    # Implicit convertion from Expr to ExprStmt
     def validate_node(node)
-      item = node
-      item = ExprStmt.new(node) if Syntax::Expr.accept?(node)
+      Syntax::BlockItem.ensure(node)
+    end
+  end
+
+  # === 6.8.4.1 The if statement
+  class If < Stmt
+    attr_reader :condition, :then, :else
 
-      Syntax::BlockItem.ensure(item)
+    def initialize(condition_expr, then_stmt, else_stmt=nil, **rest)
+      @condition = Syntax::Expr.ensure(condition_expr)
+      @then = Syntax::Stmt::ensure(then_stmt)
+      @else = Syntax::Stmt::ensure(else_stmt) if else_stmt
+
+      super **rest
+    end
+  end
+
+  # === 6.8.4.2 Theswitchstatement
+  class Switch < Stmt
+    attr_reader :expr, :stmt
+
+    def initialize(expr, stmt, **rest)
+      @expr = Syntax::Expr.ensure(expr)
+      @stmt = Syntax::Stmt.ensure(stmt)
+      super **rest
+    end
+  end
+
+  class Case < Labeled
+    attr_reader :expr
+
+    def initialize(expr, stmt, **rest)
+      @expr = Syntax::Expr.ensure(expr)
+      super :case, stmt, **rest
+    end
+  end
+
+  # == 6.8.5 Iteration statements
+  class While < Stmt
+    attr_reader :condition, :body
+
+    def initialize(condition_expr, body_stmt, **rest)
+      @condition = Syntax::Expr.ensure(condition_expr)
+      @body = Syntax::Stmt::ensure(body_stmt)
+
+      super **rest
     end
   end
 
-  # == 6.8.6.4 Thereturnstatement
+  class DoWhile < Stmt
+    attr_reader :condition, :body
+
+    def initialize(condition_expr, body_stmt, **rest)
+      @condition = Syntax::Expr.ensure(condition_expr)
+      @body = Syntax::Stmt::ensure(body_stmt)
+
+      super **rest
+    end
+  end
+
+  class For < Stmt
+    attr_reader :init, :condition, :loop, :body
+
+    def initialize(init_stmt=nil, condition_expr=nil, loop_expr=nil, body_stmt, **rest)
+      @init = Syntax::BlockItem::ensure(init_stmt) if init_stmt
+      @condition = Syntax::Expr.ensure(condition_expr) if condition_expr
+      @loop = Syntax::Expr.ensure(loop_expr) if loop_expr
+      @body = Syntax::Stmt::ensure(body_stmt)
+
+      super **rest
+    end
+  end
+
+  class Goto < Stmt
+    attr_reader :label
+
+    def initialize(label, **rest)
+      @label = Syntax::Ident.ensure(label)
+      super **rest
+    end
+  end
+
+  class Continue < Stmt
+  end
+
+  class Break < Stmt
+  end
+
+  # === 6.8.6.4 The return statement
   class Return < Stmt
     attr_reader :expr
 
@@ -333,53 +1039,51 @@ module Chelsy
     end
   end
 
-  # = 6.9 External definitions
-
-  # == 6.9.1 Function definition
-
-  # Param-List ::
-  #     [] |
-  #     [:void] |
-  #     [Param] |
-  #     [Param, ..., :"..."]
-  class Param < Element
+  # 6.7 Declarations
+  class Declaration < Declarative
     attr_reader :name, :type
 
-    def initialize(name, type, register: false, **rest)
+    def initialize(name, type, init=nil, **rest)
       @name = Syntax::Ident.ensure(name)
       @type = Syntax::Type.ensure(type)
+      @init = case init
+              when nil
+                nil
+              when Enumerable
+                InitializerList.new(init)
+              else
+                Syntax::Expr.ensure(init)
+              end
 
       super(**rest)
     end
-  end
 
-  module Syntax
-    Param = Any.new('Parameter', [Param, :void, :"..."])
+    def init; @init end
   end
 
-  class ParamList < Element
-    include NodeList
+  class Typedef < Declarative
+    attr_reader :name, :type
 
-    def initialize(**rest)
-      @params = []
+    def initialize(name, type, **rest)
+      @name = Syntax::Ident.ensure(name)
+      @type = Syntax::Type.ensure(type)
+
+      rest[:storage] = :typedef
       super(**rest)
     end
-
-    private
-    def items; @params end
-    def validate_node(node); Syntax::Param.ensure(node) end
   end
 
-  class Function < Definition
+  # = 6.9 External definitions
+
+  # == 6.9.1 Function definition
+
+  class Function < Declarative
     attr_reader :name, :return_type, :params, :body
 
     def initialize(name, return_type, params, inline: false, **rest, &block)
       @name = Syntax::Ident.ensure(name)
       @return_type = Syntax::Type.ensure(return_type)
-
-      @params = ParamList.new.tap do |list|
-        params.map {|p| list << p }
-      end
+      @params = ParamList.new(params)
 
       @body = Block.new
       block.call(@body)
@@ -399,13 +1103,140 @@ module Chelsy
       def initialize(location, system: false, **rest)
         @location = location.to_s.dup
         @system = !!system
+
+        super **rest
       end
 
       # If `true`, this fragment forms `#include <...>`.
       # otherwise, this fragment forms `#include "..."`.
       def system?; @system end
     end
+
+    # `#define`
+    #
+    # - `params` - [symbol]
+    # - `replacement` - string
+    class Define < Base
+      attr_reader :name, :params, :replacement
+
+      def initialize(name, params=nil, replacement, **rest)
+        @name = Syntax::Ident.ensure(name)
+        @params = IdentList.new(params) if params
+        @replacement = Syntax::Raw.ensure(replacement)
+
+        super **rest
+      end
+    end
+
+    # `#undef`
+    class Undef < Base
+      attr_reader :name
+
+      def initialize(name, **rest)
+        @name = Syntax::Ident.ensure(name)
+        super **rest
+      end
+    end
+
+    # `#if`
+    class If < Base
+      attr_reader :condition
+
+      def initialize(condition_expr, **rest)
+        @condition = Syntax::Expr.ensure(condition_expr)
+        super **rest
+      end
+    end
+
+    # `#elif`
+    class ElseIf < Base
+      attr_reader :condition
+
+      def initialize(condition_expr, **rest)
+        @condition = Syntax::Expr.ensure(condition_expr)
+        super **rest
+      end
+    end
+
+    # `#else`
+    class Else < Base
+    end
+
+    # `#endif`
+    class EndIf < Base
+    end
+
+    # `#line`
+    #
+    #     #line digits ["filename"]
+    #
+    class Line < Base
+      attr_reader :lineno, :filename
+
+      def initialize(lineno, filename=nil, **rest)
+        @lineno = Syntax::Int.ensure(lineno)
+        @filename = Syntax::Raw.ensure(filename) if filename
+
+        super **rest
+      end
+    end
+
+    # `#pragma`
+    class Pragma < Base
+      attr_reader :pragma
+
+      def initialize(pragma, **rest)
+        @pragma = Syntax::Raw.ensure(pragma)
+        super **rest
+      end
+    end
+
+    # `STDC` pragma
+    #
+    #     #pragma STDC FP_CONTRACT on-off-switch
+    #     #pragma STDC FENV_ACCESS on-off-switch
+    #     #pragma STDC CX_LIMITED_RANGE on-off-switch
+    class StdcPragma < Pragma
+      attr_reader :name, :state
+
+      def initialize(name, state, **rest)
+        @name = Syntax::StdcPragma.ensure(name)
+        @state = Syntax::StdcPragmaState.ensure(state)
+
+        super "STDC #{name} #{state}", **rest
+      end
+    end
+
   end
 
+end
 
+module Chelsy
+  module Syntax
+    TopLevel = Any.new('TopLevel', [Declarative])
+    Type = Any.new('TypeSpecifier', [Chelsy::Type::Base, :void])
+    Raw = Any.new('Raw', [String])
+    Int = Any.new('Int', [::Integer])
+    Ident = Any.new('Identifier', [Symbol])
+    Expr = Any.new('Expression', [Chelsy::Expr, Syntax::Ident])
+    ExprOrType = Any.new('Expression-Or-Type', [Syntax::Expr, Syntax::Type])
+    Fragment = Any.new('Fragment', [Fragment, String])
+    Storage = Any.new('Storage-class specifiers', [:typedef, :extern, :static])
+    Param = Any.new('Parameter', [Chelsy::Param, :void, :"..."])
+    ProtoParam = Any.new('Prototype Parameter', [Syntax::Param, Symbol, Chelsy::Type::Base])
+    ArraySize = Any.new('ArraySize', [Syntax::Expr])
+    BitField = Any.new('BitField', [Chelsy::Constant::Integral])
+    StructOrUnionMember = Any.new('StructOrUnionMember', [Chelsy::Declaration, Chelsy::BitField])
+    EnumMember = Any.new('EnumMember', [Chelsy::EnumMember, Symbol])
+    Initializer = Any.new('Initializer', [Syntax::Expr, Chelsy::Initializer, Chelsy::InitializerList])
+    Stmt = Any.new('Statement', [
+                    Syntax::Expr, # Treats Expr as ExprStmt
+                    Chelsy::Stmt])
+    BlockItem   = Any.new('BlockItem', [
+                    Syntax::Stmt,
+                    Chelsy::Declarative])
+    Declaration = Any.new('Declaration', [Chelsy::Declaration])
+    StdcPragma = Any.new('STDC Pragma', [:FP_CONTRACT, :FENV_ACCESS, :CX_LIMITED_RANGE])
+    StdcPragmaState = Any.new('STDC Pragma State', [:ON, :OFF, :DEFAULT])
+  end
 end