chelsy 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19521bbd4533094bff5ecf162e7d6f8ff8329ced
-  data.tar.gz: 4a476989d47416c7db6050a369af9ce514139805
+  metadata.gz: 2e2b87298eca205d1b4c4783ab090559a971e749
+  data.tar.gz: f068070509af5a93eed85179a011bd9234f09f0d
 SHA512:
-  metadata.gz: 5a4d6930ec401db7fbd8916494cd521d06dafa62545e58bbcd6d19b01203e2534ff528a06d485b290ccff2300eb627ad909f20e5ff51c4f0fe830407a4b6ed81
-  data.tar.gz: f7e6be9b2e90d98b7c30a9b8278508e03f9b54dfe65f74860e6d89d900887217e65e931544ae111ccc3d6d9cdc79af1f014321c4eee1c9d0e75b547535e7a962
+  metadata.gz: a8a4defd43ff48249e937060ac12765ebd740e5a432acfcc97500136a124d4c930db949a6778d25da8b06d342bcdb8dd4da662857926d33852d63c0394fee335
+  data.tar.gz: a0b5f5c7e59a7ad34e9f49b7087f8c745240797c4008ea25ecbf4511be4aa2c6a60878aedcc7583eac32b3343fe1a2d3f9dc8fd4ce6a085fccd6c52351976b76

data/lib/chelsy/ast.rb

@@ -1,24 +1,238 @@
+require "chelsy/syntax"
+
 module Chelsy
 
   class Node
+    def initialize(**opts)
+    end
+  end
+
+  # The class must provide a method `items` and `validate_node`
+  module NodeList
+    include Enumerable
+
+    def each(&block)
+      items.each(&block)
+      self
+    end
+
+    def size; items.size end
+    def empty?; items.empty? end
+
+    def <<(node)
+      items << validate_node(node)
+      self
+    end
+  end
+
+  class Fragment < Node
   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
+
+  # `Element` can have multiple `Fragment`s
+  #
+  # - `fragments` is an instace of `FragmentList` holds `Fragment`s which stands above `Element`.
+  # - `post_fragments` holds `Fragment`s which stands below `Element`.
   class Element < Node
+    attr_reader :fragments, :post_fragments
+
+    def initialize(**rest)
+      @fragments = FragmentList.new
+      @post_fragments = FragmentList.new
+
+      super(**rest)
+    end
+  end
+
+  class Declaration < Element
+  end
+
+  class Definition < Element
+    def initialize(extern: false, static: false, **rest)
+      @extern = !!extern
+      @static = !!static
+
+      super(**rest)
+    end
+
+    def extern?; @extern end
+    def static?; @static end
+  end
+
+  class Expr < Element
+  end
+
+  class Stmt < Element
+  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)
+        @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
+      end
+    end
+
+    class Numeric < Base
+    end
+
+    # == _Bool
+    class Bool < Numeric
+    end
+
+    # == Integer types
+    class Integral < Numeric
+      def initialize(unsigned: false, **rest)
+        @unsigned = !!unsigned
+        super(**rest)
+      end
+
+      def unsigned?; @unsigned end
+    end
+
+    class Char < Integral
+    end
+
+    class Short < Integral
+    end
+
+    class Int < Integral
+    end
+
+    class Long < Integral
+    end
+
+    class LongLong < Integral
+    end
+
+    # == Real floating types
+    class Real < Numeric
+    end
+
+    class Float < Real
+    end
+
+    class Double < Real
+    end
+
+    class LongDouble < Real
+    end
+
+    # == Complex types
+    class Complex < Numeric
+    end
+
+    class FloatComplex < Complex
+    end
+
+    class DoubleComplex < Complex
+    end
+
+    class LongDoubleComplex < Complex
+    end
+
+    # == Derived types
+    class Derived < Base
+    end
+
+    class Pointer < Derived
+      attr_reader :pointee
+
+      def initialize(pointee, **rest)
+        @pointee = Syntax::Type.ensure(pointee)
+        super(**rest)
+      end
+    end
+
+    class Array < Derived
+      attr_reader :element_type, :size
+
+      def initialize(element_type, size = nil, **rest)
+        @element_type = element_type
+        @size = size
+
+        super(**rest)
+      end
+
+      # An array type of unknown size is an incomplete type.
+      def incomplete?; @size.nil? end
+    end
+
+    # TODO Function
+    # TODO Struct
+    # TODO Union
   end
 
