rgo-lang 0.1.0

data/lib/rgo/tokenizer.rb

@@ -0,0 +1,105 @@
+require 'strscan'
+
+module Rgo
+  class Tokenizer
+    def initialize(source)
+      @source = source
+    end
+
+    def tokens
+      @q = []
+      scanner = StringScanner.new(@source)
+
+      until scanner.empty?
+        case
+          when m=scanner.scan(/\s+/)
+            blank_lines = m.count("\n") - 1
+            blank_lines.times do
+              @q.push [:BLANK_LINE, ""]
+            end
+          when m = scanner.scan(Expression::INTEGER)
+            @q.push [:INTEGER, m.to_i]
+          when m = scanner.scan(Expression::KEYWORDS)
+            @q.push [:"KEYWORD_#{m.upcase}", m]
+          when m = scanner.scan(Expression::COMMENT)
+            @q.push [:COMMENT, m[1..-1]]
+          when m = scanner.scan(Expression::STRING)
+            @q.push [:STRING, m[1..-2]]
+          when m = scanner.scan(Expression::CONSTANT)
+            @q.push [:CONSTANT, m]
+          when m = scanner.scan(Expression::IDENTIFIER)
+            @q.push [:IDENTIFIER, m]
+          when m = scanner.scan(/==/)
+            @q.push [:EQUAL, "=="]
+          when m = scanner.scan(/=/)
+            @q.push [:KEYWORD_ASSIGN, "="]
+          when m = scanner.scan(/\+/)
+            @q.push [:PLUS, "+"]
+          when m = scanner.scan(/\-/)
+            @q.push [:MINUS, "-"]
+          when m = scanner.scan(/\*/)
+            @q.push [:MULTIPLY, "*"]
+          when m = scanner.scan(/\//)
+            @q.push [:DIVIDE, "/"]
+          when m = scanner.scan(/>/)
+            @q.push [:GREATER, ">"]
+          when m = scanner.scan(/</)
+            @q.push [:LESS, "<"]
+          when m = scanner.scan(/\%/)
+            @q.push [:MOD, "%"]
+          when m = scanner.scan(/\(/)
+            @q.push [:LPAREN, "("]
+          when m = scanner.scan(/\)/)
+            @q.push [:RPAREN, ")"]
+          when m = scanner.scan(/\,/)
+            @q.push [:COMMA, ","]
+          when m = scanner.scan(/\./)
+            @q.push [:DOT, "."]
+          when m = scanner.scan(/\:/)
+            @q.push [:COLON, ":"]
+          when m = scanner.scan(Expression::INSTANCE_VARIABLE)
+            @q.push [:INSTANCE_VARIABLE, m[1..-1]]
+          when m = scanner.scan(/.|\n/)
+            @q.push [m, m]
+        end
+      end
+
+      @q.push [false, false]
+
+      @q
+    end
+
+    module Expression
+      NEWLINE = /\r\n|\n\r|\r|\n/
+
+      SPACE_1 = /[\t ]+/
+      SPACE_2 = /\\[\t ]*#{NEWLINE}/
+      #SPACE = %r(#{SPACE_1}|#{SPACE_2})
+
+      IDENTIFIER = /[a-z]\w*/
+
+      INTEGER = /[0-9]+/
+
+      BOOLEAN = /(true|false)/
+
+      # scarry comment - bad style - beward of '\' at end of line...
+      comment = /\#(?:\\[ \t]*#{NEWLINE}|[^\r\n])*/m
+      COMMENT = %r(#{comment})m
+
+      sym_1 = /\+=|\-=|\*=|\/=|%=|\&=|\^=|\|=|<<=|>>=|##|\.\.\./
+      sym_2 = /==|!=|<=|>=|->|\&\&|\|\||<<|>>|\+\+|\-\-/
+      sym_3 = /<:|:>|<%|%>|%:%:|%:/ # Digraph
+      sym_4 = /[\(\)\[\]\{\}\|\&\+\-\/\*%<>\.,=!:;\?\^~#]/
+      SYMBOL = %r(#{sym_1}|#{sym_2}|#{sym_3}|#{sym_4})
+
+      STRING = /L?"(?:\\.|[^"])*"/m
+
+      CONSTANT = /[A-Z]\w*/
+
+      INSTANCE_VARIABLE= /\@\w+/
+
+      KEYWORDS = /class|end|require|module|def|include|true|false|if|else|elsif|alias|return/
+    end # Expression
+  end
+end
+

data/lib/rgo/version.rb

@@ -0,0 +1,3 @@
+module Rgo
+  VERSION = "0.1.0"
+end

data/parse.y

@@ -0,0 +1,224 @@
+class Rgo::Parser
+  options no_result_var
+
+  prechigh
+    nonassoc UMINUS
+    left '^'
+    left '*' '/'
+    left '+' '-'
+  preclow
+
+rule
+  target
+    : statement_list
+    ;
+
+  statement_list
+    : statement
+    | statement_list statement { val }
+    ;
+
+  statement
+    : /* NONDE */
+    | comment_statement
+    | module_statement
+    | require_statement
+    | func_call
+    | func_def
+    | include_statement
+    | assignment_statement
+    | constant_assignment_statement
+    | blank_line
+    | if_statement
+    | expression_statement
+    | alias_statement
+    | return_statement
+    | class_statement
+    ;
+
+  if_statement
+    : KEYWORD_IF LPAREN expression RPAREN statement_list KEYWORD_END
+      { Node.new(:if, val[2], val[4]) }
+
+    | KEYWORD_IF LPAREN expression RPAREN statement_list KEYWORD_ELSE statement_list KEYWORD_END
+      { Node.new(:if_else, val[2], [val[4], val[6]]) }
+    ;
+
+  else_statement
+    : KEYWORD_ELSE statement_list
+
+  require_statement: KEYWORD_REQUIRE STRING { Node.new(:require, val[1]) }
+
+  module_statement
+    : KEYWORD_MODULE CONSTANT statement_list KEYWORD_END
+      { Node.new(:module, val[1], val[2]) }
+    ;
+
+  func_call: IDENTIFIER LPAREN args RPAREN { Node.new(:func_call, val[0], val[2]) }
+
+  args
+    : arg             { Array(val[0]).flatten     }
+    | args COMMA arg  { [val[0], val[2]].flatten   }
+    ;
+
+  arg
+    : none
+    | STRING      { Node.new(:string, val[0])    }
+    | IDENTIFIER  { Node.new(:variable, val[0])  }
+    | expression  { val[0] }
+    ;
+
+
+  func_def
+    : KEYWORD_DEF IDENTIFIER LPAREN func_def_args RPAREN statement_list KEYWORD_END
+      { Node.new(:func_def, val[1], [val[3], val[5]]) }
+
+    | KEYWORD_DEF IDENTIFIER LPAREN RPAREN statement_list KEYWORD_END
+      { Node.new(:func_def, val[1], [nil, val[4]]) }
+
+    | KEYWORD_DEF IDENTIFIER statement_list KEYWORD_END
+      { Node.new(:func_def, val[1], [nil, val[2]]) }
+
+    ;
+
+  func_def_args
+    : func_def_arg                      { val[0]                    }
+    | func_def_args COMMA func_def_arg  { [val[0], val[2]].flatten  }
+    ;
+
+  func_def_arg
+    : IDENTIFIER { Node.new(:variable, val[0]) }
+    ;
+
+  include_statement: KEYWORD_INCLUDE CONSTANT { Node.new(:include, val[1]) };
+
+  comment_statement: COMMENT { Node.new(:comment, val[0]) };
+
+  assignment_statement: IDENTIFIER KEYWORD_ASSIGN expression { Node.new(:assignment, val[0], [val[2]]) }
+
+  constant_assignment_statement: CONSTANT KEYWORD_ASSIGN expression { Node.new(:constant_assignment, val[0], [val[2]]) }
+
+  expression_statement
+    : expression { Node.new(:return, nil, val[0])    }
+    ;
+
+  alias_statement
+    : KEYWORD_ALIAS IDENTIFIER IDENTIFIER { Node.new(:alias, val[1], val[2]) }
+    ;
+
+  expression
+    : IDENTIFIER '(' ')'                    { val[0,3].join                             }
+    | IDENTIFIER                            { Node.new(:variable, val[0])               }
+    | STRING                                { Node.new(:string, val[0])                 }
+    | INTEGER                               { Node.new(:integer, val[0].to_i)           }
+    | boolean
+    | expression number_operator expression { Node.new(val[1], nil, [val[0], val[2]])   }
+    | CONSTANT                              { Node.new(:constant, val[0])               }
+    | func_call
+    | INSTANCE_VARIABLE                     { Node.new(:instance_variable_get,  val[0]) }
+    | class_new
+    | class_instance_method_call
+    ;
+
+
+  return_statement
+    : KEYWORD_RETURN expression { Node.new(:return, nil, val[1]) }
+    ;
+
+  class_statement
+    : KEYWORD_CLASS CONSTANT instance_variables_def methods_def KEYWORD_END
+      { Node.new(:class, val[1], [val[2], val[3]]) }
+    ;
+
+  instance_variables_def
+    : instance_variable_def
+    | instance_variables_def instance_variable_def
+      { val.flatten }
+    ;
+
+  instance_variable_def
+    : INSTANCE_VARIABLE { Node.new(:instance_variable_def, val[0]) }
+    | blank_line
+    | comment_statement
+    ;
+
+  methods_def
+    : method_def
+    | methods_def method_def
+      { val.flatten }
+    ;
+
+  method_def
+    : comment_statement
+    | func_def
+    | blank_line
+    ;
+
+
+  class_new
+    : CONSTANT DOT IDENTIFIER LPAREN arg_options RPAREN { Node.new(:class_method_call, val[0], [val[2], val[4]]) }
+    ;
+
+  arg_options
+    : arg_option
+    | arg_options COMMA arg_option { [val[0], val[2]] }
+    ;
+
+  arg_option
+    : none
+    | IDENTIFIER COLON expression { [val[0], val[2]] }
+    ;
+
+  class_instance_method_call
+    : IDENTIFIER DOT IDENTIFIER LPAREN args RPAREN { Node.new(:class_instance_method_call, val[0], [val[2], val[4]]) }
+
+  number_operator
+    : PLUS      { :plus      }
+    | MINUS     { :minus     }
+    | MULTIPLY  { :multiply  }
+    | DIVIDE    { :divide    }
+    | GREATER   { :greater   }
+    | LESS      { :less      }
+    | EQUAL     { :equal     }
+    | MOD       { :mod       }
+    ;
+
+  boolean
+    : KEYWORD_TRUE  { Node.new(:boolean, true) }
+    | KEYWORD_FALSE { Node.new(:boolean, false) }
+    ;
+
+  blank_line: BLANK_LINE { Node.new(:blank_line, "") }
+
+  none
+    : /* NONE */
+    ;
+end
+
+---- header ----
+
+require 'strscan'
+require_relative './tokenizer.rb'
+require_relative './node.rb'
+
+---- inner ----
+
+def parse(str)
+  @q = Tokenizer.new(str).tokens
+
+  do_parse
+end
+
+def next_token
+  @q.shift
+end
+
+def on_error(error_token_id, error_value, value_stack)
+  token_name = token_to_str(error_token_id)
+  token = error_value.to_s.inspect
+
+  str = 'parse error on '
+  str << token_name << ' ' unless token_name == token
+  str << token
+  raise str
+end

data/rgo.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/rgo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rgo-lang"
+  spec.version       = Rgo::VERSION
+  spec.authors       = ["Mohsen Alizadeh"]
+  spec.email         = ["mohsen@alizadeh.us"]
+
+  spec.summary       = %q{ruby like programming langauge}
+  spec.description   = %q{syntax by Ruby, performance by Go}
+  spec.homepage      = "https://github.com/mohsen-alizadeh/rgo-lang"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"]     = spec.homepage
+  spec.metadata["source_code_uri"]  = "https://github.com/mohsen-alizadeh/rgo-lang"
+  spec.metadata["changelog_uri"]    = "https://github.com/mohsen-alizadeh/rgo-lang"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "racc", "~> 1.4.16"
+end

data/samples/1_hello_world.go

@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+  fmt.Println("hello world")
+}

data/samples/1_hello_world.rgo

@@ -0,0 +1,7 @@
+module Main
+  include Fmt
+
+  def main
+    println("hello world")
+  end
+end

data/samples/3_variables.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+  // string
+  var a = "mohsen"
+  fmt.Println(a)
+
+  // integer
+  var b = 9
+  fmt.Println(b)
+
+  // boolean
+  var d = true
+  fmt.Println(d)
+}

data/samples/3_variables.rgo

@@ -0,0 +1,17 @@
+module Main
+  include Fmt
+
+  def main
+    # string
+    a = "mohsen"
+    println(a)
+
+    # integer
+    b = 9
+    println(b)
+
+    # boolean
+    d = true
+    println(d)
+  end
+end

data/samples/4_if_else.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+    if 7 % 2 == 0 {
+    fmt.Println("7 is even")
+  }
+
+    if 7 % 2 == 0 {
+    fmt.Println("7 is even")
+  } else {
+    fmt.Println("7 is odd")
+  }
+}

data/samples/4_if_else.rgo

@@ -0,0 +1,15 @@
+module Main
+  include Fmt
+
+  def main
+    if (7%2 == 0)
+      println("7 is even")
+    end
+
+    if (7%2 == 0)
+      println("7 is even")
+    else
+      println("7 is odd")
+    end
+  end
+end