posxml_parser 1.3.1 → 2.0.0

data/lib/posxml_compiler/function.rb

@@ -0,0 +1,23 @@
+module PosxmlCompiler
+  class Function
+    attr_reader :number, :functions
+
+    def initialize
+      @functions = {}
+      @number = 0
+    end
+
+    def get(name)
+      return if name.to_s.empty?
+      if @functions[name]
+        @functions[name]
+      else
+        @functions[name] = next_number
+      end
+    end
+
+    def next_number
+      (@number += 1).to_s
+    end
+  end
+end

data/lib/posxml_compiler/instruction_not_found_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class InstructionNotFoundError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/jump.rb

@@ -0,0 +1,97 @@
+module PosxmlCompiler
+  class Jump
+    INSTRUCTION_FUNCTION     = "function"
+    INSTRUCTION_CALLFUNCTION = "callfunction"
+    INSTRUCTION_FUNCTION_END = "/function"
+
+    INSTRUCTION_WHILE        = "while"
+    INSTRUCTION_BREAK        = "break"
+    INSTRUCTION_WHILE_END    = "/while"
+
+    INSTRUCTION_IF           = "if"
+    INSTRUCTION_ELSE         = "else"
+    INSTRUCTION_IF_END       = "/if"
+
+    attr_reader :instructions, :jumps
+
+    def initialize(instructions_array)
+      @instructions = instructions_array
+      @jumps        = []
+      self.parse
+    end
+
+    def persist!
+      self.jumps.each do |jump|
+        line = self.instructions[jump.persistence][:line]
+        self.instructions[jump.persistence][:line] = line.insert(1, "#{jump.jump_value}\n")
+      end
+    end
+
+    def parse
+      instructions_indexed = self.instructions.each_with_index.to_a.reverse
+      stack_function       = []
+      stack_while          = []
+      stack_if             = []
+
+      # It's necessary parse the list of functions first because a functions can
+      # be called from anywhere, already declared or not
+      tree_function  = instructions_indexed.select do |instruction, index|
+        instruction[:name] == INSTRUCTION_FUNCTION
+      end.group_by do |instruction, index|
+        instruction[:parameters]["name"][:original]
+      end
+
+      # instruction[:point] + 1 - Because of "\n"
+      instructions_indexed.each do |instruction, index|
+        case instruction[:name]
+        when INSTRUCTION_FUNCTION_END
+          stack_function << [index, instruction[:point]]
+        when INSTRUCTION_FUNCTION
+          reference, point = stack_function.pop
+          @jumps << JumpPoint.new(self, INSTRUCTION_FUNCTION, index, reference, point)
+        when INSTRUCTION_CALLFUNCTION
+          reference, point = check_function_tree(tree_function, instruction)
+          @jumps << JumpPoint.new(self, INSTRUCTION_CALLFUNCTION, index, reference, point)
+        when INSTRUCTION_WHILE_END
+          stack_while << [index, instruction[:point]]
+        when INSTRUCTION_BREAK
+          reference, point = stack_while.last
+          raise PosxmlCompilerError.new("While not found for <break") unless reference
+          @jumps << JumpPoint.new(self, INSTRUCTION_BREAK, index, reference, point)
+        when INSTRUCTION_WHILE
+          reference, point = stack_while.pop
+          @jumps << JumpPoint.new(self, INSTRUCTION_WHILE, index, reference, point)
+          @jumps << JumpPoint.new(self, INSTRUCTION_WHILE_END, reference, index, instruction[:point] - 1)
+        when INSTRUCTION_IF_END
+          stack_if << [index, instruction[:point]]
+        when INSTRUCTION_ELSE
+          reference, point = stack_if.pop
+          @jumps << JumpPoint.new(self, INSTRUCTION_ELSE, index, reference, point)
+          stack_if << [index, instruction[:point], true]
+        when INSTRUCTION_IF
+          reference, point, is_else = stack_if.pop
+          @jumps << JumpPoint.new(self, INSTRUCTION_IF, index, reference, point)
+        end
+      end
+      # TODO add treatment for open/end statments
+      check_addition
+    end
+
+    private
+    def check_addition
+      self.jumps.each do |jump|
+        jump.check_itself!
+      end
+    end
+
+    def check_function_tree(tree, instruction)
+      function_name    = instruction[:parameters]["name"][:original]
+      unless function  = tree[function_name]
+        raise PosxmlCompilerError.new("Function #{function_name} not found") unless reference
+      end
+      function_indexed = tree[function_name][0]
+      [function_indexed[1], function_indexed[0][:point]]
+    end
+  end
+end
+

