calc_jgomez88 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61a2b5a27d01d7760aedb6ed9a2715c2dda44b8c
-  data.tar.gz: 844adc3e28d0d7e5e88d7dc32686127bb6133aa6
+  metadata.gz: 484290abe479b03f1415c585afc1a4debdf5782f
+  data.tar.gz: 334f22367cc64dda2c42dc19d79348e6eec3b243
 SHA512:
-  metadata.gz: 8a8d4dd2b9d7cd230d39111c4f9626645dab902c6dcfc9740a9aafa5fd22dcadf78bcc03f313ffed0faefb50ed9abe781925535e2c12eb8b3e0e7a2319c47328
-  data.tar.gz: ff5f8da5c84f4f1d62fc44435944d42edacb81fa3ce755c045f75e2e95416f81c569641c1c183fc21fbf2fc4c687b5f36eed26bf47f7f646179b25577d0635c1
+  metadata.gz: 6b659ce91e3389dcb216a9a514f4b7e0c155216f3212097f5185edf9f7768d77b9453d30c68a3b45f208f70f6c420cd9bf872a80d39bc22225aa93eabe2619d8
+  data.tar.gz: 82759f854a7eef1867082729122dabe99630dd99839505c404b1134bfbdf285d5cb13e6f3b4adcc9881a1b33191f10ea9bc4a249a35607ec81c830bd70de7f31

data/bin/calc

@@ -8,16 +8,26 @@ require 'calcex'
 $stdout.print "> "
 $stdout.flush
 
-text = gets
-
 $calc = Calculator.new()
+entro = true #Varaible para saber si entro datos
+text = gets
 
-begin
-  puts "= " + $calc.eval(text).to_s
-rescue ParseError
-  puts "Parse Error"
-rescue UnrecognizedTokenException
-  puts "UnrecognizedTokenException"
-rescue
-  puts "Unkown exception"
+while entro do  
+  begin
+    puts "=> " + $calc.eval(text).to_s
+  rescue ParseError
+    puts "Parse Error"
+  rescue UnrecognizedTokenException
+    puts "UnrecognizedTokenException"
+  rescue
+    puts "Unkown exception"
+  end
+  $stdout.print "> "
+  if text = gets then #Verifica si entro otra linea
+    entro = true
+  else
+    entro = false
+  end
 end
+
+

data/lib/ast.rb

@@ -58,10 +58,19 @@ class DivideNode < BinaryNode
     return @left.evaluate() / @right.evaluate()
   end
 end
+#modulo--------------------------------------------------
+class ModuleNode < BinaryNode
+  def initialize(left, right)
+    super(left,right)
+  end
 
+  def evaluate()
+    return @left.evaluate()  %  @right.evaluate()
+  end
+end
+#------------------------------------------------------------
 
 class StoreNode < UnaryNode
-  #
   def initialize(subTree)
     super(subTree)
   end
@@ -71,13 +80,59 @@ class StoreNode < UnaryNode
   end
 end
 
+#plus---------------------------------
+class PlusNode < UnaryNode
+  def initialize(subTree)
+    super(subTree)
+  end
+  def evaluate
+    $calc.memory =$calc.memory + subTree.evaluate()
+  end
+end
+#----------------------------------------    
+#minus-------------------------------------
+class MinusNode < UnaryNode
+  def initialize(subTree)
+    super(subTree)
+  end
+  def evaluate
+    $calc.memory =$calc.memory - subTree.evaluate()
+  end
+end
+
+#----------------------------------------
 class RecallNode
-  #
+  
   def evaluate
     $calc.memory
   end
 end
-      
+#------------------------------------
+
+class AssignableNode < UnaryNode
+  def initialize(valor1,nombre)
+    super(valor1)
+   @name=nombre
+  end
+  
+  def evaluate
+    guardar=@subTree.evaluate()
+    $calc.addVar(@name,guardar)
+    return guardar
+  end
+end
+#-----------------------------------------
+  
+
+#C----------------------------------------
+class ClearNode
+  def  evaluate
+    $calc.memory=$calc.memory-$calc.memory#0
+    
+  end
+end
+#----------------------------------------
+
 class NumNode 
   def initialize(num) #
     @num = num

data/lib/calculator.rb

@@ -7,6 +7,7 @@ class Calculator
   
   def initialize()
     @memory = 0
+    @varmap = Hash.new() #crea un mapax
   end
   
   def eval(expr)
@@ -14,4 +15,12 @@ class Calculator
     ast = parser.parse()
     return ast.evaluate()
   end
+  
+  def addVar(nombre,valor)
+    @varmap[nombre]=valor
+  end
+  def getVar(valor)
+    return @varmap[valor]
+  end
+  
 end

data/lib/parser.rb

@@ -8,7 +8,7 @@ class Parser
     @scan = Scanner.new(istream)
     #recibe un flujo de datos
   end
-   
+  
   def parse()
     return Prog()
   end
