calc_jgomez40 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 861e6c75b217b55d0b8c1d8528ecabd7c68bca79
-  data.tar.gz: d92252649fd2e65b0a698a4269791bfd8e37addd
+  metadata.gz: e5dfe1f154a350d932fe0b2f82cf4d67de86e2df
+  data.tar.gz: abe76b073ad521d809c82b39a6a8226e9d907837
 SHA512:
-  metadata.gz: 7ed00eb029dd271709cb343e095f162df3ccf29e24a8e87b18a3455ab9d14db82c2a9e86eba9ba853a2858a7e1342fc5d989869866bc1e34edb96240637a1557
-  data.tar.gz: eecce5d8f90a5382003c233d8e27f2fcf7fd9c698b41d104280816becfcb94a9a0e684bfb8a64c28485b73c57addb3bd7851f6993881d78ef153b55dd46e0d8b
+  metadata.gz: 263b0cc058f0893b2a166a656a3b5181ff44266736c03bf245493a713847d5d0586b92bbb5b7a6262e230cf46cfbd7cf26e0dcbee76480580b160028de8c5679
+  data.tar.gz: a1f6d8c5c05f1d076096e6af97128fb14ebb95f73a60a365ffad1efbeedb169931a7bef9ed762e515c341680e2b571462fb725ef0a3746ffa5f2e02d91b2bf66

data/bin/calc

@@ -4,19 +4,63 @@ require 'rubygems'
 require 'calculator'
 require 'calcex'
 
-$stdout.print "> "
-$stdout.flush
+$calc = Calculator.new()
 
-text = gets
+def interactiveCalc
+  $stdout.print "> "
+  $stdout.flush
+  text = gets
+  makeCalc(text)
+  interactiveCalc()
+end
 
-$calc = Calculator.new()
+def makeCalc(text)
+  $stdout.puts "=> " + $calc.eval(text).to_s + $calc.printVar()
+end
+
+def setEnvVars
+  ENV.each do |key, value|
+    if key.start_with?("CALCVAR") == true then
+      var = key.slice(7, key.size)
+      text = var + "=" + value + "\n"
+      $calc.eval(text)
+    end
+  end
+  $calc.changeSetEnvVars(false)
+end
+
+def processArgs
+  args = ARGF.argv
+  i = 0
+  while i < args.size-1 do
+    optionArg = args[i]
+    if optionArg == "-e" then
+      $calc.envConf()
+      setEnvVars()
+    elsif (optionArg == "-v") then
+      text = args[i+1] + "\n"
+      $calc.eval(text)
+      i += 1
+    else
+      lines = ARGF.readlines
+      lines.each do |line| makeCalc(line) end
+    end
+    i += 1
+  end
+end
+
+def main
+  setEnvVars()
+  processArgs()
+  interactiveCalc()
+end
 
 begin
-  puts "= " + $calc.eval(text).to_s
+  main()
 rescue ParseError
-  puts "Parse Error"
+  puts "* Parse Error"
 rescue UnrecognizedTokenException
-  puts "UnrecognizedTokenException"
+  puts "* UnrecognizedTokenException"
 rescue
-  puts "Unkown exception"
+  puts "* Unkown exception"
 end

data/lib/ast.rb

@@ -8,10 +8,10 @@ class BinaryNode
     @right = right
   end
 end
-   
+
 class UnaryNode
   attr_reader :subTree
-   
+  
   def initialize(subTree)
     @subTree = subTree
   end
@@ -21,9 +21,9 @@ class AddNode < BinaryNode
   def initialize(left, right)
     super(left,right)
   end
-   
-  def evaluate 
-    @left.evaluate + @right.evaluate
+  
+  def evaluate
+    return @left.evaluate() + @right.evaluate()
   end
 end
 
@@ -31,54 +31,119 @@ class SubNode < BinaryNode
   def initialize(left, right)
     super(left,right)
   end
