iparser 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0106d75e819c43af7da5c282d661c29a5c90e8ea
-  data.tar.gz: 1cebe402197c60e390f477b5d9331c70ea8f520b
+  metadata.gz: 9a12b304b0cfd0fc94f9043f03321648f95f2a60
+  data.tar.gz: 48f5b42bf26ec9cc78ba8ec443085325693a9173
 SHA512:
-  metadata.gz: 1464526b0c4670428996b7dde12b96366dba8a27c9fa7a701265313904d4f0c97193338cf6f058b0a65dddae73eeea8e11cc4534db8c249c372d4978d15537a0
-  data.tar.gz: 5ecbdd4e9ad9f5a494ff109b816f2bf5290e5dc6d8b3882b18ce74a4304d3f856d524ff0075e0ca7032114bbba5ad90d1a71b4f2dc86064b07a00d6699bd6e01
+  metadata.gz: c0d50e2ccdd4cc0393a302869fffe3d10ece69ffb828f761fda020c06bbf5edd56a8aa3ea0e57ca4b3079b077b38b38e9058451a59e4fa1e0e2c499b56692bbf
+  data.tar.gz: 42e50dd5f5a159452909a9aeaf52428c203fac762872221d2a308fcd273bd7313ca4a00f855b9611784b6b3e9f91829607c855f74bec6ea710ae5ea45a8a9ff9

data/README.md

@@ -1,6 +1,6 @@
 # Iparser
 
-Universal parser machine to generate your specific parsers.
+Universal parser machine to generate your specific parsers (Parser engine).
 Used for simple and fast create your specific parsers.
 
 ## Installation
@@ -22,249 +22,174 @@ Or install it yourself as:
 ## Usage
 
 For example usage, present here very simple parser for automatically generate documentation from source code.
+Create file 'parser_example.rb' and copy the contents from the file *source № 1*.
 
 *source № 1*:
 ```ruby
 require 'iparser'
 
-#
 # Create parser-machine object.
-#
 parser = Iparser::Machine.new
-
-#
 # Create startup state for this parser-machine.
-#
 ps_idle = Iparser::State.new('idle')
-
-#
-# Add branch indexes to 'comment-line' and 'comment-block' state.
-#
-ps_idle.branches << 1
-ps_idle.branches << 2
-
-#
 # Create single line comment state for this parser-machine.
-#
 ps_cline = Iparser::State.new('comment-line')
-ps_cline.entry << /\//
-ps_cline.entry << /\//
-ps_cline.entry << /\//
-ps_cline.leave << /[\n\r]/
-
-#
 # Create multiline comment state for this parser-machine.
-#
 ps_cblock = Iparser::State.new('comment-block')
-ps_cblock.entry << /\//
-ps_cblock.entry << /\*/
-ps_cblock.entry << /\*/
-ps_cblock.leave << /\*/
-ps_cblock.leave << /\//
-ps_cblock.ignore << '*'
 
-#
 # Add all states to parser-machine.
-#
 parser.addstate ps_idle
 parser.addstate ps_cline
 parser.addstate ps_cblock
 
-#
+# Describe 'comment-line' state.
+# Set template for entry this state (String or Regexp).
+ps_cline.entry << '/'
+ps_cline.entry << '/'
+ps_cline.entry << '/'
+# Set template for leave this state (String or Regexp).
+ps_cline.leave << /[\n\r]/
+# Add handler to 'commaent-line' state.
+ps_cline.init( method(:doc_init) )
+ps_cline.handler( method(:doc_handler) )
+ps_cline.fini( method(:doc_fini) )
+# Add branch indexes to 'comment-line' and 'comment-block' state.
+# From 'idle' we can branch to 'comment-line' or 'comment-block' states.
+ps_idle.branches << parser.state_index( ps_cline )
+ps_idle.branches << parser.state_index( ps_cblock )
+
+# Describe 'comment-block' state.
+# Set template for entry this state (String or Regexp).
+ps_cblock.entry << '/'
+ps_cblock.entry << '*'
+ps_cblock.entry << '*'
+# Set template for leave this state (String or Regexp).
+ps_cblock.leave << '*'
+ps_cblock.leave << '/'
+# Set template for ignore this state (String format only).
+ps_cblock.ignore << '*'
+
 # Call parser startup method.
-#
 parser.prestart
-
-#
 # Call interactive mode for check state-machine.
-#
 parser.interactive_parser
 ```
 