+  module Syntax
+    Type = Any.new('TypeSpecifier', [Chelsy::Type::Base, :void])
+  end
+
+  # 6.4.4.1 Integer constants
   module Constant
+    class Base < Expr
+    end
 
-    class Integral < Element
+    class Integral < Base
       attr_reader :value, :base
 
-      def initialize(value, unsigned: false, base: 10)
+      def initialize(value, unsigned: false, base: 10, **rest)
         @value = value
-        @unsigned = unsigned
+        @unsigned = !!unsigned
         @base = base
+
+        super(**rest)
       end
 
       def unsigned?
-        !!@unsigned
+        @unsigned
       end
     end
 
@@ -33,4 +247,165 @@ module Chelsy
 
   end
 
+  # 6.4.5 String literals
+  module Constant
+
+    class String < Base
+      attr_reader :value
+
+      def initialize(str, wide: false, **rest)
+        @value = str.dup.freeze
+        @wide = !!wide
+
+        super(**rest)
+      end
+
+      def wide?
+        @wide
+      end
+    end
+
+  end
+
+  # 6.5.2.2 Function calls
+  class FunctionCall < Expr
+    attr_reader :callee, :args
+
+    def initialize(callee, args, **rest)
+      @callee = Syntax::Expr.ensure(callee)
+      @args = args.map {|a| Syntax::Expr.ensure(a) }
+
+      super(**rest)
+    end
+  end
+
+  # = 6.8 Statements and blocks
+
+  # == 6.8.3 Expression and null statements
+
+  # A null statement (consisting of just a semicolon) performs no operations.
+  class EmptyStmt < Stmt
+  end
+
+  class ExprStmt < Stmt
+    attr_reader :expr
+
+    def initialize(expr, **rest)
+      @expr = Syntax::Expr.ensure(expr)
+
+      super(**rest)
+    end
+  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(item)
+    end
+  end
+
+  # == 6.8.6.4 Thereturnstatement
+  class Return < Stmt
+    attr_reader :expr
+
+    def initialize(expr=nil, **rest)
+      @expr = Syntax::Expr.ensure(expr) if expr
+
+      super(**rest)
+    end
+  end
+
+  # = 6.9 External definitions
+
+  # == 6.9.1 Function definition
+
+  # Param-List ::
+  #     [] |
+  #     [:void] |
+  #     [Param] |
+  #     [Param, ..., :"..."]
+  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
+    Param = Any.new('Parameter', [Param, :void, :"..."])
+  end
+
+  class ParamList < Element
+    include NodeList
+
+    def initialize(**rest)
+      @params = []
+      super(**rest)
+    end
+
+    private
+    def items; @params end
+    def validate_node(node); Syntax::Param.ensure(node) end
+  end
+
+  class Function < Definition
+    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
+
+      @body = Block.new
+      block.call(@body)
+
+      super(**rest)
+    end
+  end
+
+  # = 6.10 Preprocessing directives
+  module Directive
+    class Base < Fragment
+    end
+
+    class Include < Base
+      attr_reader :location
+
+      def initialize(location, system: false, **rest)
+        @location = location.to_s.dup
+        @system = !!system
+      end
+
+      # If `true`, this fragment forms `#include <...>`.
+      # otherwise, this fragment forms `#include "..."`.
+      def system?; @system end
+    end
+  end
+
+
 end

data/lib/chelsy/syntax.rb

