electr 0.0.2

data/lib/electr/ast/func_args_ast.rb

@@ -0,0 +1,11 @@
+module Electr
+
+  class FuncArgsAST < AST
+
+    def initialize
+      super("funcargs")
+    end
+
+  end
+end
+

data/lib/electr/ast/func_ast.rb

@@ -0,0 +1,12 @@
+module Electr
+
+  class FuncAST < AST
+
+    def initialize
+      super("func")
+    end
+
+  end
+end
+
+

data/lib/electr/ast/func_name_ast.rb

@@ -0,0 +1,14 @@
+module Electr
+
+  class FuncNameAST < AST
+
+    def initialize(value)
+      super("funcname")
+      @value = value
+    end
+
+  end
+end
+
+
+

data/lib/electr/ast/numeric_ast.rb

@@ -0,0 +1,13 @@
+module Electr
+
+  class NumericAST < AST
+
+    def initialize(value)
+      super("numeric")
+      @value = value
+    end
+
+  end
+end
+
+

data/lib/electr/ast/operator_ast.rb

@@ -0,0 +1,13 @@
+module Electr
+
+  class OperatorAST < AST
+
+    def initialize(value)
+      super("operator")
+      @value = value
+    end
+
+  end
+end
+
+

data/lib/electr/ast/root_ast.rb

@@ -0,0 +1,11 @@
+module Electr
+
+  class RootAST < AST
+
+    def initialize
+      super("root")
+    end
+
+  end
+end
+

data/lib/electr/ast/value_ast.rb

@@ -0,0 +1,12 @@
+module Electr
+
+  class ValueAST < AST
+
+    def initialize(value)
+      super("value")
+      @value = value
+    end
+
+  end
+end
+

data/lib/electr/compiler.rb

@@ -0,0 +1,24 @@
+module Electr
+
+  class Compiler
+
+    def compile_to_ast(code)
+      units = []
+      tokenizer = Tokenizer.new(code)
+      lexer = Lexer.new
+      while tokenizer.has_more_token?
+        units << lexer.lexify(tokenizer.next_token)
+      end
+
+      syntaxer = Syntaxer.new(units.dup)
+      ast = syntaxer.run
+    end
+
+    # To Prefix Notation.
+    def compile_to_pn(code)
+      ast = compile_to_ast(code)
+      ast.to_pn
+    end
+
+  end
+end

data/lib/electr/evaluator.rb

@@ -0,0 +1,64 @@
+module Electr
+
+  class Evaluator
+
+    def initialize
+      @stack = []
+    end
+
+    def evaluate_pn(list)
+      while item = list.pop
+        case item.name
+        when "numeric" then @stack.push(item.value.to_f)
+        when "constant" then @stack.push(constant(item.value))
+        when "value" then do_value(item.value)
+        when "operator" then operation(item.value)
+        when "funcname" then func(item.value)
+        end
+      end
+
+      @stack.pop
+    end
+
+    private
+
+    def constant(value)
+      case value
+      when "pi" then Math::PI
+      end
+    end
+
+    def func(name)
+      case name
+      when "sqrt"
+        a = @stack.pop
+        @stack.push(Math::sqrt(a))
+      end
+    end
+
+    def operation(operand)
+      a = @stack.pop
+      b = @stack.pop
+      @stack.push(a.send(operand, b))
+    end
+
+    def do_value(str)
+      # FIXME It's going to be better to separate the check for the unit
+      # (ohm, volt, ampere, etc) and for the prefix ([m]illi, [k]ilo,
+      # etc).
+      val = str.to_f
+      if %w( k K ).include?(str[-1]) || %w( kΩ ).include?(str[-2..-1])
+        val *= 1_000
+      elsif %w( mA mV mW ).include?(str[-2..-1])
+        val *= 0.001
+      elsif %w( u μ ).include?(str[-1]) || %w( μF uF ).include?(str[-2..-1])
+        val *= 0.000_001
+      elsif str[-1] == 'p' || str[-2..-1] == 'pF'
+        val *= 0.000_000_001
+      end
+      @stack.push(val)
+    end
+
+  end
+
+end

data/lib/electr/exceptions.rb

@@ -0,0 +1,6 @@
+module Electr
+
+  class SyntaxError < StandardError
+  end
+
+end

data/lib/electr/option.rb

@@ -0,0 +1,70 @@
+module Electr
+
+  # Process command line switches.
+  #
+  # The keys you are going to use:
+  #
+  # :ast        - Boolean, if true the user want to print the Abstract
+  #               Syntax Tree instead of the result.
+  # :expression - Don't run interactively, parse this String and quit.
+  #
+  # Examples
+  #
+  #   opt = Option.new
+  #   if opt[:expression]
+  #     puts "Doing the job with #{opt[:expression]}"
+  #   end
+  class Option
+
+    # Creates a new Option instance.
+    def initialize
+      @options = { ast: false }
+
+      optparse = OptionParser.new {|opts| parse(opts) }
+
+      begin
+        optparse.parse!
+      rescue OptionParser::InvalidOption => exception
+        puts exception.to_s
+        exit 1
+      end
+
+      print_version if @options[:version]
+    end
+
+    # Get an option.
+    #
+    # key - The Symbol name of the option to get.
+    #
+    # Returns Any value corresponding of the key, or nil if the key
+    #   doesn't exists.
+    def [](key)
+      @options[key]
+    end
+
+    def parse(opts)
+      opts.on(nil, '--ast', 'Display AST and quit') do
+        @options[:ast] = true
+      end
+      opts.on('-e', '--expression EXP', 'Compute EXP and quit') do |arg|
+        @options[:expression] = arg
+      end
+      opts.on('-v', '--version', 'Print version number and exit') do
+        @options[:version] = true
+      end
+      opts.on('-h', '--help', 'Display this screen') do
+        puts opts
+        exit
+      end
+    end
+
+    private
+
+    def print_version
+      puts "Electr version #{VERSION}"
+      exit
+    end
+
+  end
+
+end