-Run this script and typing `'///'` for branch to 'comment-line' state. Then type `'\n'` or `'\r'` for leave this state.
-**NOTE**: Type `'\\'` for input `'\'`. Check each state. Press `enter` (input empty string) to leave interactive mode.
-After successfully check, add the following code to the beginning of the file:
-
-*source № 2*:
+Run this script `ruby parser_example.rb` and typing `'///'` for branch to 'comment-line' state.
+Then type `'\n'` or `'\r'` for leave this state.
+Press `enter` (input empty string) to leave interactive mode.
+Check each state.
+
+**NOTE**: Type `'\\'` for input `'\'`.
+
+Each state has the following templates:
+ 1 __entry__  - used for set condition (template) to entry state.
+ 2 __leave__  - used for set condition (template) to leave state (return to previous state).
+ 3 __ignore__ - used for set symbols to ignoring.
+ 
+After successfully check, you can add handler to each state.
+Each state has the following handlers:
+ 1 __init__ - is state contructor (called when entry to state).
+ 2 __fini__ - is state destructor (called when leave state).
+ 3 __handler__ - is state handler (called every time, is still in state).
+
+Each handler can return the following values: __nil__ - nothing is done (method `.parse` return `true`)
+and __any__ values for break parsing (method `.parse` return `false`). For break parsing process you
+should check return value of `.parse` method. For example:
 ```ruby
-#
-# Simple check startup arguments.
-#
-if( ARGV.size != 1 || !File.exist?(ARGV[0]) )
-  puts
-  puts "ERROR: unable to open file #{ARGV[0]}"
-  puts
-  exit
-end
-#
-# Create output file.
-#
-$fout = File.new( 'index.html', 'w' )
-
-#
-# Create initializer method for parser-states.
-#
-def doc_init ( str )
-  $fout.print "<p>"
-end
-#
-# Create handler method for parser-states.
-#
-def doc_handler ( c )
-  $fout.print c
-end
-#
-# Create finalizer method for parser-states.
-#
-def doc_fini ( str )
-  $fout.puts "</p>"
-end
-```
-Method `doc_init` is state contructor.
-Method `doc_handler` is state handler and call in `comment-line` or `comment-block` for each input char.
-Method `doc_fini` is state destructor.
-
-Handler may be return following data types: `Fixnum` - index to branch (>=0),
-`NilClass` - hold current state (nil) and any data types for break parse (error, method `parse`
-return `false`).
-
-For `comment-block` state set ignore char - `*`, and handler don't called to this chars.
-
-Add the following code instead `parser.interactive_parser`:
-
-*source № 3*:
-```ruby
-$fout.puts "<html>"
-$fout.puts "<body>"
-
-File.open( ARGV[0], 'r' ).each do |line|
-  line.each_char do |c|
-    parser.parse(c)
-  end
+parser = Iparser::Machine.new
+'123asd'.each_char do |c|
+  exit if !parser.parse(c)
 end
-
-$fout.puts "</body>"
-$fout.puts "</html>"
-$fout.close
 ```
+Also each state have a `branches` field. Use the `branches` to add the index state,
+which is a possible jump.
 
-And add this code (*source № 4*) before `addstate` method call.
-
-*source № 4*:
-```ruby
-#
-# Add handlers for states.
-#
-ps_cline.init( method(:doc_init) )
-ps_cline.handler( method(:doc_handler) )
-ps_cline.fini( method(:doc_fini) )
+We create the following handlers:
 
-ps_cblock.init( method(:doc_init) )
-ps_cblock.handler( method(:doc_handler) )
-ps_cblock.fini( method(:doc_fini) )
-```
+* Method `doc_init` is state destructor.
+* Method `doc_handler` is state handler and call in `comment-line` or `comment-block` for each input char.
+* Method `doc_fini` is state destructor.
 
-The result is a file with the following content.
+For `comment-block` state set ignore char - `*`, and handler don't called to this chars.
+The result is a file with the following content of 'parser_example.rb':
 