-   
-  def evaluate 
-    return @left.evaluate - @right.evaluate
+  
+  def evaluate
+    return @left.evaluate() - @right.evaluate()
   end
 end
+
 class TimesNode < BinaryNode
   def initialize(left, right)
-    super(left,right)
+    super(left, right)
   end
 
   def evaluate
-    @left.evaluate * @right.evaluate
+    left.evaluate * right.evaluate
   end
 end
 
 class DivideNode < BinaryNode
   def initialize(left, right)
-    super(left,right)
+    super(left, right)
+  end
+  
+  def evaluate
+    left.evaluate / right.evaluate
+  end
+end
+
+class ModNode < BinaryNode
+  def initialize(left, right)
+    super(left, right)
   end
 
   def evaluate
-    @left.evaluate / @right.evaluate
+    left.evaluate % right.evaluate
   end
 end
 
 class StoreNode < UnaryNode
-  def initialize(subTree)
-    super(subTree)
+  def initialize(sub)
+    super(sub)
   end
 
   def evaluate
-     $calc.memory = subTree.evaluate
+    $calc.memory = subTree.evaluate
   end
 end
 
 class RecallNode
   def evaluate
-      $calc.memory 
-  end  
+    $calc.memory
+  end
 end
 
-
-class NumNode 
+class NumNode
   def initialize(num)
     @num = num
   end
-   
+  
+  def evaluate
+    return @num
+  end
+end
+
+class PlusNode < UnaryNode
+  def initialize(sub)
+    super(sub)
+  end
+
+  def evaluate
+    valc = $calc.memory + subTree.evaluate
+    $calc.memory = valc
+    return valc
+  end
+end
+
+class MinusNode < UnaryNode
+  def initialize(sub)
+    super(sub)
+  end
+
+  def evaluate
+    valc = $calc.memory - subTree.evaluate
+    $calc.memory = valc
+    return valc
+  end
+end
+
+class ClearNode
+  def evaluate
+    valc = 0
+    $calc.memory = valc
+    return valc
+  end
+end
+
+class SetNode < UnaryNode
+  def initialize(sub, key)
+    super(sub)
+    @key = key
+  end
+
+  def evaluate
+    val = subTree.evaluate
+    $calc.set(@key, val)
+    return val
+  end
+end
+
+class GetNode
+  def initialize(key)
+    @key = key
+  end
+
   def evaluate
-    @num
+    return $calc.get(@key)
   end
 end

data/lib/calcex.rb

@@ -1,3 +1,2 @@
-
 class ParseError < Exception; end
 class UnrecognizedTokenException < Exception; end

data/lib/calculator.rb

@@ -3,14 +3,67 @@ require 'ast'
 
 class Calculator
   attr_accessor :memory
-  
+
   def initialize()
     @memory = 0
+    @useEnvVars = false
+    @setEnvVars = false
+    @createVar = false
+    @lastCreateKey = ''
+    @varsEnv = Hash.new()
+    @vars = Hash.new()
   end
-    
+
   def eval(expr)
     parser = Parser.new(StringIO.new(expr))
     ast = parser.parse()
     return ast.evaluate()
   end
+
+  def set(key, value)
+    if @setEnvVars == true then
+      @varsEnv.store(key, value)
+    else
+      @vars.store(key, value)
+    end
+    @createVar = true;
+    @lastCreateKey = key
+  end
+  def isEnvVar(key)
+    if @varsEnv.has_key?(key) == true then
+      return true
+    else
+      return false
+    end
+  end
+  def get(keyToGet)
+    if @useEnvVars == true && isEnvVar(key) == true then
+      @varsEnv.each {|key, val|
+        if keyToGet == key then
+          return val
+        end }
+    else
+      @vars.each {|key, val|
+        if keyToGet == key then
+          return val
+        end }
+    end
+    return 0
+  end
+  def envConf
+    @useEnvVars = true
+  end
+
+  def changeSetEnvVars(bool)
+    @setEnvVars = bool
+  end
+
+  def printVar
+    result = ''
+    if @createVar == true then
+      result = " [ #{@lastCreateKey} <- #{get(@lastCreateKey)} ]"
+      @createVar = false
+    end
+    return result
+  end
 end