data/lib/posxml_compiler/jump_point.rb

@@ -0,0 +1,54 @@
+module PosxmlCompiler
+  class JumpPoint
+    INSTRUCTION_WHILE = "while"
+
+    attr_reader :persistence, :reference, :number, :type, :jump, :changed
+
+    def initialize(jump, type, persistence, reference, number)
+      @jump        = jump
+      @type        = type
+      @persistence = persistence
+      @reference   = reference
+      @number      = number
+    end
+
+    def changed?
+      @changed
+    end
+
+    def check_itself!
+      chars = (@number.to_s.size + 1) # \n separator between parameters
+      # chars sizes already changed and propogate, so 1 char must not included
+      chars -= 1 if changed? 
+      self.check_others(chars)
+    end
+
+    def add(index, value)
+      return if index.nil? || value.nil?
+      if self.reference > index
+        old_number = @number
+        @number += value
+        check_chars(old_number, @number)
+      end
+    end
+
+    def check_others(value)
+      self.jump.jumps.each do |jump_point|
+        jump_point.add(self.persistence, value)
+      end
+    end
+
+    def check_chars(old, new)
+      addition = new.to_s.size - old.to_s.size
+      if addition > 0
+        @changed = true
+        check_others(addition)
+      end
+    end
+
+    def jump_value
+      self.number.to_s
+    end
+  end
+end
+

data/lib/posxml_compiler/parser.rb