-*source № 5*:
+*source № 2*:
 ```ruby
 require 'iparser'
 
-#
 # Simple check startup arguments.
-#
 if( ARGV.size != 1 || !File.exist?(ARGV[0]) )
   puts
   puts "ERROR: unable to open file #{ARGV[0]}"
   puts
   exit
 end
-#
+
 # Create output file.
-#
 $fout = File.new( 'index.html', 'w' )
 
-#
 # Create initializer method for parser-states.
-#
 def doc_init ( str )
   $fout.print "<p>"
 end
-#
 # Create handler method for parser-states.
-#
 def doc_handler ( c )
   $fout.print c
 end
-#
 # Create finalizer method for parser-states.
-#
 def doc_fini ( str )
   $fout.puts "</p>"
 end
 
-#
 # Create parser-machine object.
-#
 parser = Iparser::Machine.new
-
-#
 # Create startup state for this parser-machine.
-#
 ps_idle = Iparser::State.new('idle')
-
-#
-# Add branch indexes to 'comment-line' and 'comment-block' state.
-#
-ps_idle.branches << 1
-ps_idle.branches << 2
-
-#
 # Create single line comment state for this parser-machine.
-#
 ps_cline = Iparser::State.new('comment-line')
-ps_cline.entry << /\//
-ps_cline.entry << /\//
-ps_cline.entry << /\//
-ps_cline.leave << /[\n\r]/
-
-#
 # Create multiline comment state for this parser-machine.
-#
 ps_cblock = Iparser::State.new('comment-block')
-ps_cblock.entry << /\//
-ps_cblock.entry << /\*/
-ps_cblock.entry << /\*/
-ps_cblock.leave << /\*/
-ps_cblock.leave << /\//
-ps_cblock.ignore << '*'
 
-#
-# Add handlers for states.
-#
+# Add all states to parser-machine.
+parser.addstate ps_idle
+parser.addstate ps_cline
+parser.addstate ps_cblock
+
+# Describe 'comment-line' state.
+# Set template for entry this state (String or Regexp).
+ps_cline.entry << '/'
+ps_cline.entry << '/'
+ps_cline.entry << '/'
+# Set template for leave this state (String or Regexp).
+ps_cline.leave << /[\n\r]/
+# Add handler to 'commaent-line' state.
 ps_cline.init( method(:doc_init) )
 ps_cline.handler( method(:doc_handler) )
 ps_cline.fini( method(:doc_fini) )
-
+# Add branch indexes to 'comment-line' and 'comment-block' state.
+# From 'idle' we can branch to 'comment-line' or 'comment-block' states.
+ps_idle.branches << parser.state_index( ps_cline )
+ps_idle.branches << parser.state_index( ps_cblock )
+
+# Describe 'comment-block' state.
+# Set template for entry this state (String or Regexp).
+ps_cblock.entry << '/'
+ps_cblock.entry << '*'
+ps_cblock.entry << '*'
+# Set template for leave this state (String or Regexp).
+ps_cblock.leave << '*'
+ps_cblock.leave << '/'
+# Set template for ignore this state (String format only).
+ps_cblock.ignore << '*'
+# Add handler to 'commaent-block' state.
 ps_cblock.init( method(:doc_init) )
 ps_cblock.handler( method(:doc_handler) )
 ps_cblock.fini( method(:doc_fini) )
 
-#
-# Add all states to parser-machine.
-#
-parser.addstate ps_idle
-parser.addstate ps_cline
-parser.addstate ps_cblock
-
-#
 # Call parser startup method.
-#
 parser.prestart
 
-#
-# Call interactive mode for check state-machine.
-#
 $fout.puts "<html>"
 $fout.puts "<body>"
 
@@ -281,7 +206,7 @@ $fout.close
 
 Now developing of the simple parser has been finished. You can create test file, for example 'test.c':
 
-*source № 6*:
+*source № 3*:
 ```
 #include <stdlib.h>
 
@@ -297,9 +222,9 @@ void test2 ( void )
 }
 ```
 
-and do folow command in command line as:
+and execute folow command in command line as:
 
-    $ ruby <you parser script name>.rb test.c
+    $ ruby parser_example.rb test.c
 
 After work, we should see a file named 'index.html'.
 
@@ -323,29 +248,46 @@ After work, we should see a file named 'index.html'.
 
 **NOTE**: для ввода символа `'\'` необходимо набрать `'\\'`.
 