data/lib/parser.rb

@@ -7,124 +7,144 @@ class Parser
   def initialize(istream)
     @scan = Scanner.new(istream)
   end
-   
-  def parse()
-    return Prog()
+  
+  def parse
+    Prog()
   end
   
   private
-  def Prog()
+  def Prog
     result = Expr()
-    t = @scan.getToken()
-    
+    t = @scan.getToken
     if t.type != :eof then
       print "Expected EOF. Found ", t.type, ".\n"
       raise ParseError.new
     end
     
-    return result
+    result
   end
   
-  def Expr() 
+  def Expr
     RestExpr(Term())
   end
-   
+  
   def RestExpr(e) 
-    t = @scan.getToken()
+    t = @scan.getToken
     
     if t.type == :add then
-         return RestExpr(AddNode.new(e,Term()))
+      return RestExpr(AddNode.new(e,Term()))
     end
     
     if t.type == :sub then
       return RestExpr(SubNode.new(e,Term()))
     end
-      
-    @scan.putBackToken()
+    
+    @scan.putBackToken
     
     e
   end
   
-  def Term()
-    # Write your Term() code here. This code is just temporary
-    # so you can try the calculator out before finishing it.
-    
-   # t = @scan.getToken()
-    
-    #if t.type == :number then
-     # val = t.lex.to_i
-      #return NumNode.new(val)
-    #end
-    
-   # puts "Term not implemented\n"
-    
-   # raise ParseError.new
+  def Term
     RestTerm(Storable())
   end
-   
+  
   def RestTerm(e)
     t = @scan.getToken
-    if t.type == :times
-       return RestTerm(TimesNode.new(e,Storable()))
+
+    if t.type == :times then
+      return RestTerm(TimesNode.new(e,Storable()))
     end
 
-    if t.type == :divide
-     return  RestTerm(DivideNode.new(e,Storable()))
-      
+    if t.type == :divide then
+      return RestTerm(DivideNode.new(e,Storable()))
     end
-    
+
+    if t.type == :mod then
+      return RestTerm(ModNode.new(e,Storable()))
+    end
+
     @scan.putBackToken
-   
+
     e
   end
-   
-
-  def Storable()
-    result = Factor()
 
+  def Storable
+    MemOperation(Factor())
+  end
+  
+  def MemOperation(e)
     t = @scan.getToken
 
-    if t.type == :keyword then
-      if t.lex == "S" then
-        return StoreNode(result)
+    if t.type == :keyword
+      if t.lex == "S"
+        return StoreNode.new(e)
       end
-      puts "Expected s found: ",t.lex
+
+      if t.lex == 'P'
+        return PlusNode.new(e)
+      end
+
+      if t.lex == 'M'
+        return MinusNode.new(e)
+      end
+      
+      puts "We found an error on MemOperation #{t.lex}"
+      print " at line #{t.line} col: #{t.col}"
       raise ParseError.new
     end
 
     @scan.putBackToken
-    result
-    
+
+    e
   end
-   
-  def Factor() 
+  
+  def Factor
     t = @scan.getToken
 
-    if t.type == :number then
+    if t.type == :number
       return NumNode.new(t.lex.to_i)
     end
 
-    if t.type == :keyword then
-      if t.lex == "R" then
+    if t.type == :keyword
+      if t.lex == 'R'
         return RecallNode.new
       end
-    puts "Factor not implemented" + t.lex
-    raise ParserError.new 
+
+      if t.lex == 'C'
+        return ClearNode.new
+      end
+      puts "We found an error on Factor::keyword"
+      raise ParseError.new
     end