@@ -0,0 +1,182 @@
+# Treat for variables - ok
+# Treat for functions - ok
+# Treat number of variables - ok
+# Treat string size - ok
+# Check if variable is created before execute
+module PosxmlCompiler
+  class Parser
+    LIMIT_DEFAULT = 32000
+
+    attr_accessor :text, :xsd, :bytecodes, :variables, :limit
+
+    def initialize(source, xsd)
+      @xsd       = xsd
+      @text      = source
+      @variables = PosxmlCompiler::Variable.new(xsd, PosxmlCompiler::Function.new)
+      @bytecodes = parse(self.text)
+      @limit     = LIMIT_DEFAULT
+    end
+
+    def posxml
+      jump = PosxmlCompiler::Jump.new(self.bytecodes.dup)
+      jump.persist!
+      txt = jump.instructions.inject("") { |string, instruction| string << instruction[:line] }
+      if txt.size > self.limit
+        puts "Application size limit(#{self.limit}) exceed"
+      end
+      txt
+    end
+
+    private
+    # Clean text
+    # from:
+    #   <if variable="$(sKeyTouchScreen)" operator="equalto" value="KEY_CLEAR">
+    #   <else />
+    #   </if>
+    # to:
+    #   <if variable="$(sKeyTouchScreen)" operator="equalto" value="KEY_CLEAR"
+    #
+    #   <else
+    #
+    #   </if
+    def sanitize(txt)
+      txt.gsub("\r\n", "\n").gsub("\n\r", "\n").gsub("><", ">\n<")
+    end
+
+    # Check if an instruction end in the next line, then split by \n
+    def split_instructions(txt)
+      txt_new = ""
+      ignore = false
+      txt.split("\n").compact.each do |str|
+        line = str.strip
+        if line[0..3] == "<!--" || ignore # Check comentaries
+          ignore = true
+          ignore = false if line.include?("-->")
+        elsif line.include?("<!--") # Check end of comentaries
+          line_without_comment = line.split("<!--")[0].strip
+          txt_new << instruction_check_close(line_without_comment)
+        elsif line.include?("<") || line.include?(">")
+          txt_new << instruction_check_close(line)
+        else !ignore # For middle of instruction between lines
+          # Avoid this <pinpad.getpindukptmessage="$(sDisplayMsg)"type="3"pan="$(sPAN)"maxlen="12"variablereturnpin="$(sPIN)"variablereturnksn="$(sKSN)"variablereturn="$(iRet)"
+          txt_new << " " if txt_new[-1] != " "
+          txt_new << instruction_check_close(line)
+        end
+      end
+      txt_new.split("\n")
+    end
+
+    def instruction_check_close(str)
+      if str[-1] == ">"
+        "#{str[0..-2]}\n"
+      else
+        str
+      end
+    end
+
+    def parse(txt)
+      point = 0
+      # Split in lines and remove nil's
+      split_instructions(sanitize(txt)).inject([]) do |array, str|
+        value = str.strip
+        next(array) if value.empty?
+        # => "if", {"variable" => "$(sKeyTouchScreen)", "operator" => "equalto", "value" => "KEY_CLEAR"}
+        name, parameters = parse_line(value)
+
+        # => "if", {"variable" => {:original => "$(sKeyTouchScreen)", :value => "$(1)", :type => :string}, "operator" => {:original => "equalto", :value => "equalto", :type => :string}, "value" => {:original => "KEY_CLEAR", :value => "KEY_CLEAR", :type => :string}
+        parse_references(name, parameters)
+
+        line = parse_instruction(name, parameters)
+        size = line.size
+        array << {
+          :name => name, :parameters => parameters, :line => line, :size => size, :point => point
+        }
+        point += size
+        array
+      end
+    end
+
+    # Receive:
+    #   ("if", {"variable" => {:original => "$(sKeyTouchScreen)", :value => "$(1)", :type => :string}, "operator" => {:original => "equalto", :value => "equalto", :type => :string}, "value" => {:original => "KEY_CLEAR", :value => "KEY_CLEAR", :type => :string})
+    # Return:
+    #   "I$(1)\nequalto\nKEY_CLEAR"
+    #
+    def parse_instruction(name, parameters)
+      self.xsd.to_bytecode(name, parameters)
+    end
+
+    # Receive:
+    #   ("if", {"variable" => "$(sKeyTouchScreen)", "operator" => "equalto", "value" => "KEY_CLEAR"})
+    #   ("function", {"name" => "dosomething"})
+    # Return (changing parameter key value):
+    #   "if", {"variable" => {:original => "$(sKeyTouchScreen)", :value => "$(1)", :type => :string}, "operator" => {:original => "equalto", :value => "equalto", :type => :string}, "value" => {:original => "KEY_CLEAR", :value => "KEY_CLEAR", :type => :string})
+    #   "function", {"name" => {:original => "dosomething", :value => "1", :type => :string}})
+    #
+    def parse_references(name, parameters)
+      parameters.each do |param_name, value|
+        parameters[param_name] = self.variables.get(name, param_name, value)
+      end
+    end
+
+    # Parse line and return instruction name and parameters
+    # from:
+    #   <if variable="$(sKeyTouchScreen)" operator="equalto" value="KEY_CLEAR"
+    # to:
+    #   ["if", {"variable" => "$(sKeyTouchScreen)", "operator" => "equalto", "value" => "KEY_CLEAR"}]
+    #
+    def parse_line(str)
+      command = (str.strip[-1] == "/") ? str.strip[0..-2] : str.strip
+      index   = command.index(" ")
+
+      if index
+        [command[1..(index - 1)], parse_parameters(command[index..-1])]
+      else # Common to instruction without parameters
+        [command[1..-1], {}]
+      end
+    end
+
+    # Parse only parameters
+    # from:
+    #   variable="$(sKeyTouchScreen)" operator="equalto" value="KEY_CLEAR"
+    # to:
+    #   {"variable" => "$(sKeyTouchScreen)", "operator" => "equalto", "value" => "KEY_CLEAR"}
+    #
+    def parse_parameters(str)
+      value = ""
+      variable = ""
+      separator = nil
+      bVariable = true
+      bValue = false
+      str.strip.chars.inject({}) do |hash, ch|
+        if ch == separator
+          separator = nil
+          bVariable = true
+          bValue    = false
+          hash[variable.strip] = replace_xml_constants(value)
+          variable = ""
+          value = ""
+
+        elsif ! separator && (ch == "'" || ch == "\"")
+          separator = ch
+          bVariable = false
+          bValue    = true
+
+        elsif bVariable && ch == "="
+          bVariable = false
+
+        elsif bValue
+          value << ch
+
+        elsif bVariable
+          variable << ch
+        end
+        hash
+      end
+    end
+
+    def replace_xml_constants(str)
+      str.gsub("&quot;", "\"").gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&")
+    end
+  end
+end
+

data/lib/posxml_compiler/posxml_compiler_error.rb

@@ -0,0 +1,4 @@
+module PosxmlCompiler
+  class PosxmlCompilerError < StandardError
+  end
+end

data/lib/posxml_compiler/string_size_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class StringSizeError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/variable.rb