-Если все переходы работают как мы и ожидали, то
-можно перейти к написанию обработчиков наших состояний. Для этого допишем в наш скрипт код из *source № 2*
-в начало файла и вместо строки `parser.interactive_parser` добавим код из *source № 3* и *source № 4*.
-В результате должен получится код как на *source № 5*.
+Если все переходы работают как мы и ожидали, то можно перейти к написанию обработчиков наших состояний.
 
 Метод `doc_init` будет вызываться при входе в состояние, т.е. является конструктором состояния.
 Метод `doc_handler` будет вызываться каждый раз, до тех пор пока парсер находится в состоянии `comment-line` или `comment-block`.
 Метод `doc_fini` будет вызываться при выходе из состояния, т.е. является деструктором состояния.
 
-Обработчик состояния должен возвращать следующие типы данных:  `Fixnum` - индекс состояния на которое надо перейти (>=0),
-`NilClass` - оставаться в текущем состоянии (nil) и остальные типы данных которые будут расценены как ошибка
-обработки и метод `parse` вернет `false` (error). Во всех остальных случаях `parse` возвращает `true`.
+Обработчики состояния должены возвращать следующие значения: __nil__ - говорит парсер-машине о том,
+что процесс разбора продолжается и метод `.parse` вернет `true` и любое отличное от __nil__ значение
+будет разценено парсером как ошибка обработки и метод `.parse` вернет `false`. Для того, чтобы
+прервать процесс процесс парсинга, следует анализировать возвращаемое значение метода `,parse`,
+например так:
+```ruby
+parser = Iparser::Machine.new
+'123asd'.each_char do |c|
+  exit if !parser.parse(c)
+end
+```
+Также, каждое состояние имеет поле `branches`, для добавление индекса состояний на которые
+возможен переход из текущего состояния.
 
 Дополнительно для состояния `comment-block` мы указали символы, которые надо игнорировать,
 а именно `'*'` и `doc_handler` не будет вызываться при наличия данного символа во входном потоке.
+По окончанию мы получим файл с содержимым из *source № 2*.
 
-И наконец создадим тестовый файл с именем 'test.c' и наполним его содержимым из *source № 6*.
+И наконец создадим тестовый файл с именем 'test.c' и наполним его содержимым из *source № 3*.
 Наш простой парсер готов. Теперь запустим его набрав следующую команду:
 
     $ ruby parser_example.rb test.c
 
 По окончанию работы мы должны увидеть файл с именем 'index.html'.
 
+## Patch
+
+Details information for each patch.
+
+##### 1.1.4
+* Add method `.state_index` for return index of parser-state.
+* Add analyes result of any handler (init, fini, handler).
+* Now `entry` and `leave` templates you can set a string or regular expression.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/iparser.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["gera-gas"]
   spec.email         = ["gera_box@mail.ru"]
 
-  spec.summary       = %q{Universal parser machine to generate your specific parsers.}
-  spec.description   = %q{Universal parser machine implementation with interactive mode.}
+  spec.summary       = %q{Universal parser machine implementation with interactive mode. Can be used as a parser engine.}
+  spec.description   = %q{}
   spec.homepage      = "https://github.com/gera-gas/iparser"
   spec.license       = "MIT"
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

data/lib/iparser.rb

@@ -1,30 +1,22 @@
 #--
 # iparser.rb - Universal parser machine to generate your specific parsers.
 #++
-# Parser::State.new - Create single state for parser.
-# Parser::Machine.new - Create parser machine.
-#
-require "iparser/version"
+require 'iparser/version'
 
-module Iparser  
-  ##
+module Iparser
   #  Used for describe single state
   #  of parser machine.
-  #
   class State
 
     attr_reader :statename
     attr_accessor :branches, :entry, :leave, :ientry, :ileave, :ignore
-    #
+  
     # call-seq:
     #  State.new( String )
-    #
-    # Class constructor.
-    #
     def initialize ( sname )
-
-      raise TypeError, 'Incorrectly types for <ParserState> constructor.' unless
-	sname.instance_of? String
+      unless sname.instance_of? String
+        raise TypeError, 'Incorrectly types for <Parser-State> constructor.'
+      end
 
       @statename = sname
       @init    = nil  # method called after entry (state constructor).
@@ -38,30 +30,22 @@ module Iparser
       @branches = [] # indexes of any states to branch.
     end
 
-    #
     # call-seq:
     #   init( method(:some_init_method) )
     #
     # Set initializer method for current state.
-    #
-    def init ( m )
-      raise TypeError, m.class.to_s + ': Incorrectly types for <init> method of <ParserState>.' unless
-	m.instance_of? Method
-    
-      @init = m
+    def init ( method )
+      raise TypeError, error_message(method, __method__) unless method.instance_of? Method
+      @init = method
     end
 