-    if t.type == :lparen then
-      result  = Expr()
-      
+    
+    if t.type == :lparen
+      result = Expr()
       t = @scan.getToken
-      if t == :rparen then
-         return result
+      if t.type == :rparen
+        return result
       end
-
-      puts "Expected ) no found: " + t.lex.to_i
-      raise ParserError.new
-      
+      puts "We found an error on Factor::rparen"
+      print " at line #{t.line} col: #{t.col}"
+      raise ParseError.new
     end
-    puts "Expected number, R ( found:" + t.type.to_s
-    raise ParserError.new
     
-  end    
+    if t.type == :identifier
+      Assignable(t.lex)
+    end
+  end
+  
+  def Assignable(key)
+    t = @scan.getToken
+    if t.type == :assign
+      return Assign(key)
+    end
+
+    @scan.putBackToken
+
+    return GetNode.new(key)
+  end
+
+  def Assign(key)
+    return SetNode.new(Expr(), key)
+  end
 end

data/lib/scanner.rb

@@ -4,33 +4,33 @@ require 'calcex'
 class Scanner
   def initialize(inStream)
     @istream = inStream
-    @keywords = Set.new(["S","R"])
+    @keywords = Set.new(["S","R","P","C","M"])
     @lineCount = 1
     @colCount = -1
     @needToken = true
     @lastToken = nil
   end
-  
-  def putBackToken
+
+  def putBackToken()
     @needToken = false
   end
 
-  def getToken
-    unless @needToken
+  def getToken()
+    if !@needToken
       @needToken = true
       return @lastToken
     end
-    
+
     state = 0
     foundOne = false
     c = @istream.getc()
-    
+
     if @istream.eof() then
       @lastToken = Token.new(:eof,@lineCount,@colCount)
       return @lastToken
     end
-    
-    until foundOne
+
+    while !foundOne
       @colCount = @colCount + 1
       case state
       when 0
@@ -45,7 +45,9 @@ class Scanner
         elsif c == ?/ then state = 6
         elsif c == ?( then state = 7
         elsif c == ?) then state = 8
-        elsif c == ?\n then 
+        elsif c == ?% then state = 9
+        elsif c == ?= then state = 10
+        elsif c == ?\n then
           @colCount = -1
           @lineCount = @lineCount+1
         elsif isWhiteSpace(c) then state = state #ignore whitespace
@@ -91,6 +93,12 @@ class Scanner
       when 8
         type = :rparen
         foundOne = true
+      when 9
+        type = :mod
+        foundOne = true
+      when 10
+        type = :assign
+        foundOne = true
       end
 
       if !foundOne then
@@ -99,8 +107,8 @@ class Scanner
       end
 
     end
-   
-    @istream.ungetc(c)   
+
+    @istream.ungetc(c)
     @colCount = @colCount - 1
     if type == :number or type == :identifier or type == :keyword then
       t = LexicalToken.new(type,lex,line,column)
@@ -109,18 +117,18 @@ class Scanner
     end
 
     @lastToken = t
-    return t 
+    return t
   end
 
   private
-  def isLetter(c) 
+  def isLetter(c)
     return ((?a <= c and c <= ?z) or (?A <= c and c <= ?Z))
   end
-  
+
   def isDigit(c)
     return (?0 <= c and c <= ?9)
   end
-  
+
   def isWhiteSpace(c)
     return (c == ?\  or c == ?\n or c == ?\t)
   end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: calc_jgomez40
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
-- Kent D. Lee - Juan Francisco Cardona Mc - Juan Sebastian Gomez
+- Kent D. Lee - Juan Francisco Cardona Mc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-11 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies: []
 description: An calculator implementation on ruby
-email: fcardona@eafit.edu.co
+email: jgomez40@eafit.edu.co
 executables:
 - calc
 extensions: []
@@ -44,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Another calculator in ruby