@@ -0,0 +1,37 @@
+module Chelsy; end
+
+# Syntax rules
+module Chelsy::Syntax
+
+  class Rule
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.dup
+    end
+
+    def accept?(node)
+      false
+    end
+
+    def ensure(node)
+      if accept?(node)
+        node
+      else
+        raise ArgumentError, "#{node.class.name} is not one of #{@name}"
+      end
+    end
+  end
+
+  class Any < Rule
+    def initialize(name, classes)
+      @classes = classes
+      super name
+    end
+
+    def accept?(node)
+      @classes.any? {|klass| klass === node }
+    end
+  end
+
+end

data/lib/chelsy/translator.rb

@@ -1,31 +1,245 @@
 module Chelsy
 
   class Translator
+    attr_accessor :indent_string, :indent_level
+
+    DEFAULT_INDENT_STRING = '    '.freeze
+
+    def initialize()
+      @indent_string = DEFAULT_INDENT_STRING
+      @indent_level = 0
+    end
+
     def translate(node)
       case node
+      when Element
+        translate_element(node)
+      when Node
+        translate_node(node)
+      when Symbol
+        translate_ident(node)
+      when String
+        translate_fragment(node)
+      else
+        raise ArgumentError, "Unrecognized AST node: #{node.inspect}"
+      end
+    end
+
+    protected
+
+    def translate_node(node)
+      case node
+      # Fragment
+      when Fragment
+        translate_fragment(node)
+      else
+        raise ArgumentError, "Unrecognized AST node: #{node.inspect}"
+      end
+    end
+
+    def translate_fragment(node)
+      case node
+      when String
+        node.to_s
+      when Directive::Include
+        translate_include(node)
+      else
+        raise ArgumentError, "Unrecognized AST fragment: #{node.inspect}"
+      end
+    end
+
+    def translate_element(node)
+      case node
+      # Document
+      when Document
+        translate_document(node)
+
+      # Types
+      when Type::Base
+        translate_type(node)
+
+      # Expressions
       when Constant::Integral
         translate_integral(node)
+      when Constant::String
+        translate_string(node)
+      when FunctionCall
+        translate_function_call(node)
+
+      # Statements
+      when EmptyStmt
+        translate_empty_stmt(node)
+      when ExprStmt
+        translate_expr_stmt(node)
+      when Return
+        translate_return(node)
+      when Block
+        translate_block(node)
+
+      # Definition
+      when Function
+        translate_function(node)
+      when Param
+        translate_function_param(node)
+
       else
-        raise "Unrecognized AST node: #{node}"
+        raise ArgumentError, "Unrecognized AST element: #{node.inspect}"
+      end
+      .tap do |src|
+        # Fragments
+        unless node.fragments.empty?
+          src.insert 0, "\n"
+          src.insert 0, node.fragments.map {|f| translate_fragment(f) }.join("\n")
+        end
+        unless node.post_fragments.empty?
+          src << "\n"
+          src << node.post_fragments.map {|f| translate_fragment(f) }.join("\n")
+        end
       end
     end
 
-    protected
+    def translate_document(node)
+      node.map {|nd| translate(nd) }.join('')
+    end
+
+    def translate_ident(node)
+      node.to_s
+    end
+
+    # = Types
+
+    def translate_type(ty)
+      translate_typed_name(ty)
+    end
+
+    def translate_typed_name(ty, name=nil)
+      case ty
+      when Type::Derived
+        # TODO
+        raise NotImplementedError
+      else
+        translate_primitive_type(ty).tap do |src|
+          src << " #{name}" if name
+        end
+      end
+    end
+
+    def translate_primitive_type(ty)
+      case ty
+      when :void; 'void'
+      when Type::Char; 'char'
+      when Type::Short; 'short'
+      when Type::Integral
+        translate_integral_type(ty)
+      end.tap do |src|
+        # qualifiers
+        src.insert(0, 'const ') if ty.const?
+        src.insert(0, 'volatile ') if ty.volatile?
+        src.insert(0, 'restrict ') if ty.restrict?
+      end
+    end
+
+    def translate_integral_type(ty)
+      case ty
+      when Type::Char;     'char'
+      when Type::Short;    'short'
+      when Type::Int;      'int'
+      when Type::Long;     'long'
+      when Type::LongLong; 'long long'
+      end.tap do |src|
+        src.insert(0, 'unsigned ') if ty.unsigned?
+      end
+    end
+
+    # = Expressions
 
     def translate_integral(node)
       integer_prefix(node) + node.value.to_s(node.base) + integer_suffix(node)
     end
 
