salt 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58f8fcc6218bf972ee729572931f84d819e54214
+  data.tar.gz: 8fbc92ec6384e78234ef79a4f9731d3474cb436a
+SHA512:
+  metadata.gz: e2641e9c27e20e4dd0999df7b95222e594235766d75e6f44ab17d6f8a992cb6214e507e80896694ea44cb81ca0b3c96e14606a602284fbd24e0f42d5cfa76174
+  data.tar.gz: bac7d1f1d90c12c68234e1acbcb16a33faee963a74ea70922dbb8779c8ebe579112e9df63ca7a78b28546880bc1aefb92ca5857c4ce9620c04aa8c976b3f2f05

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+lib/salt/parser.err
+lib/salt/parser.inf

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,11 @@
+require: rubocop-rspec
+
+AllCops:
+  Exclude:
+    - 'lib/salt/parser.rb'
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/SignalException:
+  EnforcedStyle: only_raise

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+script: bundle exec rspec -f d spec
+sudo: false
+cache: bundler

data/.yardopts

@@ -0,0 +1,6 @@
+--protected
+--private
+-m markdown
+-
+LICENSE.txt
+README.md

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    salt (0.0.1)
+      command-runner (~> 0.9)
+      commander
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.0.0)
+    astrolabe (1.3.0)
+      parser (>= 2.2.0.pre.3, < 3.0)
+    command-runner (0.9.3)
+      hashie (~> 3.3)
+      promise
+    commander (4.3.0)
+      highline (~> 1.6.11)
+    diff-lcs (1.2.5)
+    hashie (3.4.0)
+    highline (1.6.21)
+    parser (2.2.0.3)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.0)
+    promise (0.3.1)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    rubocop (0.29.1)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.0.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    rubocop-rspec (1.2.2)
+    ruby-progressbar (1.7.1)
+
+PLATFORMS
+  x64-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  rake (~> 10.0)
+  rspec (~> 3.1)
+  rubocop
+  rubocop-rspec
+  salt!

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jeremy Rodi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,2 @@
+# salt
+Sane Alternative Language To C

data/Rakefile

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)

data/bin/salt

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'salt'
+
+Salt::CLI.new.run

data/lib/salt.rb

@@ -0,0 +1,19 @@
+require 'salt/version'
+require 'salt/scanner'
+require 'salt/parser'
+require 'salt/compiler'
+require 'salt/walker'
+require 'salt/cli'
+
+module Salt
+  def parse(path)
+    parse_string(File.read(path))
+  end
+
+  def parse_string(string, source = '(eval)')
+    tokens = Scanner.scan(string, source)
+    ast = Parser.parse(tokens)
+  end
+
+  module_function :parse, :parse_string
+end

data/lib/salt/cli.rb

@@ -0,0 +1,40 @@
+require 'commander'
+
+module Salt
+  class CLI
+    include Commander::Methods
+
+    def run
+      program :name, 'Salt'
+      program :version, Salt::VERSION
+      program :description, 'Compiles and/or runs salt programs.'
+
+      compile_command
+      lint_command
+      run_command
+
+      run!
+    end
+
+    private
+
+    def compile_command
+      command :compile do |command|
+        command.syntax = 'salt compile'
+        command.description = 'Compiles the given file.'
+        command.option '-f STRING', '--file STRING', String,
+          'The file to compile.'
+
+        command.action do |_, options|
+          p options
+        end
+      end
+    end
+
+    def lint_command
+    end
+
+    def run_command
+    end
+  end
+end

data/lib/salt/compiler/type.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Salt
+  class Compiler
+    class Type
+      attr_reader :type
+
+      def initialize(type, clname, value)
+        @type = type
+        @clname = clname
+        @value = value
+      end
+    end
+  end
+end

data/lib/salt/generator.rb

@@ -0,0 +1,11 @@
+module Salt
+  class Generator
+    def initialize(settings)
+      @settings = settings
+    end
+
+    def generate(ast)
+      
+    end
+  end
+end

data/lib/salt/generator/main.rb

@@ -0,0 +1,7 @@
+module Salt
+  module Generator
+    module Main
+
+    end
+  end
+end

data/lib/salt/parser.ace

