calc_emonto15 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 323be5b28cb4e775ea072cff56ac45d72162ed10
-  data.tar.gz: 678b1430e17eb8ac35c82a2950272d4ef5b8e6db
+  metadata.gz: 3d01a7350e2aa58eb7bb63fdeb3fe4a396585119
+  data.tar.gz: 608ac2f43274a72b2f9e078830a80f444e075635
 SHA512:
-  metadata.gz: 37afe97be4f2172f1b40031b40e83ab1289ab4bc10e747652e1148164d8e2d817dd790622cac9c3b9a9186533535981412e4890671c5977dea9955292f23ab6e
-  data.tar.gz: d4fb5eb75050de929812d91eb88181fc1bf5c39a193aca7211abe4e9955f2f544abc85347a88f3902eaba0e77e57989aa2dc0395fc122d7135ea0885f88d9bd1
+  metadata.gz: e16fdb29a2e93b7489561a760462816149ee7128af5d25072e210f0a1d6902f0880e53809d153ee97f485b34106c5c64c5e7b3b2a71f1fdc11faf0ce4e489b04
+  data.tar.gz: d2d3d968d709d86e21589fe561eb968a91d8fcfb9abfc873558f79918aab73350fb4dc6badef3caa287b1135d9af887766c63d2a4295670054f7deb9a168101d

data/bin/calc

@@ -1,22 +1,109 @@
 #!/usr/bin/env ruby
+# coding: utf-8
 
 require 'rubygems'
 require 'calculator'
 require 'calcex'
+interactivo=true;
+$calc = Calculator.new()
 
-$stdout.print "> "
-$stdout.flush
+if ARGV[0]=="-e" then
+  i=0
+  ARGV.each do |val|
+    if val=="-v"
+      i+=1
+      particion = ARGV[i].partition("=")
+      $calc.mem2[particion[0]]=particion[2].to_i
+    else
+      i+=1
+    end
+  end
+ 
+   ENV.each do |val,v|
+     if val.match(/CALCVAR.*/) then
+       $calc.mem2[(val.delete "CALCVAR")]=v.to_i
+     end
+   end
+else
+  ENV.each do |val,v|
+    if val.match(/CALCVAR.*/) then
+      $calc.mem2[(val.delete "CALCVAR")]=v.to_i
+    end
+  end
+  i=0
+  ARGV.each do |k|
+    if k=="-v"
+      i+=1
+      particion = ARGV[i].partition("=")
+      $calc.mem2[particion[0]]=particion[2].to_i
+    else
+      i+=1
+    end
+  end
+end
 
-text = gets
+cont=0
+ARGV.each do |k|
+  cont+=1
+end
 
-$calc = Calculator.new()
+  i=-1
+  ARGV.each do |var|
+    i+=1
+    if var!="-v" and var!="-e" then
+      if i!=0 then
+        if ARGV[i-1]!="-v"
+          File.open(ARGV[i], 'r') do |f1|
+            while linea = f1.gets
+              begin
+                result=$calc.eval(linea).to_s
+                if $calc.assign!=""
+                  puts "=> " + result + " [" + $calc.assign.partition(" ")[2] + "]"
+                else
+                  puts "=> " + result
+                end
+              rescue ParseError
+              rescue UnrecognizedTokenException
+              end
+              interactivo=false;
+            end
+          end
+        end
+      else
+        File.open(ARGV[i], 'r').each do |f1|
+            begin
+              result=$calc.eval(f1).to_s
+              if $calc.assign!=""
+                puts "=> " + result + " [" + $calc.assign.partition(" ")[2] + "]"
+              else
+                puts "=> " + result
+              end
+            rescue ParseError
+            rescue UnrecognizedTokenException
+            end
+            interactivo=false;
+          
+        end
+      end
+    end
+  end
 
