linmeric 0.1.0

data/lib/linmeric/Parser.rb

@@ -0,0 +1,118 @@
+#! /usr/bin/env ruby
+
+require_relative 'CnGal_new_classes.rb'
+
+class Parser
+  def initialize()
+    @d = 0
+    @error = false
+  end
+  
+  def reset()
+    @d = 0
+    @error = false
+  end
+
+  def parse(expr)
+    array = Array.new
+    until @d == expr.length
+      c = expr[@d]
+      case c
+        when "("
+          @d += 1
+          calc = parse(expr)
+          array.push calc if calc != nil 
+        when ")"
+          @d += 1
+          return array
+        when /[\*\/]/
+          @d +=1
+          array.push c.to_sym
+        when /[\+\-\^]/
+          @d+=1
+          array.push c.to_sym
+        when /\=/
+          @d += 1
+          array.push c.to_sym
+        when /\>/
+          @d += 1
+          array.push c.to_sym
+        when /\"/
+          @d += 1
+          array.push extract(expr)
+        when /\~/
+          @d += 1
+          if expr[@d] == "("
+            @d +=1
+            calc = parse(expr)
+            array.push calc unless calc == nil
+          else
+            array.push expr[@d]
+            @d += 1
+          end
+        when /\./
+          if expr[@d-1] =~ /[0-9]+/
+            x = array.pop.to_s + c + expr[@d+1]
+            array.push x.to_n
+          else
+            unless @error
+              @error = true
+              puts "Problem evaluating expression at index:#{@d}"
+              puts "Invalid char '#{expr[@d]}' in string variable"
+            end
+            return
+          end
+          @d+=2
+        when /\:/
+          if expr[@d - 1] =~ /[a-zA-Z]+/ then
+            x = array.pop.to_s + c
+            array.push x.downcase.to_sym
+          else
+            unless @error
+              @error = true
+              puts "Problem evaluating expression at index:#{@d}"
+              puts "Invalid char '#{expr[@d]}' in numeric variable"
+            end
+            return
+          end
+          @d += 1
+        when /\_/
+          @d += 1
+          x = array.pop.to_s + c
+          array.push x
+        when /\p{Alnum}/ 
+          if expr[@d-1] =~ /[0-9\.x]/ && array.count>0
+            x = array.pop.to_s + c 
+            array.push x.to_n
+          elsif (expr[@d-1] =~ /[a-z\A-Z]/ or expr[@d-1] == '_') && array.count>0
+            x = array.pop.to_s + c 
+            array.push x
+          else 
+            array.push c.to_n if c =~ /[0-9\.x]/
+            array.push c if c =~ /[a-zA-Z]/
+          end
+          @d += 1
+        else
+          unless @error
+            @error = true
+            puts "Problem evaluating expression at index:#{@d}"
+            puts "Char '#{expr[@d]}' not recognized"
+          end
+          return
+      end
+    end
+
+    return array
+  end
+  
+  def extract(expr)
+    ext = '"'
+    while expr[@d] != '"' do
+      ext += expr[@d]
+      @d += 1
+    end
+    @d += 1
+    return ext + '"'
+  end
+end
+

data/lib/linmeric/Scopify.rb

