special-giggle 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51b322e0b69121f5f57d8b7a514783d86dc33d06c7e81b59b33c36129f06741b
+  data.tar.gz: f74f42bb454c31cf959493f856904eb969fcc58aa19ab3fb0bb231c7d1883c3f
+SHA512:
+  metadata.gz: 7064c01e544f59f15b46dd552ead4eba0a1b36b2a9dc854f1f57af40e98bbb20abc824d261411aa308bee06bf6ea740387141b61cbc6a130ca627e676a5e40fb
+  data.tar.gz: a08e189d09bf5d5f4b7f003fff659cc4229a7ca6f2461f668e9b0332a4b2e22b07971fb879e7607abf1b6dfbafe9bf66812da393f4530436826a3b89739d8e21

data/.gitignore

@@ -0,0 +1,7 @@
+/pkg/
+/tmp/
+
+# Unit test
+/test/*/*/*.s
+/test/*/*/*.o
+/test/*/*/*.bin

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+TODO

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in special-giggle.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    special-giggle (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    irb (1.0.0)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  irb (~> 1.0)
+  rake (~> 10.0)
+  special-giggle!
+
+BUNDLED WITH
+   2.0.2

data/README.md

@@ -0,0 +1,51 @@
+# SpecialGiggle (Under Development)
+
+Compiler for BX language, written fully in Ruby
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for more details
+
+## Specification
+
+See [SPECIFICATION.md](SPECIFICATION.md) for details
+
+## Version Convention
+
+- Patch 0.0.x: Implementation level changes, such as bugfixes
+- Minor 0.x.0: Backwards compatible API changes, such as new functionality and feature
+- Major x.0.0: Backwards incompatible API changes, such as changes that will break existing codes
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'special-giggle'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install special-giggle
+
+## Usage
+
+```ruby
+require 'special-giggle'
+
+SpecialGiggle.compile("file.bx", "file.bin")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kalari499/special-giggle.

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+# Default
+task :default => :spec
+
+# Build
+desc "Build special-giggle Gem"
+task :build do
+  sh %{gem build special-giggle.gemspec} 
+end
+
+# Unit test
+Rake::TestTask.new(:test => [:test_good, :test_bad]) do |t|
+  t.description = "Unit testing: All tests"
+end
+
+Rake::TestTask.new(:test_good) do |t|
+  t.description = "Unit testing: Good programs"
+  t.test_files = ['test/good/unit.rb']
+end
+
+Rake::TestTask.new(:test_bad) do |t|
+  t.description = "Unit testing: Bad programs - Not implemented"
+  t.test_files = []
+end
+

data/SPECIFICATION.md

@@ -0,0 +1,3 @@
+## BX Language Specification
+
+TODO

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "special-giggle"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/special-giggle.rb

@@ -0,0 +1,27 @@
+require 'special-giggle/lexer'
+require 'special-giggle/parser'
+require 'special-giggle/generator'
+
+module SpecialGiggle
+  include Lexer
+  include Parser
+  include Generator
+
+  class GiggleError < StandardError; end
+
+  def self.to_asm(string)
+    tokens = Lexer.tokenize(string)
+    ast = Parser.parse(tokens)
+    code = Generator.generate(ast)
+    code
+  end
+
+  def self.compile(infile, outfile, tmpdir = "/tmp")
+    raise GiggleError, "Input file #{infile} does not found." unless File.exist?(infile)
+    file = File.basename(infile, ".*")
+    sfile, ofile = File.expand_path("#{file}.s", tmpdir), File.expand_path("#{file}.o", tmpdir)
+    File.write(sfile, to_asm(File.read(infile)))
+    system("as --64 -o #{ofile} #{sfile}") || (raise GiggleError, "Can't compile with as")
+    system("gcc -no-pie -o #{outfile} #{ofile}") || (raise GiggleError, "Can't link with gcc")
+  end
+end

data/lib/special-giggle/generator.rb

@@ -0,0 +1,143 @@
+module Generator
+  class GeneratorError < StandardError; end
+
+  class Token
+    def initialize(type, src = nil, dst = nil)
+      @type, @src, @dst = type, src, dst
+    end
+
+    def need_imm?
+    end
+
+    def to_code
+      case @type
+      when :Print
+        [ "movq #{@src}, %rsi", "movq $__print_fmt, %rdi", "movq $0, %rax", "call printf" ]
+      when :Move
+        [ @src.is_a?(Integer) ? "movq $#{@src}, %r11" : "movq #{@src}, %r11", "movq %r11, #{@dst}" ]
+      when :Tilde
+        [ "movq #{@src}, %r11", "notq %r11", "movq %r11, #{@dst}" ]
+      when :Negative
+        [ "movq #{@src}, %r11", "negq %r11", "movq %r11, #{@dst}" ]
+      when :Plus
+        [ "movq #{@src[0]}, %r11", "movq %r11, #{@dst}", "movq #{@src[1]}, %r11", "addq %r11, #{@dst}"]
+      when :Minus
+        [ "movq #{@src[0]}, %r11", "movq %r11, #{@dst}", "movq #{@src[1]}, %r11", "subq %r11, #{@dst}"]
+      when :Asterisk
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "imulq %rcx", "movq %rax, #{@dst}" ]
+      when :Slash
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "cqo", "idivq %rcx", "movq %rax, #{@dst}" ]
+      when :Percent
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "cqo", "idivq %rcx", "movq %rdx, #{@dst}" ]
+      when :Bar
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "orq %rcx, %rax", "movq %rax, #{@dst}" ]
+      when :Ampersand
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "andq %rcx, %rax", "movq %rax, #{@dst}" ]
+      when :Caret
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "xorq %rcx, %rax", "movq %rax, #{@dst}" ]
+      when :LeftShift
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "salq %cl, %rax", "movq %rax, #{@dst}" ]
+      when :RightShift
+        [ "movq #{@src[0]}, %rax", "movq #{@src[1]}, %rcx", "sarq %cl, %rax", "movq %rax, #{@dst}" ]
+      end
+    end
+  end
+
+  BinaryOps = {
+    :Plus         => 50,
+    :Minus        => 50,
+    :Asterisk     => 60,
+    :Slash        => 60,
+    :Percent      => 60,
+    :Bar          => 10,
+    :Ampersand    => 30,
+    :Caret        => 20,
+    :LeftShift    => 40,
+    :RightShift   => 40,
+  }
+
+  UnaryOps = {
+    :Tilde        => 70,
+    :Negative     => 80,
+  }
+
+  Vars = Array.new
+
+  def self.var_temp
+    #var = "#{8 * Vars.length}(%rsp)"
+    var = "tmp_#{Vars.length}"
+    Vars << var unless Vars.include?(var)
+    var
+  end
+
+  def self.generate_expression(token)
+    if token.type == :Number
+      t = var_temp
+      [t, [Token.new(:Move, token.child[0], t)]]
+    elsif token.type == :Variable
+      [token.child[0], []]
+    elsif token.type == :Bracket
+      var, array = generate_expression(token.child[0])
+      t = var_temp
+      [t, [array, Token.new(:Move, var, t)]]
+    elsif UnaryOps.include?(token.type)
+      var, array = generate_expression(token.child[0])
+      t = var_temp
+      [t, [array, Token.new(token.type, var, t)]]
+    else
+      var1, array1 = generate_expression(token.child[0])
+      var2, array2 = generate_expression(token.child[1])
+      t = var_temp
+      [t, [array1, array2, Token.new(token.type, [var1, var2], t)]]
+    end
+  end
+
+  def self.generate_statement(token)
+    array = Array.new
+    if token.type == :Print
+      var, garray = generate_expression(token.child[0])
+      array << garray unless garray.empty?
+      array << Token.new(:Print, var)
+    elsif token.type == :Move
+      Vars << token.child[0].child[0] unless Vars.include?(token.child[0].child[0])
+      var, garray = generate_expression(token.child[1])
+      array << garray unless garray.empty?
+      array << Token.new(:Move, var, token.child[0].child[0])
+    end
+    array
+  end
+
+  def self.generate(token)
+    array = Array.new
+    token.child.each do |statement|
+      array << generate_statement(statement)
+    end
+
+    output = %{
+  .section .data
+__print_fmt:
+  .string "%ld\\n"
+
+  .section .text
+  .globl main
+  main:
+  pushq %rbp
+  movq %rsp, %rbp
+  subq <VARIABLE>, %rsp
+
+<CODE>
+  movq %rbp, %rsp
+  popq %rbp
+  movq $0, %rax
+  retq
+}
+    text = ""
+    array.flatten.each { |ops| ops.to_code.each { |line| text += " " * 2 + line + "\n" } }
+
+    Vars.length.times do |i|
+      regex = "(?<![\\w])#{Vars[i]}(?![\\w])"
+      text.gsub!(/#{regex}/, i > 0 ? "#{8*i}(%rsp)" : "(%rsp)")
+    end
+    output.gsub('<VARIABLE>', "$#{Vars.length * 8}").gsub('<CODE>', text)
+  end
+end

data/lib/special-giggle/lexer.rb

@@ -0,0 +1,62 @@
+module Lexer
+  class LexerError < StandardError; end
+
+  class Token
+    attr_reader :string, :type
+
+    def initialize(string, type)
+      @string, @type = string, type
+    end
+  end
+
+  Patterns = {
+    :Blank          => '[ \t\r]+',
+    :NewLine        => '\n+',
+    :Print          => 'print',
+    :Variable       => '[A-Za-z_][A-Za-z0-9_]*',
+    :Number         => '-?[0-9]+',
+    :Plus           => '\+',
+    :Minus          => '\-',
+    :Asterisk       => '\*',
+    :Slash          => '\/',
+    :Percent        => '\%',
+    :Bar            => '\|',
+    :Ampersand      => '\&',
+    :Caret          => '\^',
+    :Tilde          => '\~', 
+    :LeftShift      => '<<',
+    :RightShift     => '>>',
+    :Equal          => '\=',
+    :LeftBracket    => '\(',
+    :RightBracket   => '\)',
+    :SemiColon      => '\;',
+  }
+
+  def self.next_token(string, index)
+    Patterns.each do |type, pattern|
+      res = string.match(pattern, index)
+      next if res.nil?
+      return [res[0], type, res.end(0)] if res.begin(0) == index
+    end
+    [nil, nil, nil]
+  end
+
+  def self.tokenize(string)
+    tokens = Array.new
+    index, line, column = 0, 1, 1
+    while index < string.length
+      rstring, rtype, index = next_token(string, index)
+      case rtype
+      when nil
+        raise LexerError, "Unrecognized character in line #{line}, column #{column}"
+      when :Blank
+        next
+      when :NewLine
+        line, column = line + 1, 1
+      else
+        tokens << Token.new(rstring, rtype)
+      end
+    end
+    tokens
+  end
+end

data/lib/special-giggle/main.rb

@@ -0,0 +1,72 @@
+require_relative "lexer"
+require_relative "parser"
+require_relative "generator"
+
+require "optparse"
+
+def main
+  ARGV << "-h" if ARGV.empty?
+
+  options = Hash.new
+  OptionParser.new do |opts|
+    opts.banner = "Usage: ruby main.rb [options]"
+
+    opts.separator ""
+    opts.separator "Specific options:"
+
+    opts.on("-f FILE", "--file", String, "Input from file (required)") do |f|
+      options[:file] = f
+    end
+
+    opts.on("-t LANG", "--target", String, "Target language - C, Assembly (default C)") do |t|
+      options[:lang] = t
+    end
+
+    opts.on("-o FILE", "--output", String, "Output to file (default: stdout)") do |o|
+      options[:output] = o
+    end
+
+    opts.on_tail("-h", "--help","Show this message") do
+      puts opts
+      exit
+    end
+  end.parse!
+
+  abort("Missing input file. Abort.") if options[:file].nil?
+  abort("File not found. Abort.") unless File.file?(options[:file])
+
+  options[:lang] ||= "C"
+  lang = case options[:lang].downcase
+         when "c"
+           :C
+         when "assembly"
+           :S
+         else
+           abort("Language not supported. Abort.")
+         end
+
+  # Read program
+  program = File.read(options[:file])
+
+  # Lexing
+  lexer = Lexer.new
+  tokens = lexer.tokenize(program)
+
+  # Parsing
+  parser = Parser.new
+  ast = parser.parse(tokens)
+
+  # Code Generator
+  generator = Generator.new
+  code = generator.generate(ast, lang)
+
+  if options[:output]
+    File.write(options[:output], code)
+  else
+    puts code
+  end
+end
+
+if __FILE__ == $0
+  main
+end

data/lib/special-giggle/parser.rb

@@ -0,0 +1,85 @@
+module Parser
+  class ParserError < StandardError; end
+
+  class Token
+    attr_reader :type, :child
+
+    def initialize(type, *args)
+      @type, @child = type, args
+    end
+  end
+
+  BinaryOps = {
+    :Plus         => 50,
+    :Minus        => 50,
+    :Asterisk     => 60,
+    :Slash        => 60,
+    :Percent      => 60,
+    :Bar          => 10,
+    :Ampersand    => 30,
+    :Caret        => 20,
+    :LeftShift    => 40,
+    :RightShift   => 40,
+  }
+
+  UnaryOps = {
+    :Tilde        => 70,
+    :Minus        => 80,
+  }
+
+  def self.parse_expression(tokens)
+    if tokens.length == 1 && tokens[0].type == :Variable
+      Token.new(:Variable, tokens[0].string)
+    elsif tokens.length == 1 && tokens[0].type == :Number
+      Token.new(:Number, tokens[0].string.to_i)
+    elsif tokens.length >= 3 && tokens[0].type == :LeftBracket && tokens[-1].type == :RightBracket
+      Token.new(:Bracket, parse_expression(tokens[1...-1]))
+    elsif tokens.length >= 2 && UnaryOps.include?(tokens[0].type)
+      if tokens[0].type == :Minus
+        Token.new(:Negative, parse_expression(tokens[1..-1]))
+      else
+        Token.new(tokens[0].type, parse_expression(tokens[1..-1]))
+      end
+    elsif tokens.length >= 3
+      head, precedence = nil, 100
+      (tokens.length-1).downto(0) do |index|
+        token = tokens[index]
+        next if index == 0 || index == tokens.length - 1 || !BinaryOps.include?(token.type)
+        next unless precedence.nil? || precedence > BinaryOps[token.type]
+        begin
+          head = Token.new(token.type, parse_expression(tokens[0..index-1]), parse_expression(tokens[index+1..-1]))
+          precedence = BinaryOps[token.type]
+        rescue ParserError
+        end
+      end
+      raise ParserError, "Syntax error in statement: #{tokens.map(&:string).join(' ')}" if head.nil?
+      head
+    else
+      raise ParserError, "Syntax error in statement: #{tokens.map(&:string).join(' ')}"
+    end
+  end
+
+  def self.parse_statement(tokens)
+    if tokens.length >= 1 && tokens[0].type == :Print
+      Token.new(:Print, parse_expression(tokens[1..-1]))
+    elsif tokens.length >= 2 && tokens[0].type == :Variable && tokens[1].type == :Equal
+      Token.new(:Move, Token.new(:Variable, tokens[0].string), parse_expression(tokens[2..-1]))
+    else
+      raise ParserError, "Syntax error in statement: #{tokens.map(&:string).join(' ')}"
+    end
+  end
+
+  def self.parse(tokens)
+    head = Token.new(:Program)
+    statement = Array.new
+    tokens.each do |token|
+      if token.type == :SemiColon
+        head.child << parse_statement(statement)
+        statement = Array.new
+      else
+        statement << token
+      end
+    end
+    head
+  end
+end

data/lib/special-giggle/version.rb

@@ -0,0 +1,3 @@
+module SpecialGiggle
+  VERSION = "1.0.0"
+end

data/special-giggle.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "special-giggle/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "special-giggle"
+  spec.version       = SpecialGiggle::VERSION
+  spec.authors       = ["kalari499"]
+  spec.email         = ["kalari499@gmail.com"]
+
+  spec.summary       = "BX language compiler written in Ruby"
+  spec.homepage      = "https://github.com/kalari499/special-giggle"
+  spec.license       = "MIT"
+
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  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 "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "irb", "~> 1.0"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: special-giggle
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- kalari499
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- kalari499@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- SPECIFICATION.md
+- bin/console
+- bin/setup
+- lib/special-giggle.rb
+- lib/special-giggle/generator.rb
+- lib/special-giggle/lexer.rb
+- lib/special-giggle/main.rb
+- lib/special-giggle/parser.rb
+- lib/special-giggle/version.rb
+- special-giggle.gemspec
+homepage: https://github.com/kalari499/special-giggle
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/kalari499/special-giggle/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: BX language compiler written in Ruby
+test_files: []