-begin
-  puts "= " + $calc.eval(text).to_s
-rescue ParseError
-  puts "Parse Error"
-rescue UnrecognizedTokenException
-  puts "UnrecognizedTokenException"
-rescue
-  puts "Unkown exception"
+if interactivo==true then
+  $stdout.print "> "
+  $stdout.flush
+  while text=$stdin.gets
+    begin
+      result=$calc.eval(text).to_s      
+      if $calc.assign!=""
+        puts "=> " + result + " [" + $calc.assign.partition(" ")[2] + "]"
+      else
+        puts "=> " + result
+      end
+    rescue ParseError
+    rescue UnrecognizedTokenException
+    end
+    $stdout.print "> "
+    $stdout.flush
+  end
+ $stdout.print "\n"
 end

data/lib/ast.rb

@@ -57,6 +57,16 @@ class DivideNode < BinaryNode
   end
 end
 
+class ModNode < BinaryNode
+  def initialize(left, right)
+    super(left,right)
+  end
+
+  def evaluate
+    return @left.evaluate % @right.evaluate()
+  end
+end
+
 class StoreNode < UnaryNode
   def initialize(sub)
     super sub
@@ -83,3 +93,50 @@ class NumNode
   end
 end
 
+class ClearNode
+  def evaluate
+    $calc.memory=0
+  end
+end
+
+class PlusNode < UnaryNode
+  def initialize(sub)
+    super sub
+  end
+
+  def evaluate
+    aux = subTree.evaluate().to_i
+    $calc.memory=$calc.memory+aux
+  end
+end
+
+class MinusNode < UnaryNode
+  def initialize(sub)
+    super sub
+  end
+
+  def evaluate
+    aux = subTree.evaluate().to_i
+    $calc.memory=$calc.memory-aux
+  end
+end
+
+class AssignNode < UnaryNode
+  def initialize(sub,name)
+    super sub
+    @name=name
+  end
+
+  def evaluate
+    $calc.mem2[@name] = subTree.evaluate()
+  end
+end
+
+class IdNode
+  def initialize(name)
+    @name=name
+  end
+  def evaluate
+    $calc.mem2[@name]
+  end
+end

data/lib/calculator.rb

@@ -2,14 +2,19 @@ require 'parser'
 require 'ast'
 
 class Calculator
+  attr_accessor :assign
   attr_accessor :memory
+  attr_accessor :mem2
   
   
   def initialize()
+    @assign=""
     @memory = 0
+    @mem2= Hash.new(0)
   end
   
   def eval(expr)
+    @assign=""
     parser = Parser.new(StringIO.new(expr))
     ast = parser.parse()
     return ast.evaluate()

data/lib/parser.rb

@@ -4,6 +4,7 @@ require 'token'
 require 'calcex'
 
 class Parser
+  
   def initialize(istream)
     @scan = Scanner.new(istream)
   end
@@ -14,21 +15,27 @@ class Parser
   
   private
   def Prog
+    t = @scan.getToken
+    if t.type == :eof
+      print "* ParseError: Expected EOF. Found  eol.\n"
+      raise ParseError
+      
+    end
+    @scan.putBackToken
     result = Expr()
     t = @scan.getToken
-    
     if t.type != :eof then
-      print "Expected EOF. Found ", t.type, ".\n"
+      print "* ParseError: Expected EOF. Found ", t.type, ".\n"
       raise ParseError.new
     end
-    
     result
   end
-  
+
+
   def Expr 
     return RestExpr(Term())
   end
-   
+
   def RestExpr(e) 
     t = @scan.getToken
     
@@ -46,46 +53,46 @@ class Parser
   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
-  # end
-
     RestTerm(Storable())
-  end   
+  end
+  
   def RestTerm(e)
     t = @scan.getToken
     if t.type == :times
-      return RestTem(TimesNode.new(e,Storable()))
+      return RestTerm(TimesNode.new(e,Storable()))
     end
 
     if t.type == :divide
       return RestTerm(DivideNode.new(e,Storable()))
     end
+
+    if t.type == :mod
+      return RestTerm(ModNode.new(e,Storable()))
+    end
     
     @scan.putBackToken
     e
   end
-   
+
   def Storable
-    result = Factor()
+    return MemOperation(Factor());
+  end
+  
+  def MemOperation(result)
     t = @scan.getToken
 
     if t.type == :keyword
       if t.lex == "S"
         return StoreNode.new(result)
       end