@@ -32,21 +32,21 @@ class Parser
   def Expr() 
     return RestExpr(Term())
   end
-   
+  
   def RestExpr(e) 
     t = @scan.getToken()
     #leo el token
     
     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()
-   
+    
     
     return e
   end
@@ -67,7 +67,7 @@ class Parser
     # raise ParseError.new
     RestTerm(Storable())
   end
-   
+  
   def RestTerm(e)
     
     # puts "RestTerm not implemented"
@@ -75,12 +75,15 @@ class Parser
     #lo borramos
     t = @scan.getToken
     if t.type == :times
-      return  RestTerm (TimesNode.new(e, Storable()))
+      return  RestTerm(TimesNode.new(e, Storable()))
     end
     if t.type == :divide
       #mira el tipo de token
       return  RestTerm(DivideNode.new(e, Storable()))
     end
+    if t.type == :mod
+      return RestTerm(ModuleNode.new(e, Storable()))
+    end
     @scan.putBackToken
 
     return e
@@ -91,19 +94,44 @@ class Parser
     # puts "Storable not implemented"
     # raise ParseError.new # "Parse Error"
     #lo borramos
-    result=Factor()
-    t = @scan.getToken
+    #-------------------------------------------
+    # result=Factor()
+    # t = @scan.getToken
+    # if t.type== :keyword then
+    # if t.lex == "S" then
+    # return StoreNode.new(result)
+    #end
+    # puts "Expected S found: ",t.lex
+    #  raise ParseError.new
+    # end
+    #  @scan.putBackToken
+    # return  result
+    # end
+    #----------------------------------------------------
+    return MemOperation(Factor())
+  end
+  #------------------------------------------------------
+
+  
+  def MemOperation(result)
+    # result=Factor()
+    t= @scan.getToken
     if t.type== :keyword then
       if t.lex == "S" then
         return StoreNode.new(result)
+      elsif t.lex == "P" then
+        return PlusNode.new(result)
+      elsif t.lex == "M" then
+        return MinusNode.new(result)
       end
-      puts "Expected S found: ",t.lex
-      raise ParseError.new
+      puts "Expected S || P || M found: ",t.lex
+      raise  ParseError
     end
     @scan.putBackToken
-   return  result
+    return result
   end
   
+  
   def Factor() 
     
     # puts "Factor not implemented"
@@ -117,22 +145,43 @@ class Parser
     if t.type == :keyword then
       if t.lex == "R" then
         return RecallNode.new
+      elsif t.lex == "C" then
+        return ClearNode.new
       end
-      puts "Expected R found: " + t.lex
+      puts "Expected R || C found: " + t.lex
       raise ParseError.new
     end
     if t.type == :lparen then
       result = Expr()
       t=@scan.getToken
-
       if t.type == :rparen then
         return result
       end
-
       puts "Expected ) found: " + t.type.to_s
       raise ParseError.new
     end
+    if t.type == :identifier then
+      return Assignable(t)
+    end
     puts "Expected number,R ( found: " + t.type.to_s
     raise ParseError
   end
+ 
+
+def Assignable(t)
+  r=@scan.getToken
+  if r.type == :Asignav
+    return assign(t)
+  end
+  nombre=t.lex
+  @scan.putBackToken
+  return NumNode.new($calc.getVar(nombre))
+end
+
+def assign(t)
+  result=Expr()
+  paso=result.evaluate()
+  nombre=t.lex
+  return AssignableNode.new(NumNode.new(paso), nombre)
 end
+end  

data/lib/scanner.rb

@@ -7,7 +7,7 @@ class Scanner
   def initialize(inStream)
     @istream = inStream
     #flujo de entrada
-    @keywords = Set.new(["S","R"])
+    @keywords = Set.new(["S","R","P","M","C","="])
     @lineCount = 1
     @colCount = -1
     @needToken = true
@@ -44,7 +44,7 @@ class Scanner
         column = @colCount
         line = @lineCount
         if isLetter(c) then state=1
- #pregunta de que tipo de caracter 
+        #pregunta de que tipo de caracter 
         elsif isDigit(c) then state=2
         elsif c == ?+ then state = 3
         elsif c == ?- then state = 4
@@ -52,6 +52,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
@@ -100,7 +102,15 @@ class Scanner
       when 8
         type = :rparen
         foundOne = true
+      when 9
+        type = :mod
+        foundOne = true
+      when 10
+        type = :Asignav
+        foundOne = true
       end
+    
+      
 
       if !foundOne then
         lex.concat(c)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calc_jgomez88
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Kent D. Lee - Juan Francisco Cardona Mc-juan camilo gomez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-12 00:00:00.000000000 Z
+date: 2015-11-22 00:00:00.000000000 Z
 dependencies: []
 description: An calculator implementation on ruby
 email: fcardona@eafit.edu.co-jgomez88@eafit.edu.co
@@ -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.8
 signing_key: 
 specification_version: 4
 summary: Another calculator in ruby