@@ -0,0 +1,206 @@
+#! /usr/bin/env ruby
+require_relative 'CnGal_new_classes.rb'
+# per poter computare un'espressione in formato stringa
+# devo prima creare un albero con un parsing.
+# per poter fare queste operazioni necessito di racchiudere
+# le operazioni con priorità maggiore tra parentesi; es:
+# 1+2*3   => 1+(2*3)
+# 1+2*9^4 => 1+(2*(9^(4))) N.B. anche l'argomento di una potenza
+# deve essere tra parentesi.
+# valgono le stesse regole per le parti di espressione tra parentesi; es:
+# 3*(1+2/3) => (3*(1+(2/3)))
+# non importa se ci sono parentesi inutili in più, basta che
+# siano coerenti.
+# se c'è un uguale le parti a sx e a dx devono essere chiuse tra 
+# parentesi; es: a=b*c => (a)=((b*c)) 
+# per quanto riguarda le parole chiavi, la parola chive e il
+# suo argomento vengono messi tra parentesi; es t: a => (t: a)
+class Scp
+  def initialize
+    @i = 0 
+  end
+
+  def scopify(expr)
+    expr = insert_b(expr)
+    @i         = 0
+    n_expr     = ""
+    last_empty = 0
+    open_b     = 0
+    open_p_b   = 0
+    open_m_b   = 0
+    eq         = false
+    stack      = Array.new
+    last_e     = Array.new
+    state      = 0
+    while @i < expr.size
+      case expr[@i]
+        # ogni parte racchiusa tra parentesi viene interpretata come
+        # una sotto espressione, e la sistemo a parte con una ricorsione
+        when '('
+          scp = Scp.new
+          n_expr += expr[@i] + scp.scopify(extract(expr[(@i + 1)...expr.length])) 
+          @i += scp.count  
+        when /[\*\/]/
+          # se ho parentesi aperte da operazioni con priorità superiore
+          # le chiudo
+          if open_m_b > 0
+            n_expr += ')' * open_m_b
+            last_empty = last_e.pop
+            open_m_b = 0
+            #open_b -= 1
+          end
+          if state == 2
+            n_expr += ')' * open_p_b
+            open_p_b = 0
+            state = (stack.size > 0 ? stack.pop : 0)
+          end
+          # se non ho già in corso un inserimento di parentesi per
+          # moltiplicazione, le aggiungo
+          unless state == 1
+            n_expr.insert last_empty, '(' 
+            state = 1
+            open_b += 1
+          end
+          n_expr += expr[@i]
+          last_empty = n_expr.size # + 1
+        when /[\+\-]/
+          # chiudo le parentesi delle operazioni con priorità superiore
+          # faccio lo shift di last_empty
+          n_expr += ')' * open_p_b if open_p_b > 0
+          n_expr += ')' * open_b if open_b > 0
+          state = 0
+          open_b = 0
+          open_p_b = 0
+          n_expr += expr[@i]
+          last_empty = n_expr.size
+        when /\^/
+          # comincio a mettere tra parentesi l'operazione e il suo esponente
+          
+          if open_m_b > 0 then
+            n_expr += ")" * open_m_b
+            last_empty = last_e.pop
+            #open_b -= 1
+            open_m_b = 0
+          end
+          n_expr.insert last_empty, '(' unless state == 2
+          last_empty += 1 unless state == 2
+          n_expr += expr[@i] + (expr[@i+1] == '(' ? '' : '(')
+          open_p_b += (expr[@i+1] == '(' ? 1 : (state == 2 ? 1:2))
+          stack.push state unless state == 2
+          state = 2
+        when /\=/
+          # metto tra parentesi la parte a sx dell'uguale e comincio a
+          # mettere tra parentesi quella a dx
+          # chiudendo eventuali parentesi di potenza o di prodotto
+          n_expr += ')' * open_p_b if open_p_b > 0
+          n_expr += ')' * open_b if open_b > 0
+          open_b = 0
+          open_p_b = 0
+          n_expr = '(' + n_expr + ')' + expr[@i]
+          n_expr += '('
+          last_empty = n_expr.size
+          state = 0
+          eq = true
+        when /\>/
+          n_expr += ')' * open_p_b if open_p_b > 0
+          n_expr += ')' * open_b if open_b > 0
+          open_b = 0
+          open_p_b = 0
+          n_expr = '(' + n_expr + ')' + expr[@i]
+          last_empty = n_expr.size
+        when /\:/
+          n_expr.insert last_empty, '('
+          n_expr += expr[@i]
+          last_k = n_expr[(last_empty+1)...n_expr.size]
+          open_m_b += 1 if  "mx:integ:as:from:".include? last_k
+          last_e.pop if last_e.count > 0 and (last_k == "mx:" or last_k == "integ:")# or last_k == "solve:")
+          last_e.push last_empty if last_k == "mx:" or last_k == "integ:"# or last_k == "solve:"
+          last_empty = n_expr.size
+          open_b += 1 unless "mx:integ:as:from:".include? last_k
+        when /\"/
+          n_expr += expr[@i]
+          @i += 1
+          n_expr += discard(expr)
+          last_empty = n_expr.length
+        when /\~/
+          n_expr += ')' * open_p_b if open_p_b > 0
+          n_expr += ')' * (open_b - 1 ) if open_b - 1 > 0
+          open_p_b = 0
+          open_b = 1
+          state = (stack.size > 0 ? stack.pop : 0)
+          n_expr += expr[@i]
+          last_empty = n_expr.size 
+        else
+          n_expr += expr[@i]
+      end
+      @i += 1
+    end
+    # chiudo parentesi aperte, e quella dell'uguale se stata aperta
+    n_expr += ')' * open_m_b if open_m_b > 0
+    n_expr += ')' * open_p_b if open_p_b > 0
+    n_expr += ')' * open_b if open_b > 0
+    n_expr += ')' if eq
+    return n_expr
+  end
+  
+  def count()
+    return @i
+  end
+  
+  def insert_b(expr)
+    @i = 0
+    string = false
+    while @i < expr.size 
+      string = (expr[@i] == "\"") ? (string ? false : true) : (string)
+      if (expr[@i] == '-' or expr[@i] == '+') and ((expr[@i - 1] == '(') or (@i == 0)) and !string then
+        expr.insert @i, '()'
+      end
+      @i += 1
+    end
+    return expr
+  end
+  
+  private
+  
+  def extract(expr)
+    n_expr = ""
+    i = 0
+    open_b = 0 
+    until (i == expr.size) or ((expr[i] == ')') and (open_b == 0))
+      n_expr += expr[i]
+      open_b += 1 if expr[i] == '('
+      open_b -= 1 if expr[i] == ')' and (i < expr.size - 1)
+      i += 1
+    end
+    return n_expr + ')'
+  end
+  
+  def discard(expr)
+    extract = ""
+    while expr[@i] != '"' do
+      extract += expr[@i]
+      @i += 1
+    end
+    return extract + expr[@i]
+  end
+end
+
+
+#####################################
+#               Tests               #
+##################################### 
+=begin
+print ">"
+inp = gets.chomp.compact
+scp = Scp.new
+
+while inp != 'exit'
+  puts scp.scopify(inp)
+  print '>'; inp = gets.chomp.compact
+end
+
+=end
+
+
+
+