-      puts "Expected 'S' , found #{t.lex} at line: #{t.line} col: #{t.col}"
+      if t.lex == "P"
+        return PlusNode.new(result)
+      end
+      if t.lex == "M"
+        return MinusNode.new(result)
+      end
+          
+      puts "* ParseError: Expected 'S','P' or 'M' , found #{t.lex}"
       raise ParseError.new
 
     end
@@ -96,34 +103,59 @@ class Parser
    
   def Factor 
     t = @scan.getToken
-
+    
     if t.type == :number
       return NumNode.new(t.lex.to_i)
     end
-
+    
     if t.type == :keyword
       if t.lex == "R"
         return RecallNode.new
       end
-      puts "Expected R. Found #{t.lex} at line: #{t.line} col: #{t.col}"
+      if t.lex == "C"
+        return ClearNode.new
+      end
+      puts "* ParseError: Expected R or C. Fount #{t.type}"
       raise ParseError.new
     end
-
-
+    
+    
     if t.type == :lparen
       result = Expr()
       t = @scan.getToken
       if t.type == :rparen
         return result
       end
-
-      puts "Parse Erro: expected ) found #{t.lex} at line: #{t.lex} col #{t.col}"
+      puts "* Parse Error: expected )."
       raise ParseError.new
     end
-
-    puts "Expected number, R or (Expr). Found#{t.lex} at line #{t.line} col #{t.col}"
-    raise ParseError.new
     
+    
+    @scan.putBackToken
+    return Assignable()
+  end
+
+  def Assignable
+    t = @scan.getToken
+    if t.type == :identifier
+      @scan.putBackToken
+      return Assign()
+    end
+      puts "* ParseError: Expected number, R, C, Assignable, eol or (Expr). Found #{t.type}"
+      raise ParseError.new
   end
 
+  def Assign
+    t=@scan.getToken
+    name=t.lex
+    t=@scan.getToken
+    if t.type == :igual
+      result= Expr()
+      valor=result.evaluate()
+      $calc.assign+=", "+name+" <- "+valor.to_s
+      return AssignNode.new(result,name)
+    end
+    @scan.putBackToken
+    return IdNode.new(name)
+  end
 end

data/lib/scanner.rb

@@ -4,7 +4,7 @@ require 'calcex'
 class Scanner
   def initialize(inStream)
     @istream = inStream
-    @keywords = Set.new(%w{S R}) #definicion de colecciones
+    @keywords = Set.new(%w{S R C P M}) #definicion de colecciones
     @lineCount = 1
     @colCount = -1
     @needToken = true
@@ -45,6 +45,8 @@ class Scanner
         elsif c == ?/ then state = 6
         elsif c == ?( then state = 7
         elsif c == ?) then state = 8
+        elsif c == ?% then state = 9
+        elsif c == ?= then state = 10
         elsif c == ?\n then 
           @colCount = -1
           @lineCount = @lineCount+1
@@ -91,16 +93,28 @@ class Scanner
       when 8
         type = :rparen
         foundOne = true
+      when 9
+        type = :mod
+        foundOne = true
+      when 10
+        type = :igual
+        foundOne = true
       end
 
       if !foundOne then
         lex.concat(c)
         c = @istream.getc()
+        if state==0 && @istream.eof?
+          @lastToken = Token.new(:eof, @lineCount, @colCount)
+          return @lastToken
+        end
       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)
@@ -114,14 +128,14 @@ class Scanner
 
   private
   def isLetter(c) 
-    return ((?a <= c and c <= ?z) or (?A <= c and c <= ?Z))
+    return ((?a <= c.to_s and c.to_s <= ?z) or (?A <= c.to_s and c.to_s <= ?Z))
   end
   
   def isDigit(c)
-    return (?0 <= c and c <= ?9)
+    return (?0 <= c.to_s and c.to_s <= ?9)
   end
   
   def isWhiteSpace(c)
-    return (c == ?\  or c == ?\n or c == ?\t)
+    return (c.to_s == ?\  or c.to_s == ?\n or c == ?\t)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: calc_emonto15
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kent D. Lee - Juan Francisco Cardona Mc - Edwin Montoya Jaramillo