@@ -0,0 +1,235 @@
+module PosxmlCompiler
+  class Variable
+    VARIABLE_REFERENCE       = "$("
+    VARIABLE_STRING_MAX_SIZE = 2048
+    VARIABLE_STRING_LIMIT    = 256
+    VARIABLE_LIMIT           = 512
+
+    FUNCTION_NAME            = "function"
+    FUNCTION_PARAMETER       = "name"
+    CALLFUNCTION_NAME        = "callfunction"
+    VARIABLE_STRING          = "stringvariable"
+    VARIABLE_INTEGER         = "integervariable"
+    VARIABLE_PARAMETER_VALUE = "value"
+    VARIABLE_PARAMETER_NAME  = "variable"
+
+    attr_accessor :number_strings, :variables, :number, :xsd, :functions
+
+    def initialize(xsd, functions)
+      @functions       = functions
+      @number          = 0
+      @number_strings  = 0
+      @variables       = {}
+      @xsd             = xsd
+    end
+
+    def check_typing_mismatch(instruction, parameter_name, variable_struct)
+      type = self.xsd.parameter_type(instruction, parameter_name)
+
+      return true if type == :string_or_integer
+
+      case variable_struct[:type]
+      when type # match everything is ok
+      when :string_or_integer # match everything is ok
+      when nil # not defined yet, it's ok for now
+      when :string
+        raise PosxmlCompiler::VariableTypeError.new("Variable type #{variable_struct[:type]} mismatch, instruction #{instruction}, parameter #{parameter_name}, xsd type #{type}.")
+      when :integer
+        raise PosxmlCompiler::VariableTypeError.new("Variable type #{variable_struct[:type]} mismatch, instruction #{instruction}, parameter #{parameter_name}, xsd type #{type}.")
+      else
+        raise PosxmlCompiler::VariableTypeError.new("Variable type #{variable_struct[:type]} not recognized, instruction #{instruction}, parameter #{parameter_name}, xsd type #{type}.")
+      end
+
+      return true
+    end
+
+    # reference true is a variable that is been referenced without been previously created
+    def create(instruction, parameter, value, reference = false)
+      validate_size(parameter, value)
+      case instruction
+      when FUNCTION_NAME
+        create_function_variable(value, instruction)
+      when CALLFUNCTION_NAME
+        create_function_variable(value, instruction)
+      when VARIABLE_STRING
+        create_type_variable(parameter, value, :string, reference)
+      when VARIABLE_INTEGER
+        create_type_variable(parameter, value, :integer, reference)
+      else
+        create_ordinary_variable(instruction, parameter, value, reference)
+      end
+    end
+
+    def find(instruction, parameter, name)
+      if instruction == VARIABLE_STRING || instruction == VARIABLE_INTEGER
+        if parameter == VARIABLE_PARAMETER_NAME
+          remove_reference_struct(self.variables[name])
+        else # VARIABLE_PARAMETER_VALUE can return a reference for other variable
+          self.variables[name]
+        end
+      else
+        self.variables[name]
+      end
+    end
+
+    def multiple_reference?(str, reference)
+      reference && str.include?("[")
+    end
+
+    # Receive:
+    #   ("function", "name", "functionbla")
+    #   ("if", "variable", "$(sKeyTouchScreen)")
+    #   ("if", "operator", "equalto")
+    #   ("if", "value", "KEY_CLEAR")
+    #
+    # Return:
+    #   {:original => "functionbla", :value => "functionbla", :type => :string}
+    #   {:original => "$(sKeyTouchScreen)", :value => "$(1)", :type => :string}
+    #   {:original => "$(!sBufRecv[$(iFound)])", :value => "$(2.$&3)", :type => :string}
+    #   {:original => "$(sBufRecv[$(iFound)])", :value => "$(2.$3)", :type => :string}
+    #   {:original => "equalto", :value => "equalto", :type => :string}
+    #   {:original => "KEY_CLEAR", :value => "KEY_CLEAR", :type => :string}
+    #
+    # - Important, the struct returned only has a parameter value with $()
+    #     if isn't the stringvariable and integervariable value. Because those
+    #     instructions require the variable number without $().
+    def get(instruction, parameter, value)
+      if value.include? VARIABLE_REFERENCE
+        value = remove_reference(value)
+        if variable_struct = self.find(instruction, parameter, value)
+          check_typing_mismatch(instruction, parameter, variable_struct)
+          variable_struct
+        else
+          self.create(instruction, parameter, value, true)
+        end
+      else
+        # Not a reference for other variable
+        self.create(instruction, parameter, value)
+      end
+    end
+
+    def parameter_scheme(original = nil, value = nil, type = nil, reference = false)
+      if reference
+        value, index_variable, range_index = parse_index_variable(value, reference)
+        if index_variable
+          variable1 = self.get(VARIABLE_STRING, VARIABLE_PARAMETER_VALUE, value)
+          variable2 = self.get(VARIABLE_INTEGER, VARIABLE_PARAMETER_VALUE, index_variable)
+          format = format_multiple_reference(range_index, variable1[:value], variable2[:value])
+
+          {:original => original, :value => format, :type => type, :index_variable => index_variable}
+        else
+          {:original => original, :value => "#{VARIABLE_REFERENCE}#{value})", :type => type}
+        end
+      else
+        {:original => original, :value => value, :type => type}
+      end
+    end
+
+    def next_number(name, type)
+      value = self.number += 1
+      if type == :string
+        if (self.number_strings += 1) > VARIABLE_STRING_LIMIT
+          raise PosxmlCompiler::VariableStringLimitError.new("#{type} variable #{name} exceed the number of string variables")
+        end
+      end
+      if value > VARIABLE_LIMIT
+        raise PosxmlCompiler::VariableLimitError.new("#{type} variable #{name} exceed the number of variables")
+      end
+      "$(#{value})"
+    end
+
+    private
+    def create_type_variable(parameter, value, type, reference)
+      if parameter == VARIABLE_PARAMETER_NAME
+        unless self.variables[value]
+          number = remove_reference(next_number(parameter, type))
+          self.variables[value] = self.parameter_scheme(value, number, type, true)
+        end
+        remove_reference_struct(self.variables[value])
+      else
+        # If is value, reference and the variable doesn't exists should raise an error because it wasn't declared
+        if parameter == VARIABLE_PARAMETER_VALUE && self.variables[value].nil? && reference && ! self.multiple_reference?(value, reference)
+          raise PosxmlCompiler::VariableUndefinedError.new("Variable #{value} undefined")
+        end
+        self.parameter_scheme(value, value, type, reference)
+      end
+    end
+
+    def create_function_variable(value, instruction)
+      raise PosxmlCompiler::VariableNameError.new("#{instruction} name #{value} can't be a reference") if value.include?(VARIABLE_REFERENCE)
+      self.parameter_scheme(value, self.functions.get(value), :string)
+    end
+
+    def create_ordinary_variable(instruction, parameter, value, reference)
+      if reference
+        type = self.xsd.parameter_type(instruction, parameter)
+        if self.multiple_reference?(value, reference)
+          self.parameter_scheme(value, value, type, reference)
+        else
+          raise PosxmlCompiler::VariableUndefinedError.new("Variable #{value} undefined") unless self.variables[value]
+          self.variables[value] = self.parameter_scheme(value, value, type, reference)
+        end
+      else
+        # isn't important consider a type in this case
+        self.parameter_scheme(value, value)
+      end
+    end
+
+    # parse_index_variable
+    #   receive "!sBufRecv[$(iFound)]"
+    #   return  ["!sBufRecv", iFound, true]
+    # or
+    #   receive "sBufRecv[$(iFound)]"
+    #   return  ["sBufRecv", iFound, false]
+    def parse_index_variable(value, reference)
+      #if reference && value.include?("[")
+      if self.multiple_reference?(value, reference)
+        index = "$(#{value.match(/\[\$\((.+)\)\]/)[1]})"
+        str = "$(#{value.split("[")[0]})"
+
+        if str[2] == "!"
+          str[2] = ""
+          [str, index, true]
+        else
+          [str, index, false]
+        end
+      else
+        value
+      end
+    end
+
+    def format_multiple_reference(range_index, variable1, variable2)
+      str1 = variable1.sub(VARIABLE_REFERENCE, "").sub(")", "") # Format value to be like "123"
+      str2 = variable2.sub("(", "").sub(")", "") # format value to be "$123")
+      # At the end "$(123.$&456)"
+      if range_index
+        format = "#{VARIABLE_REFERENCE}#{str1}.#{str2.insert(1, "&")})"
+      else
+        format = "#{VARIABLE_REFERENCE}#{str1}.#{str2})"
+      end
+    end
+
+    def validate_size(name, original)
+      if original.size > VARIABLE_STRING_MAX_SIZE
+        raise PosxmlCompiler::StringSizeError.new("string variable #{name} exceed #{VARIABLE_STRING_MAX_SIZE} bytes [#{original}]")
+      end
+    end
+
+    def remove_reference_struct(data)
+      return unless data
+      struct = data.dup
+      struct[:value] = remove_reference(struct[:value])
+      struct
+    end
+
+    def remove_reference(str)
+      string = str.to_s
+      if string.include? VARIABLE_REFERENCE
+        string.to_s[2..-2]
+      else
+        string
+      end
+    end
+  end
+end
+