data/lib/linmeric/Sizer.rb

@@ -0,0 +1,328 @@
+#! /usr/bin/env ruby
+
+require_relative 'Token.rb'
+require_relative 'Lexer.rb'
+require_relative 'Error_print.rb'
+require_relative 'CnGal_new_classes.rb'
+
+class Sizer
+  def initialize()
+    @lexer = Lexer.new
+  end
+  
+  def analyze(string, equal = true)  
+    @i = 0
+    state = 0
+    return false if string == ""
+    @@string = string if string.is_a? String
+    unless string.is_a? Array
+      unless balanced_brackets? string
+        puts "Sintax Error: unbalanced brackets"
+        return false 
+      end
+    end
+    token = @lexer.tokenize(string) unless string.is_a? Array
+    token = string if string.is_a? Array
+    while @i < token.size
+      #puts "#{token[@i].me}";puts
+      case state
+        # beginning state
+        when 0
+          case token[@i].attribute
+            when "SUM_OPERATOR"
+              state = 1
+            when "VARIABLE"
+              state = 2
+            when "NUMBER"
+              state = 2
+            when "L_BRACE"
+              sizer = Sizer.new
+              return false unless sizer.analyze(token[(@i+1)...token.size])
+              @i += sizer.count + 1
+              state = 2
+            when "KEYWORD"
+              case token[@i].me
+                when "mx:"
+                  state = 6
+                when "integ:"
+                  state = 7
+                when "shwvar:"
+                  unless equal
+                    PrintError.reduced(token[@i],@@string)
+                    return false
+                  end
+                  state = 5
+                when "solve:"
+                  state = 8
+                when "f:"
+                  state = 4
+                else
+                  if ["t:","det:","norm:","id_mx:","shw:"].include? token[@i].me then
+                    unless equal or token[@i].me != "shw:"
+                      PrintError.reduced(token[@i],@@string)
+                      return false
+                    end
+                    state = 3
+                  elsif not Tool.keys.include? token[@i].me then
+                    PrintError.unknown(token[@i],@@string)
+                    return false
+                  else
+                    PrintError.reduced(token[@i],@@string)
+                    return false
+                  end
+              end
+            else
+              PrintError.default(token[@i],@@string)
+              return false
+          end
+          
+        # expecting numbers,variables, keywords (
+        when 1
+          case token[@i].attribute
+            when "NUMBER"
+              state = 2
+            when "VARIABLE"
+              state = 2
+            when "L_BRACE"
+              sizer = Sizer.new
+              return false unless sizer.analyze(token[(@i+1)...token.size])
+              @i += sizer.count + 1
+              state = 2
+            when "KEYWORD"
+              case token[@i].me
+                when "mx:"
+                  state = 6
+                when "integ:"
+                  state = 7
+                when "shwvar:"
+                  state = 5
+                when "solve:"
+                  state = 8
+                when "f:"
+                  state = 4
+                else
+                  if ["t:","det:","norm:","id_mx:"].include? token[@i].me then
+                    state = 3
+                  elsif not Tool.keys.include? token[@i].me then
+                    PrintError.unknown(token[@i],@@string)
+                    return false
+                  else
+                    PrintError.reduced(token[@i],@@string)
+                    return false
+                  end
+              end
+            else
+              PrintError.default(token[@i],@@string)
+              return false
+          end
+        
+        # expecting operators, )
+        when 2
+          case token[@i].attribute
+            when "OPERATOR"
+              state = 1
+            when "SUM_OPERATOR"
+              state = 1
+            when "EQUAL_OP"
+              if equal
+                unless @i + 1 >= token.size
+                  sizer = Sizer.new
+                  return sizer.analyze(token[(@i+1)...token.size],false)
+                end
+                PrintError.missing_expression_after_equal(@i+1,@@string)
+                return false
+              else
+                PrintError.default(token[@i],@@string)
+                return false
+              end
+            when "TO_FILE_OP"
+              unless equal
+                PrintError.default(token[@i],@@string)
+                return false
+              end
+              state = 4
+            when "R_BRACE"
+              return true
+            else
+              PrintError.default(token[@i],@@string)
+              return false
+          end
+        
+        # expecting only variables or numbers
+        when 3
+          case token[@i].attribute
+            when "VARIABLE"
+              state = 2
+            when "NUMBER"
+              state = 2
+            else
+              PrintError.default(token[@i],@@string)
+              return false
+          end
+          state = 5 if token[@i-1].me == "shw:"
+          
+        # expects blocks (full chek) than nothing
+        when 4
+          return false unless check_block(token)
+          state = 5
+          
+        # expects nothing
+        when 5
+          PrintError.default(token[@i],@@string)
+          return false
+          
+        # checking mx arguments (full)
+        when 6
+          case token[@i].attribute
+            when "KEYWORD"
+              if token[@i].me == "from:" then
+                @i += 1
+                unless @i < token.size
+                  PrintError.missing(token[@i-1],@@string)
+                  return false
+                end
+                return false unless check_block(token)
+                state = 2
+              else
+                PrintError.missmatch(token[@i],@@string,"keyword 'from:' or block")
+                return false
+              end
+            when "QUOTES"
+              return false unless check_block(token)
+              unless @i+1 >= token.size
+                if token[@i+1].attribute == "KEYWORD" then
+                  @i += 1
+                  unless @i < token.size
+                    PrintError.missing(token[@i-1],@@string)
+                    return false
+                  end
+                  unless token[@i].me == "as:"
+                    PrintError.missmatch(token[@i],@@string,"keyword 'as:' or operator")
+                    return false
+                  end
+                  @i += 1
+                  unless @i < token.size
+                    PrintError.missing_general_string(token[@i-1].position+token[@i-1],@@string)
+                    return false
+                  end
+                  return false unless check_block(token)
+                end
+              end
+              state = 2
+          end
+          
+        # checking integ arguments (full)
+        when 7  
+          unless @i < token.size
+            PrintError.missing(token[@i-1],@@string)
+            return false
+          end 
+          if token[@i].attribute == "QUOTES" then
+            return false unless check_block(token)
+          elsif token[@i].attribute != "VARIABLE" then
+            PrintError.missmatch(token[@i],@@string,"variable or block")
+            return false
+          end
+          @i += 1
+          unless @i < token.size
+            PrintError.missing_integ_range(token[@i-1].position+1,@@string)
+            return false
+          end
+          return false unless check_block(token)
+          @i += 1
+          unless @i < token.size
+            PrintError.numPoint_missing(token[@i-1].position+1,@@string)
+            return false
+          end
+          unless @i + 1 >= token.size
+            if token[@i+1].attribute == "QUOTES" then
+              @i += 1
+              return false unless check_block(token)
+            end
+          end
+          state = 2
+          
+        # checking solve args (full)   
+        when 8
+          inner_state = 0
+          while !(token[@i].attribute == "EQUALS_TO") and @i < token.size
+            case inner_state  
+              when 0
+                if token[@i].attribute == "VARIABLE" or token[@i].attribute == "NUMBER" then
+                  inner_state = 1
+                elsif token[@i].attribute == "L_BRACE"
+                  sizer = Sizer.new
+                  return false unless sizer.analyze(token[(@i+1)...token.size])
+                  @i += sizer.count + 1
+                else
+                  PrintError.unexpected_token_in_solve(token[@i],@@string)
+                  return false
+                end
+              when 1
+                if token[@i].attribute == "OPERATOR" then
+                  inner_state = 0
+                else
+                  PrintError.unexpected_token_in_solve(token[@i],@@string)
+                  return false
+                end
+            end
+            @i += 1
+          end  
+          state = 1   
+      end
+      @i += 1
+    end
+    
+    unless state == 2 or state == 5 
+      if token[@i-1].attribute == "R_BRACE" then
+        tk = token[@i-2]
+      else
+        tk = token[@i-1]
+      end 
+      PrintError.missing(tk,@@string)
+      return false
+    end
+    return true
+  end
+  
+  def count
+    return @i
+  end
+
+ private
+  def balanced_brackets?(exp)
+    open_b = 0
+    for i in 0...exp.size
+      open_b += 1 if exp[i] == "("
+      open_b -= 1 if exp[i] == ")"
+    end
+    open_b == 0 ? (return true) : (return false)
+  end 
+  
+  def check_block(token)
+    unless token[@i].attribute == "QUOTES" then
+      PrintError.missmatch(token[@i],@@string,"quotes for block")
+      return false
+    end
+    @i += 1
+    unless @i < token.size
+      PrintError.missing_general_string(token[@i-1].position+token[@i-1].me.size,@@string,)
+      return false
+    end
+    unless token[@i].attribute == "GENERAL_STRING" then
+      PrintError.missmatch(token[@i],@@string,"block argument")
+      return false
+    end
+    @i += 1
+    unless @i < token.size
+      PrintError.no_final_quotes(@@string,token[@i-1].position+token[@i-1].me.size)
+      return false
+    end
+    unless token[@i].attribute == "QUOTES" then
+      PrintError.missmatch(token[@i],@@string,"quotes for block")
+      return false
+    end
+    return true
+  end
+  
+end