-    #
     # call-seq:
     #   fini( method(:some_fini_method) )
     #
     # Set finalizer method for current state.
-    #
-    def fini ( m )
-      raise TypeError, m.class.to_s + ': Incorrectly types for <fini> method of <ParserState>.' unless
-	m.instance_of? Method
-    
-      @fini = m
+    def fini ( method )
+      raise TypeError, error_message(method, __method__) unless method.instance_of? Method
+      @fini = method
     end
 
     def run_init( *args ) # :nodoc:
@@ -74,39 +58,35 @@ module Iparser
       return nil
     end
 
-    #
     # call-seq:
     #   handler( method(:some_handler_method) )
     #
     # Set handler method for current state.
-    #
-    def handler ( h )
-      raise TypeError, h.class.to_s + ': Incorrectly types for <handler> method of <ParserState>.' unless
-	h.instance_of? Method
-    
-      @handler = h
+    def handler ( method )
+      raise TypeError,  error_message(method, __method__) unless method.instance_of? Method
+      @handler = method
     end
 
     def run_handler( *args ) # :nodoc:
       return @handler.call( *args ) if @handler != nil
       return nil
     end
-
+    
+  private
+    def error_message(object, method)
+      "#{object.class}: Incorrectly types for <#{method}> method of <Parser-State>."
+    end
   end # class State
+
   
-  
-  ##
   #  Used for create parser machine.
-  #
   class Machine
+    INITIAL_STATE = 'wait'
 
     attr_reader :parserstate
-    #
+
     # call-seq:
     #  Machine.new( )
-    #
-    # Class constructor.
-    #
     def initialize ( )
       @buffer = [] # буфер для символов входного потока
       @states = [] # массив с состояниями парсера, <ParserState> объекты
@@ -121,9 +101,7 @@ module Iparser
       @parserstate = ''
     end
 
-    #
     # Сбрасывает чувствительные переменные.
-    #  
     def reset ( ) # :nodoc:
       @buffer = []
       @states.each do |s|
@@ -132,26 +110,21 @@ module Iparser
       end
     end
 
-    #
     # Initialize parser object,
     # should be called before call other methods.
-    #
     def prestart ( )
       reset( )
       @matchstate[:state] = 0
       @chain = [ @states[0], ]
     end
 
-    #
     # Display information about of each state of parser.
-    #
     def display ( )
       puts 'Parser states: ' + @states.size.to_s
 
       @states.each do |st|
 	puts
-	puts '*' * 80
-	puts 'state: ' + st.statename
+	puts '** state: ' + st.statename
 	puts 'branches: '
 	st.branches.each do |br|
 	  puts '  ' + @states[br].statename
@@ -159,17 +132,15 @@ module Iparser
       end
     end
     
-    #
     # Обработка ввода для интерактивных режимов работы.
-    #
     def interactive_input ( ) # :nodoc:
       state = 0
       rv  = ""
       str = gets
-      #
+      
       # Сразу нажата <Enter> => exit.
       return rv if str[0] == '\n'
-      #
+      
       # Выполняем разбор посимвольно.
       str.each_char do |c|
 	break if c == ?\n
@@ -206,9 +177,7 @@ module Iparser
 	  when 'f'
 	    rv += "\f"
 	  else
-	    puts
-	    puts 'ERROR: unrecognized esc-symbols.'
-	    puts
+	    puts "\nERROR: unrecognized esc-symbols.\n"
 	    exit
 	  end
 	  state = 0
@@ -217,9 +186,7 @@ module Iparser
       return rv
     end
     
-    #
     # Обработка вывода для интерактивных режимов работы.
-    #
     def interactive_output( istr ) # :nodoc:
       str = []
       istr.bytes.each do |c|
@@ -247,82 +214,88 @@ module Iparser
       return str
     end
     
-    #
     # Run parser machine for check in interactive mode.
-    #
     def interactive_parser ( )
       puts 'Press <Enter> to exit...'
-      #
+      
       # Цикл обработки ввода.
-      loop {
+      loop do
 	str = interactive_input( )
 	break if str == ""
-	#
+      
 	# Цикл посимвольной классификаци.
 	str.bytes.each do |c|
 	  parse( c.chr )
 	  puts 'parser: ' + @parserstate
 	  puts 'symbol: ' + interactive_output( c.chr ).to_s
-	  puts 'buffer: ' + @buffer.to_s
 	  puts 'state:  ' + @chain.last.statename
 	  puts
 	end
-      }
+      end
     end
 
