salt 0.0.2

data/lib/salt/scanner.rb

@@ -0,0 +1,143 @@
+require 'forwardable'
+require 'salt/scanner/main'
+require 'salt/scanner/token'
+
+module Salt
+  # Scans a given input.
+  #
+  # @see http://ruby-doc.org/stdlib-2.1.2/libdoc/strscan/rdoc/StringScanner.html
+  class Scanner
+    extend Forwardable
+    include Main
+
+    # An array of the tokens that the scanner scanned.
+    #
+    # @return [Array<Token>]
+    attr_reader :tokens
+
+    # Scans a file.  It returns the tokens resulting from scanning.
+    #
+    # @param source [String] the source to scan.  This should be
+    #   compatible with StringScanner.
+    # @param name [String] the name of the source file.  This is
+    #   primarily used in backtrace information.
+    # @return [Array<Token>]
+    # @see #tokens
+    def self.scan(source, name = '(file)')
+      new(source, name).scan_file
+    end
+
+    # Initialize the scanner with the input.
+    #
+    # @param input [String] The source to scan.
+    # @param source [String] the source file.  This is primarily
+    #   used in backtrace information.
+    def initialize(input, source = '(file)')
+      @source  = source
+      @scanner = StringScanner.new(input)
+      @tokens  = []
+    end
+
+    # Scans the file in parts.
+    #
+    # @raise [SyntaxError] if the source is malformed in some way.
+    # @return [Array<Token>] the tokens that
+    #   were scanned in this file.
+    # @see #scan_first_part
+    # @see #scan_second_part
+    # @see #scan_third_part
+    # @see #tokens
+    def scan_file
+      @line = 1
+      scan
+      tokens
+    rescue SyntaxError => e
+      start = [@scanner.pos - 8, 0].max
+      stop  = [@scanner.pos + 8, @scanner.string.length].min
+      snip  = @scanner.string[start..stop].strip.inspect
+      char  = @scanner.string[@scanner.pos]
+      char  = if char
+                char.inspect
+              else
+                'EOF'
+              end
+
+      new_line = "#{@source}:#{@line}: unexpected #{char} " \
+        "(near #{snip})"
+
+      raise e, e.message, [new_line, *e.backtrace]
+    end
+
+    # Scans for whitespace.  If the next character is whitespace, it
+    # will consume all whitespace until the next non-whitespace
+    # character.
+    #
+    # @return [Boolean] if any whitespace was matched.
+    def scan_whitespace
+      @line += @scanner[1].count("\n") if @scanner.scan(/(\s+)/)
+    end
+
+    private
+
+    attr_reader :line
+
+    def column
+      @scanner.pos - (@scanner.string.rindex(/\n|\r/, @scanner.pos) || 0)
+    end
+
+    # Raises an error.
+    #
+    # @raise [SyntaxError] always.
+    # @return [void]
+    def error!
+      raise SyntaxError, 'invalid syntax'
+    end
+
+    # Matches using the scanner.  If it matches, it returns a truthy
+    # value.  If it fails to match, it returns nil.
+    #
+    # @param scan [String, Symbol, Regexp] The match.  If it is a
+    #   string or a symbol, it is turned into a regular expression
+    #   through interpolation.
+    # @return [Boolean, nil]
+    def on(scan)
+      case scan
+      when String, Symbol
+        @scanner.scan(/#{Regexp.escape(scan.to_s)}/)
+      when Regexp
+        @scanner.scan(scan)
+      else
+        raise ArgumentError, "Unexpected #{scan.class}, expected " \
+          'String, Symbol, or Regexp'
+      end
+    end
+
+    # Generates a token with the given name and values.
+    #
+    # @param name [Symbol] the name of the token.
+    # @param values [Object] the values to be part of the token.
+    # @return [Token]
+    def token(name, *values)
+      Token.new(name, values, line, column)
+    end
+
+    # Emits a token, by first generating the token, and then
+    # appending it to the token array.
+    #
+    # @see #token
+    # @param (see #token)
+    # @return [Array<Token>] The token array.
+    def emit(name, *values)
+      tokens << token(name, *values)
+    end
+
+    # The group from the last match.  It responds to #[] only.
+    #
+    # @return [#[]]
+    def group
+      @scanner
+    end
+
+    def_delegators :@scanner, :eos?
+  end
+end

data/lib/salt/scanner/main.rb

@@ -0,0 +1,134 @@
+module Salt
+  class Scanner
+    module Main
+      NUMBER = %{
+        (
+            [0-9]+
+          | 0[xX][0-9a-f]+
+          | 0b[01]+
+        )
+      }
+
+      DOUBLE = %{([0-9]+\.[0-9]+)}
+
+      def scan
+        until eos?
+          scan_keyword || scan_grouping || scan_logimath ||
+            scan_control || scan_string || scan_number ||
+            scan_identifier || scan_comment || scan_whitespace ||
+            error!
+        end
+      end
+
+      def scan_keyword
+        case
+        when on(:function) then emit(:function)
+        when on(:func)     then emit(:func)
+        when on(:class)    then emit(:class)
+        when on(:struct)   then emit(:struct)
+        when on(:union)    then emit(:union)
+        when on(:continue) then emit(:continue)
+        when on(:break)    then emit(:break)
+        when on(:if)       then emit(:if)
+        when on(:else)     then emit(:else)
+        when on(:for)      then emit(:for)
+        when on(:while)    then emit(:while)
+        when on(:do)       then emit(:do)
+        when on(:goto)     then emit(:goto)
+        when on(:return)   then emit(:return)
+        when on(:typedef)  then emit(:typedef)
+        when on(:label)    then emit(:label)
+        end
+      end
+
+      def scan_grouping
+        case
+        when on('{') then emit(:lbrace)
+        when on('}') then emit(:rbrace)
+        when on('(') then emit(:lparen)
+        when on(')') then emit(:rparen)
+        when on('[') then emit(:lbrack)
+        when on(']') then emit(:rbrack)
+        end
+      end
+
+      def scan_logimath
+        case
+        when on('++') then emit(:dplus)
+        when on('--') then emit(:dminus)
+        when on('<<') then emit(:lshift)
+        when on('>>') then emit(:rshift)
+        when on('==') then emit(:comp)
+        when on('!=') then emit(:ncmp)
+        when on('&&') then emit(:land)
+        when on('||') then emit(:lor)
+        when on('=')  then emit(:equals)
+        when on('+')  then emit(:plus)
+        when on('-')  then emit(:minus)
+        when on('/')  then emit(:divide)
+        when on('%')  then emit(:mod)
+        when on('&')  then emit(:amber)
+        when on('^')  then emit(:caret)
+        when on('*')  then emit(:star)
+        when on('<')  then emit(:lbrk)
+        when on('>')  then emit(:rbrk)
+        when on('!')  then emit(:lnot)
+        when on('~')  then emit(:bnot)
+        when on('|')  then emit(:bor)
+        end
+      end
+
+      def scan_control
+        case
+        when on('::') then emit(:dcolon)
+        when on(':')  then emit(:colon)
+        when on(';')  then emit(:semicolon)
+        when on('#')  then emit(:hash)
+        when on(',')  then emit(:comma)
+        end
+      end
+
+      def scan_string
+        case
+        when on(/\" ([^\"] | \\")* \"/)
+          emit(:string, group[1])
+        when on(/'(.)'/)
+          emit(:character, group[1])
+        end
+      end
+
+      def scan_number
+        case
+        when on(/#{NUMBER}(ull|llu)/x)
+          emit(:ullnumber, group[1])
+        when on(/#{NUMBER}(ul|lu)/x)
+          emit(:ulnumber, group[1])
+        when on(/#{NUMBER}(su|us)/x)
+          emit(:usnumber, group[1])
+        when on(/#{NUMBER}ll/x)
+          emit(:llnumber, group[1])
+        when on(/#{NUMBER}l/x)
+          emit(:lnumber, group[1])
+        when on(/#{NUMBER}s/x)
+          emit(:snumber, group[1])
+        when on(/#{NUMBER}u/x)
+          emit(:unumber, group[1])
+        when on(/#{NUMBER}/x)
+          emit(:number, group[1])
+        when on(/#{DOUBLE}f/)
+          emit(:float, group[1])
+        when on(DOUBLE)
+          emit(:double, group[1])
+        end
+      end
+
+      def scan_identifier
+        emit(:identifier, group[1]) if on(/([A-Za-z][A-Za-z0-9_]*)/)
+      end
+
+      def scan_comment
+        on(%r{//(.*?)\n})
+      end
+    end
+  end
+end

data/lib/salt/scanner/token.rb

@@ -0,0 +1,45 @@
+require 'forwardable'
+
+module Salt
+  class Scanner
+    class Token
+      attr_reader :type
+      attr_reader :values
+      attr_reader :line
+      attr_reader :column
+      extend Forwardable
+      include Comparable
+
+      def_delegators :to_a, :[]
+
+      def initialize(type, values, line = 0, column = 0)
+        @type = type.to_s.upcase.intern
+        @values = values
+        @line = line
+        @column = column
+        @array = [@type].concat(@values.clone.freeze).freeze
+        freeze
+      end
+
+      def to_a
+        @array
+      end
+
+      def inspect
+        "#<#{self.class}(#{self.type}) #{self.values.inspect}>"
+      end
+
+      def <=>(other)
+        case other
+        when Token
+          to_a <=> other.to_a
+        when Array
+          to_a <=> other
+        else
+          raise ArgumentError,
+            "Don't know how to compare Token with #{other}"
+        end
+      end
+    end
+  end
+end

data/lib/salt/version.rb

@@ -0,0 +1,3 @@
+module Salt
+  VERSION = "0.0.2"
+end

data/lib/salt/walker.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'pry'
+
+module Salt
+  # A class that is used to help walk the AST generated by Salt (or
+  # even any AST that uses arrays to define Nodes and Tokens).
+  class Walker
+    attr_reader :ast
+
+    def initialize(ast)
+      @ast = ast
+      @stack = []
+    end
+
+    def perform
+      to([@ast])
+      until @stack.empty?
+        yield self
+        @stack.shift
+      end
+    end
+
+    def on(action)
+      if action.is_a?(Hash) && action.key?(current_type)
+        action[current_type].each do |index|
+          to(current[index])
+        end
+      elsif !action.is_a?(Hash)
+        yield current[1..-1] if current_type == action
+      end
+    end
+
+    def to(sub)
+      return unless sub
+      @stack.concat(sub)
+    end
+
+    def current
+      @stack.first
+    end
+
+    def current_type
+      current[0]
+    end
+  end
+end

data/salt.gemspec

@@ -0,0 +1,30 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'salt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'salt'
+  spec.version       = Salt::VERSION
+  spec.authors       = ['Jeremy Rodi']
+  spec.email         = ['redjazz96@gmail.com']
+  spec.summary       = 'A sane alternative language to C.'
+  spec.description   = 'A sane alternative language to C.  It ' \
+                       'compiles directly to C, which then compiles.'
+  spec.homepage      = 'https://github.com/medcat/salt'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^spec\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+
+  spec.add_dependency 'toml-rb', '~> 0.3'
+  spec.add_dependency 'commander'
+end

data/spec/salt/language/scanner_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Salt::Language::Scanner do
+  let(:input) { %{function main(): int { return 0; } } }
+  let(:source) { 'test.sa' }
+  subject { described_class.scan(input, source) }
+
+  it 'generates tokens' do
+    expect(subject.any?).to be true
+    expect(subject.map(&:class).
+      all? { |_| _ == Salt::Language::Scanner::Token }).to be true
+  end
+
+  it 'properly tokenizes' do
+    expect(subject.map(&:to_a)).to eq [
+      [:FUNCTION], [:IDENTIFIER, 'main'], [:LPAREN], [:RPAREN],
+      [:COLON], [:IDENTIFIER, 'int'],
+      [:LBRACE], [:RETURN], [:NUMBER, '0'], [:SEMICOLON], [:RBRACE]
+    ]
+  end
+
+  it 'adds line and column information' do
+    expect(subject.map { |_| [_.line, _.column] }).to eq [
+      [1, 0], [1, 9], [1, 13], [1, 14], [1, 15], [1, 17], [1, 21],
+      [1, 23], [1, 30], [1, 31], [1, 33]
+    ]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'salt'
+require 'timeout'
+require 'benchmark'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end