data/lib/electr/parser.rb

@@ -0,0 +1,5 @@
+require "electr/parser/tokenizer"
+require "electr/parser/lexer"
+require "electr/parser/lexical_unit"
+require "electr/parser/syntaxer"
+require "electr/parser/sya"

data/lib/electr/parser/lexer.rb

@@ -0,0 +1,50 @@
+module Electr
+
+  class Lexer
+
+    # Public: Build a LexicalUnit from a given token.
+    #
+    # token - A String token to transform in LexicalUnit.
+    #
+    # Returns a LexicalUnit.
+    def lexify(token)
+      if numeric?(token)
+        LexicalUnit.numeric(token)
+      elsif operator?(token)
+        LexicalUnit.operator(token)
+      elsif constant?(token)
+        LexicalUnit.constant(token)
+      elsif value?(token)
+        LexicalUnit.value(token)
+      elsif token == '('
+        LexicalUnit.open_parenthesis()
+      elsif token == ')'
+        LexicalUnit.closed_parenthesis()
+      elsif SYMBOL_TABLE[token] == 'f'
+        LexicalUnit.fname(token)
+      else
+        LexicalUnit.name(token)
+      end
+    end
+
+    private
+
+    def numeric?(token)
+      token =~ /[0-9.]\Z/
+    end
+
+    def operator?(token)
+      %w( + - / ).include?(token)
+    end
+
+    def constant?(token)
+      %w( pi ).include?(token)
+    end
+
+    def value?(token)
+      # The unit part is redondant with Tokenizer.
+      token =~ /[0-9.][kKRuFpΩμAmWV]{1,}\Z/
+    end
+
+  end
+end

data/lib/electr/parser/lexical_unit.rb

@@ -0,0 +1,67 @@
+module Electr
+
+  class LexicalUnit
+
+    private_class_method :new
+
+    attr_reader :type, :value
+
+    # type  - Symbol
+    # value - String
+    def initialize(type, value)
+      @type = type
+      @value = value
+    end
+
+    def self.numeric(value)     ; new(:numeric, value)          ; end
+    def self.operator(value)    ; new(:operator, value)         ; end
+    def self.constant(value)    ; new(:constant, value)         ; end
+    def self.value(value)       ; new(:value, value)            ; end
+    def self.name(value)        ; new(:name, value)             ; end
+    def self.fname(value)       ; new(:fname, value)            ; end
+    def self.fcall(value)       ; new(:fcall, value)            ; end
+    def self.open_parenthesis   ; new(:open_parenthesis, "(")   ; end
+    def self.closed_parenthesis ; new(:closed_parenthesis, ")") ; end
+
+    def ==(other)
+      @type == other.type && @value == other.value
+    end
+
+    def numeric?
+      @type == :numeric
+    end
+
+    def operator?
+      @type == :operator
+    end
+
+    def constant?
+      @type == :constant
+    end
+
+    def value?
+      @type == :value
+    end
+
+    def fname?
+      @type == :fname
+    end
+
+    def fcall?
+      @type == :fcall
+    end
+
+    def number?
+      numeric? || constant? || value?
+    end
+
+    def closed_parenthesis?
+      @type == :closed_parenthesis
+    end
+
+    def open_parenthesis?
+      @type == :open_parenthesis
+    end
+
+  end
+end

data/lib/electr/parser/rules/base_rule.rb

@@ -0,0 +1,60 @@
+module Electr
+
+  class BaseRule
+
+    # Initialize a new rule. The units and ast_node objects
+    # given in arguments will be modified by #apply!.
+    #
+    # units    - Array of LexicalUnits.
+    # ast_node - An AST object, for adding children, etc.
+    def initialize(units, ast_node)
+      @units = units
+      @ast_node = ast_node
+      @series = []
+    end
+
+    # Public: Apply the rule to the list of lexical units, creating
+    # and/or modifying the ast node. #apply! modify the units and
+    # ast_node objects given to #initialize.
+    def apply!
+      raise NotImplementedError
+    end
+
+    private
+
+    # Accepts the next lexical unit, given type match the unit type.
+    # If value is given, it has to match the unit value.
+    #
+    # type  - Expected Symbol type of the next unit.
+    # value - Expected String value of the next unit. Default is the
+    #         empty string, meaning the value doesn't matter.
+    #
+    # Returns nothing.
+    # Raises SyntaxError if type or value doesn't match.
+    def accept(type, value = '')
+      unit = @units.slice!(0)
+      @series << unit
+      unless unit.type == type
+        raise(SyntaxError, "Expected type : #{type}\n" +
+                           "Expected value: #{value}\n" +
+                           "Got type      : #{unit.type}\n" +
+                           "Got value     : #{unit.value}")
+      end
+      if value != ''
+        raise SyntaxError unless unit.value == value
+      end
+    end
+
+    # A shortcut method to #accept. Usefull when we have several calls
+    # to #accept. Calls #accept for each of the symbol in args.
+    #
+    # args - A series of Symbol.
+    #
+    # Returns nothing.
+    def accept_all(*args)
+      args.each {|arg| accept(arg) }
+    end
+
+  end
+end
+