+    def translate_string(node)
+      if node.wide?
+        'L' + node.value.dump
+      else
+        node.value.dump
+      end
+    end
+
+    def translate_function_call(node)
+      callee = expr(node.callee)
+      args = node.args.map {|a| expr(a) }.join(', ')
+
+      "#{callee}(#{args})"
+    end
+
+    # = Statements
+
+    def translate_empty_stmt(node)
+      indent << ';'
+    end
+
+    def translate_expr_stmt(node)
+      indent << translate(node.expr) << ';'
+    end
+
+    def translate_return(node)
+      if node.expr
+        indent << 'return ' << translate(node.expr) << ';'
+      else
+        indent << 'return;'
+      end
+    end
+
+    def translate_block(node)
+      @indent_level += 1
+      body = node.map {|item| translate(item) }.join("\n")
+      @indent_level -= 1
+
+      "#{indent}{\n#{body}\n#{indent}}"
+    end
+
+    # = Directives
+    def translate_include(node)
+      if node.system?
+        "#include <#{node.location}>"
+      else
+        %Q{#include "#{node.location}"}
+      end
+    end
+
+    # = Statements
+
+    def translate_function(node)
+      params = node.params.map {|p| translate(p) }.join(', ')
+      "#{translate node.return_type} #{translate node.name}(#{params}) #{translate(node.body)}"
+    end
+
+    def translate_function_param(node)
+      translate_typed_name(node.type, node.name)
+    end
+
     private
 
+    def indent
+      @indent_string * @indent_level
+    end
+
+    # Expression: parenthesize if needed
+    def expr(node)
+      # TODO Pointer expression should be parenthesized.
+      translate(node)
+    end
+
     def integer_prefix(node)
       case node.base
-      when 16
-        "0x"
       when 8
         "0"
-      else
+      when 10
         ""
+      when 16
+        "0x"
+      else
+        raise ArgumentError, "Unsupported radix: #{node.base}"
       end
     end
 

data/lib/chelsy/version.rb

@@ -1,3 +1,3 @@
 module Chelsy
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/sample/hello_chelsy.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(void) {
+    printf("Hello, Chelsy!\n");
+    return 0;
+}

data/sample/hello_chelsy.rb

@@ -0,0 +1,15 @@
+require 'chelsy'
+
+include Chelsy
+
+doc = Document.new
+
+doc.fragments << Directive::Include.new("stdio.h", system: true)
+doc.fragments << ''
+
+doc << Function.new(:main, Type::Int.new, [:void]) do |b|
+  b << FunctionCall.new(:printf, [Constant::String.new("Hello, Chelsy!\n")])
+  b << Return.new(Constant::Int.new(0))
+end
+
+puts Translator.new.translate(doc)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chelsy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Takanori Ishikawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,8 +84,11 @@ files:
 - chelsy.gemspec
 - lib/chelsy.rb
 - lib/chelsy/ast.rb
+- lib/chelsy/syntax.rb
 - lib/chelsy/translator.rb
 - lib/chelsy/version.rb
+- sample/hello_chelsy.c
+- sample/hello_chelsy.rb
 homepage: https://github.com/ishikawa/chelsy
 licenses:
 - MIT