@@ -0,0 +1,353 @@
+%require "~> 0.1"
+%generator "ruby"
+
+%ruby.error-class SyntaxError
+%panic-mode true
+
+%terminal IDENTIFIER
+%terminal NUMBER
+%terminal UNUMBER
+%terminal FLOAT
+%terminal DOUBLE
+%terminal SNUMBER
+%terminal USNUMBER
+%terminal LNUMBER
+%terminal ULNUMBER
+%terminal LLNUMBER
+%terminal ULLNUMBER
+%terminal CHARACTER
+%terminal STRING
+%terminal FUNCTION "function"
+%terminal FUNC "func"
+%terminal CLASS "class"
+%terminal STRUCT "struct"
+%terminal UNION "union"
+%terminal CONTINUE "continue"
+%terminal BREAK "break"
+%terminal IF "if"
+%terminal ELSE "else"
+%terminal FOR "for"
+%terminal WHILE "while"
+%terminal DO "do"
+%terminal GOTO "goto"
+%terminal RETURN "return"
+%terminal TYPEDEF "typedef"
+%terminal LABEL "label"
+%terminal LBRACE "{"
+%terminal RBRACE "}"
+%terminal LPAREN "("
+%terminal RPAREN ")"
+%terminal LBRACK "["
+%terminal RBRACK "]"
+%terminal EQUALS "="
+%terminal PLUS "+"
+%terminal DPLUS "++"
+%terminal MINUS "-"
+%terminal DMINUS "--"
+%terminal DIVIDE "/"
+%terminal MOD "%"
+%terminal LSHIFT "<<"
+%terminal RSHIFT ">>"
+%terminal AMBER "&"
+%terminal CARET "^"
+%terminal STAR "*"
+%terminal COLON ":"
+%terminal DCOLON "::"
+%terminal SEMICOLON ";"
+%terminal HASH "#"
+%terminal COMMA ","
+%terminal LBRK "<"
+%terminal RBRK ">"
+%terminal COMP "=="
+%terminal NCMP "!="
+%terminal LNOT "!"
+%terminal BNOT "~"
+%terminal LAND "&&"
+%terminal LOR "||"
+%terminal BOR "|"
+
+%nonassoc STRING
+%left SDEC SINC CALL ACCESS
+%right PDEC PINC UPLUS UMINUS CAST LNOT BNOT DREF REF
+%left MULTIPLY DIVIDE MOD
+%left PLUS MINUS
+%left LSHIFT RSHIFT
+%left LBRK RBRK
+%left COMP NCMP
+%left BAND
+%left BXOR
+%left BOR
+%left LAND
+%left LOR
+%right EQUALS OEQ
+%left COMMA
+%nonassoc _
+%nonassoc RETURN
+
+%%
+
+body: parts.maybe
+      { |a| [:root, a] }
+
+preprocessor: HASH IDENTIFIER function.body SEMICOLON
+              { |_, a, b, _| [:pre, a, b] }
+
+parts.maybe: parts | nothing
+parts: parts part
+       { |a, b| a << b }
+     | part
+       { |a| [a] }
+     | type
+       { |a| [a] }
+part: function | class | struct | union | typedef | preprocessor
+
+function: FUNCTION IDENTIFIER LPAREN function.arguments.maybe RPAREN
+          COLON type LBRACE function.body RBRACE
+          { |_, a, _, b, _, _, c, _, d, _| [:func, a, b, c, d] }
+function.arguments.maybe: function.arguments | nothing
+function.arguments: function.arguments COMMA function.argument
+                    { |a, _, b| a << b }
+                  | function.argument
+function.argument: IDENTIFIER COLON type { |a, _, b| [:fnarg, a, b] }
+
+class: CLASS class.name LBRACE class.body RBRACE
+       { |_, a, _, b, _| [:class, a, b] }
+class.name: class.name DCOLON IDENTIFIER
+            { |a, _, b| a << b }
+          | IDENTIFIER
+            { |a| [:clname, a] }
+
+class.body: class.parts.maybe
+class.parts.maybe: class.parts | nothing
+class.parts: class.parts class.part
+             { |a, b| a << b }
+           | class.part
+             { |a| [a] }
+class.part: class.attribute | class.function | preprocessor
+class.attribute: IDENTIFIER COLON type SEMICOLON
+                 { |a, _, b| [:clattr, a, b] }
+class.function: FUNC IDENTIFIER LPAREN function.arguments.maybe RPAREN
+                COLON type LBRACE function.body RBRACE
+                { |_, a, _, b, _, _, c, _, d, _| [:clfunc, a, b, c, d] }
+
+struct: STRUCT class.name LBRACE struct.body RBRACE
+        { |_, a, _, b, _| [:struct, a, b] }
+struct.anon: STRUCT LBRACE struct.body RBRACE
+             { |_, _, b, _| [:struct, nil, b] }
+struct.body: struct.parts.maybe
+struct.parts.maybe: struct.parts | nothing
+struct.parts: struct.parts struct.part
+              { |a, b| a << b }
+            | struct.part
+              { |a| [a] }
+struct.part: class.attribute | preprocessor
+
+union: UNION class.name LBRACE union.body RBRACE
+       { |_, a, _, b, _| [:union, a, b] }
+union.anon: UNION LBRACE union.body RBRACE
+            { |_, _, b, _| [:union, nil, b] }
+union.body: union.parts.maybe
+union.parts.maybe: union.parts | nothing
+union.parts: union.parts union.part
+             { |a, b| a << b }
+           | union.part
+             { |a| [a] }
+union.part: class.attribute | preprocessor
+
+type: type CARET
+      { |a| [:pointer, a] }
+    | class.name
+    | struct.anon
+    | union.anon
+
+function.body: function.body.parts.maybe
+function.body.parts.maybe: function.body.parts | nothing
+function.body.parts: function.body.parts function.body.part
+                     { |a, b| a << b }
+                   | function.body.part
+                     { |a| [a] }
+function.body.part: function.body.declare SEMICOLON
+                  | function.body.expression SEMICOLON
+                  | function.body.control SEMICOLON
+                  | preprocessor
+function.body.expression: function.body.assignment
+                        | function.body.reference
+                        | function.body.call
+                        | function.body.math
+                        | function.body.literal
+                        | function.body.logic
+                        | LPAREN function.body.expression RPAREN
+                          { |_, a, _| a }
+
+function.body.declare: IDENTIFIER COLON type
+                       { |a, _, b| [:variable, a, b] }
+                     | IDENTIFIER COLON type EQUALS
+                       function.body.expression
+                       { |a, _, b, _, c| [:variable, a, b, c] }
+
+function.body.assignment: function.body.reference EQUALS
+                          function.body.expression %prec EQUALS
+                          { |a, _, b| [:assign, a, b] }
+function.body.reference: CARET function.body.expression %prec DEREF
+                         { |_, a| [:deref, a] }
+                       | AMBER function.body.expression %prec REF
+                         { |_, a| [:ref, a] }
+                       | function.body.expression LBRACK
+                         function.body.expression RBRACK %prec ACCESS
+                         { |a, _, b, _| [:brack, a, b] }
+                       | IDENTIFIER
+function.body.call: function.body.expression
+                    LPAREN function.body.call.arguments.maybe
+                    RPAREN %prec CALL
+                    { |a, _, b, _| [:call, a, b] }
+function.body.math: function.body.expression PLUS
+                    function.body.expression
+                    { |a, _, b| [:add, a, b] }
+                  | function.body.expression MINUS
+                    function.body.expression
+                    { |a, _, b| [:sub, a, b] }
+                  | function.body.expression STAR
+                    function.body.expression %prec MULTIPLY
+                    { |a, _, b| [:mult, a, b] }
+                  | function.body.expression DIVIDE
+                    function.body.expression
+                    { |a, _, b| [:div, a, b] }
+                  | function.body.expression MOD
+                    function.body.expression
+                    { |a, _, b| [:mod, a, b] }
+                  | function.body.expression LSHIFT
+                    function.body.expression
+                    { |a, _, b| [:lshift, a, b] }
+                  | function.body.expression RSHIFT
+                    function.body.expression
+                    { |a, _, b| [:rshift, a, b] }
+                  | function.body.expression DPLUS %prec SINC
+                    { |a, _| [:sinc, a] }
+                  | function.body.expression DMINUS %prec SDEC
+                    { |a, _| [:sdec, a] }
+                  | DMINUS function.body.expression %prec PINC
+                    { |_, a| [:pinc, a] }
+                  | DPLUS function.body.expression %prec PDEC
+                    { |_, a| [:pdec, a] }
+                  | PLUS function.body.expression %prec UPLUS
+                    { |_, a| [:uplus, a] }
+                  | MINUS function.body.expression %prec UMINUS
+                    { |_, a| [:uminus, a] }
+function.body.literal: NUMBER | FLOAT | DOUBLE | UNUMBER
+                     | SNUMBER | USNUMBER | LNUMBER | ULNUMBER
+                     | LLNUMBER | ULLNUMBER | CHARACTER
+                     | function.body.string
+function.body.string: function.body.string STRING
+                      { |a, b| a << b }
+                    | STRING
+                      { |a| [:strlist, a] }
+function.body.logic: LNOT function.body.expression
+                     { |_, a| [:lnot, a] }
+                   | BNOT function.body.expression
+                     { |_, a| [:bnot, a] }
+                   | function.body.expression LBRK
+                     function.body.expression
+                     { |a, _, b| [:lt, a, b] }
+                   | function.body.expression RBRK
+                     function.body.expression
+                     { |a, _, b| [:gt, a, b] }
+                   | function.body.expression LBRK
+                     EQUALS function.body.expression
+                     { |a, _, b| [:lte, a, b] }
+                   | function.body.expression RBRK
+                     EQUALS function.body.expression
+                     { |a, _, b| [:gte, a, b] }
+                   | function.body.expression COMP
+                     function.body.expression
+                     { |a, _, b| [:comp, a, b] }
+                   | function.body.expression NCMP
+                     function.body.expression
+                     { |a, _, b| [:ncmp, a, b] }
+                   | function.body.expression LAND
+                     function.body.expression
+                     { |a, _, b| [:land, a, b] }
+                   | function.body.expression AMBER
+                     function.body.expression %prec BAND
+                     { |a, _, b| [:band, a, b] }
+                   | function.body.expression LOR
+                     function.body.expression
+                     { |a, _, b| [:lor, a, b] }
+                   | function.body.expression BOR
+                     function.body.expression
+                     { |a, _, b| [:bor, a, b] }
+function.body.call.arguments.maybe: function.body.call.arguments
+                                  | nothing
+function.body.call.arguments: function.body.call.arguments COMMA
+                              function.body.call.argument
+                              { |a, _, b| a << b }
+                            | function.body.call.argument
+                              { |a| [a] }
+function.body.call.argument: function.body.expression
+
+function.body.control: control.if
+                     | control.while
+                     | control.for
+                     | control.goto
+                     | control.label
+                     | control.return
+                     | CONTINUE
+                       { [:continue] }
+                     | BREAK
+                       { [:break] }
+
+control.if: IF LPAREN function.body.expression RPAREN control.block
+            control.if.cont
+            { |_, _, a, _, b, c| [:if, a, b, c] }
+control.if.cont: ELSE IF LPAREN function.body.expression RPAREN
+                 control.block control.if.cont
+                 { |_, _, _, a, _, b, c| [:elif, a, b, c] }
+               | ELSE control.block
+                 { |_, a| [:else, a] }
+control.while: WHILE LPAREN function.body.expression RPAREN
+               control.block
+               { |_, _, a, _, b| [:while, a, b] }
+             | DO control.block WHILE LPAREN function.body.expression
+               { |_, b, _, _, a| [:rwhile, a, b] }
+control.for: FOR LPAREN control.for.compound SEMICOLON
+             function.body.expression SEMICOLON control.for.compound
+             RPAREN control.block
+             { |_, _, a, _, b, _, c, _, d| [:for, a, b, c, d] }
+# for now, ignore a comma-seperated list
+control.for.compound: function.body.expression
+control.goto: GOTO IDENTIFIER
+              { |_, a| [:goto, a] }
+control.label: LABEL IDENTIFIER COLON function.body.expression
+               { |_, a, _, b| [:label, a, b] }
+control.return: RETURN function.body.expression
+                { |_, a| [:return, a] }
+              | RETURN SEMICOLON
+                { [:return] }
+control.block: function.body.expression
+             | LBRACE function.body RBRACE
+
+typedef: typedef.type | typedef.func
+
+# newtype: oldtype
+typedef.type: TYPEDEF class.name COLON type SEMICOLON
+              { |_, a, _, b, _| [:type, a, b] }
+typedef.func: TYPEDEF class.name LPAREN
+              function.arguments.maybe RPAREN COLON type SEMICOLON
+              { |*a| [:typefn, a[1], a[3], a[6]] }
+            | TYPEDEF class.name CARET LPAREN
+              function.arguments.maybe RPAREN COLON type SEMICOLON
+              { |*a| [:typefnp, a[1], a[4], a[7]] }
+%%
+
+module Salt
+  class Parser
+    %{write}
+
+    def self.parse(tokens)
+      new.parse(tokens)
+    end
+
+    def type(token)
+      token.type
+    end
+  end
+end