data/lib/linmeric/Token.rb

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+
+require_relative 'CnGal_tools.rb'
+require_relative 'CnGal_new_classes.rb'
+
+class Token
+  OPERATORS = Tool.operators
+  VARIABLE = /[a-zA-Z_][a-zA-Z0-9_]*/
+  def initialize(to_token,pos,sugg = "")
+    @My_pos = pos
+    if OPERATORS.include? to_token then   
+      @My_att = "OPERATOR" unless [">","=","+","-"].include? to_token
+      @My_att = "EQUAL_OP" if to_token == "="
+      @My_att = "TO_FILE_OP" if to_token == ">"
+      @My_att = "SUM_OPERATOR" if '+-'.include? to_token
+    elsif sugg != ""
+      @My_att = sugg
+    elsif to_token == "~"
+      @My_att = "EQUALS_TO"
+    elsif to_token.include? ":" then
+      @My_att = "KEYWORD"
+    elsif to_token.match(VARIABLE).to_s.size == to_token.size then
+      @My_att = "VARIABLE"
+    elsif to_token.number? then
+      @My_att = "NUMBER"
+    elsif to_token == "(" then
+      @My_att = "L_BRACE"
+    elsif to_token == ")" then
+      @My_att = "R_BRACE"
+    elsif to_token == '"' then
+      @My_att = "QUOTES"
+    else
+      @My_att = "GENERAL_STRING"
+    end
+    @My_self = (to_token.include? ':') ? (to_token.downcase) : (to_token)
+  end
+  
+  def attribute
+    return @My_att
+  end
+  
+  def position
+    return @My_pos
+  end
+  
+  def me
+    return @My_self
+  end
+  
+  def show
+   return [@My_att,@My_pos,@My_self]
+  end
+end