-    #
     # call-seq:
     #  s = Parser::State.new('idle')
     #  p = Parser::Machine.new
     #  p << s
     #
     # Add any parser-state to current parser.
-    #
     def addstate ( ps )
       raise TypeError, ps.class.to_s + ': Incorrectly types for \'<<\' method of <Parser>.' unless
 	ps.instance_of? State
-
       @states << ps
     end
+    
+    # call-seq:
+    #   some_state1.branches << parser.state_index(some_state2).
+    # Return index 
+    def state_index ( state )
+      raise TypeError, ps.class.to_s + ': Incorrectly types for \'state_index\' method of <Parser>.' unless
+	state.instance_of? State
+	
+      @states.each_with_index do |st,i|
+	return i if state == st
+      end
+      raise "State <#{state.statename}> is not exist in Parser."
+    end
 
-    #
     # Сравнивает символы входного потока 
     # с символами из указанного шаблона.
     # В качестве шаблона выступают поля <entry> или <leave>
     # объектов типа <ParserState>.
-    # 
     def cmp ( tmp, idx ) # :nodoc:
-      #
+
       # проверка на случай если шаблон не задан,
       # т.е. проинициализирован в [].
-      #
       if tmp.size > 0 then
 	if idx < tmp.size then
-	  return true if @buffer.last =~ tmp[ idx ]
+	  case tmp[idx].class.to_s
+	  when 'Regexp'
+	    return true if @buffer.last =~ tmp[ idx ]
+	  when 'String'
+	    return true if @buffer.last == tmp[ idx ]
+	  end
 	end
       end
       return false
     end
 
-    #
     # Поиск в массиве указанного диапазона,
     # указанного в параметрах символа.
     #
     # >=0 : индекс совпавшего элемента.
     #  -1 : нет совпадений.
-    #
     def checkback ( tmp, len ) # :nodoc:
       if len > 0 then
 	i = len
-	len.times {
+	len.times do
 	  i = i - 1
 	  return i if cmp( tmp, i )
-	}
+	end
       end
       return -1
     end
 
-    #
     # Находит соответствие между символами входного потока
     # и возможными переходами.
     #
@@ -333,20 +306,17 @@ module Iparser
     # -1 : возврат в предыдущее состояние 
     # -2 : еще идет проверка.
     # -3 : нет cовпадений (промах).
-    #
     def classify ( state ) # :nodoc:
       case @matchstate[:state]
-      #
+	
       # Состояние еще не определено.
       # :state = 0
-      #
       when 0
 	mcount = 0
 	mindex = 0
 	backtag = 0
 	#
 	# Проверка условия выхода из состояния.
-	#
 	if cmp( state.leave, state.ileave ) then
 	  state.ileave = state.ileave.next
 	  #
@@ -375,7 +345,6 @@ module Iparser
 	#
 	# Проверка возможных переходов для
 	# указанного в параметрах состояния.
-	#
 	state.branches.each do |b|
 	  if cmp( @states[b].entry, @states[b].ientry ) then
 	    mcount = mcount + 1
@@ -383,7 +352,6 @@ module Iparser
 	    @states[b].ientry = @states[b].ientry.next
 	    #
 	    # состояние полностью пройдено.
-	    #
 	    if @states[ b ].ientry >= @states[ b ].entry.size then
 	      return b
 	    end
@@ -393,7 +361,6 @@ module Iparser
 	    # успешна, то возможно входной символ совпадает
 	    # с предыдущими, уже совпавшими символами,
 	    # т.е. как откат в режиме <wait>.
-	    #
 	    i = checkback( @states[b].entry, @states[b].ientry )
 
 	    if i != -1 then
@@ -407,7 +374,6 @@ module Iparser
 	end
 	#
 	# Анализ количества совпадений.
-	#
 	case mcount
 	#
 	# нет совпадений.
@@ -416,7 +382,6 @@ module Iparser
 	#
 	# однозначное совпадение, но весь массив шаблонов
 	# еще не пройден.
-	#
 	when 1
 	  @matchstate[:state] = 1
 	  @matchstate[:index] = mindex
@@ -426,10 +391,9 @@ module Iparser
 	else
 	  return -2
 	end
-      ##
+	
       # Состояние точно определено.
       # :state = 1
-      #
       when 1
 	i = @matchstate[:index]
 	if cmp( @states[ i ].entry, @states[ i ].ientry ) then
@@ -439,7 +403,6 @@ module Iparser
 	  #
 	  # Массив шаблонов совпадает полностью.
 	  # можно считать, что 100% совпадение.
-	  #
 	  if @states[ i ].ientry >= @states[ i ].entry.size then
 	    @matchstate[:state] = 0
 	    return i
@@ -451,7 +414,6 @@ module Iparser
 	# успешна, то возможно входной символ совпадает
 	# с предыдущими, уже совпавшими символами,
 	# т.е. как откат в режиме <wait>.
-	#
 	idx = checkback( @states[i].entry, @states[i].ientry )
 
 	if idx != -1 then
@@ -460,20 +422,16 @@ module Iparser
 	end
 	@states[i].ientry = 0
 	@matchstate[:state] = 0
-	#return (-3 + backtag)
-	#return -4
 	return -3
       end # case @matchstate
     end
 
-    #
     # Main method, used for parse input stream.
     # Parse will be starting in unit with nil index (0).
     #
     # Return true if parsing process is successful, else return false.
-    #
     def parse ( c )
-      @parserstate = 'wait'
+      @parserstate = INITIAL_STATE
       retval = true
       #
       # * Фиксированное состояние (определенное): -1.
@@ -481,46 +439,46 @@ module Iparser
       # * Переход (смена состояний): >0.
       # 
       @buffer << c
-      
-      #
+
       # Проверка переходов в другие состояния.
-      #
       r = classify( @chain.last )
 
-      #
       # Переход (прыжок) в другое состояние.
       # <branch>:
-      #
       if r >= 0 then
 	@chain << @states[r]
-	@chain.last.run_init( @buffer )
-	reset( )
-	@parserstate = 'branch'
-      #
+	if @chain.last.run_init( @buffer ) == nil then
+	  reset( )
+	  @parserstate = 'branch'
+	else
+	  @parserstate = 'error'
+	  retval = false
+	end
+	
       # Возврат из текущего состояния.
       # <back>:
-      #
       elsif r == -1 then
-	@chain.last.run_fini( @buffer )
-	#
-	# если это состояние не первое в цепочке
-	# тогда откатываемся назад.
-	#
-	if @chain.size > 1 then
-	  @chain.delete_at( @chain.size - 1 )
+	if @chain.last.run_fini( @buffer ) == nil then
+	  #
+	  # если это состояние не первое в цепочке
+	  # тогда откатываемся назад.
+	  if @chain.size > 1 then
+	    @chain.delete_at( @chain.size - 1 )
+	  end
+	  reset( )
+	  @parserstate = 'back'
+	else
+	  @parserstate = 'error'
+	  retval = false
 	end
-	reset( )
-	@parserstate = 'back'
-      #
+	
       # Нет совпадений.
       # <miss>:
-      #
       elsif r == -3 then
 	#
 	# если в процессе состояния <wait>
 	# мы попали в <miss>, то накопленный
 	# буфер надо обработать.
-	#
 	@buffer.each do |ch|
 	  @parserstate = 'miss'
 	  tag = true
@@ -531,7 +489,6 @@ module Iparser
 	    r = @chain.last.run_handler( ch )
 	    #
 	    # Анализ результата обработки состояния.
-	    #
 	    case r.class.to_s
 	    #
 	    # Fixnum - переход на любое состояние (индекс).
@@ -549,7 +506,6 @@ module Iparser
 	    #
 	    # else - расценивается как ошибка обработки.
 	    # обработка ложится на плечи разработчика.
-	    #
 	    else
 	      @parserstate = 'error'
 	      retval = false
@@ -563,7 +519,6 @@ module Iparser
     end
     
     private :reset, :cmp, :checkback, :interactive_input, :interactive_output
-
   end # class Machine
 
-end # Module Iparser
+end

data/lib/iparser/version.rb

@@ -1,3 +1,3 @@
 module Iparser
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iparser
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - gera-gas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-29 00:00:00.000000000 Z
+date: 2015-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Universal parser machine implementation with interactive mode.
+description: ''
 email:
 - gera_box@mail.ru
 executables: []
@@ -79,6 +79,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Universal parser machine to generate your specific parsers.
+summary: Universal parser machine implementation with interactive mode. Can be used
+  as a parser engine.
 test_files: []
 has_rdoc: