iparser 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74b3def90b2fb587ba964156f44d311a931f9978
+  data.tar.gz: b6fa824918d59bcce6ec0867ef778c4b097b3475
+SHA512:
+  metadata.gz: 8a56f7c33f4582f05e655ea0d1106d4e6f54ead2d57c274d6fb018ff942160ae2594df1b346b16ff5307ae0bb48adee902ee1b501f6e6589dd9c8f002f11a26b
+  data.tar.gz: d3426a1e514372f664b8801caab325ebd66c3063c4c7732efe868daf3f5abec4d1285264dbaf9122a943d9d8ec016f2fdddb97178265e5d18ac0fc6808d0a309

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iparser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 anton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,227 @@
+# Iparser
+
+Universal parser machine to generate your specific parsers.
+Used for simple and fast create your specific parsers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parser
+
+## Usage
+
+For example usage, present here very simple parser for automatically generate documentation from source code.
+
+*source № 1*:
+```ruby
+#
+# 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
+
+#
+# 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.
+After successfully check, add the following code to the beginning of the file:
+
+*source № 2*:
+```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
+end
+
+$fout.puts "</body>"
+$fout.puts "</html>"
+$fout.close
+```
+Now developing of the simple parser has been finished. You can create test file, for example 'test.c':
+
+*source № 4*:
+```
+#include <stdlib.h>
+
+///Test function - 1.
+void test1 ( void )
+{
+}
+/**
+ * Test function - 2.
+ */
+void test2 ( void )
+{
+}
+```
+
+and do folow command in command line as:
+
+    $ ruby <you parser script name>.rb test.c
+
+After work, we should see a file named 'index.html'.
+
+###### Своих не бросаем!
+------------------------
+
+Для примера использования данного gem, напишем простой парсер файла исходного кода
+для автоматической генерации документации, отдаленно напоминающего doxygen.
+Создадим ruby скрипт c именем 'parser_example.rb' и наполним его содержимым из *source № 1*.
+
+Далее запустим скрипт на выполнение:
+
+    $ ruby parser_example.rb
+
+Теперь в интерактивном режиме проверим корректность описанных нами состояний: `comment-line` и `comment-block`.
+Для чего введем строку символов `///` и увидим что наш парсер вывел `branch to <comment-line>`, это говорит
+о том, что парсер перешол в состояние для обработки однострочных комментариев, т.е. в состояние `comment-line`.
+Теперь введем `\n` или `\r` и увидим что парсер покинул состояние `comment-line` и вернулся в состояние `idle`.
+Аналогично проведем проверку для всех оставшихся состояний.
+
+**NOTE**: для ввода символа `'\'` необходимо набрать `'\\'`.
+
+Если все переходы работают как мы и ожидали, то
+можно перейти к написанию обработчиков наших состояний. Для этого допишем в наш скрипт код из *source № 2*
+в начало файла и вместо строки `parser.interactive_parser` добавим код из *source № 3*.
+
+Метод `doc_init` будет вызываться при входе в состояние, т.е. является конструктором состояния.
+Метод `doc_handler` будет вызываться каждый раз, до тех пор пока парсер находится в состоянии `comment-line` или `comment-block`.
+Метод `doc_fini` будет вызываться при выходе из состояния, т.е. является деструктором состояния.
+
+Обработчик состояния должен возвращать следующие типы данных:  `Fixnum` - индекс состояния на которое надо перейти (>=0),
+`NilClass` - оставаться в текущем состоянии (nil) и остальные типы данных которые будут расценены как ошибка
+обработки и метод `parse` вернет `false` (error). Во всех остальных случаях `parse` возвращает `true`.
+
+Дополнительно для состояния `comment-block` мы указали символы, которые надо игнорировать,
+а именно `'*'` и `doc_handler` не будет вызываться при наличия данного символа во входном потоке.
+
+И наконец создадим тестовый файл с именем 'test.c' и наполним его содержимым из *source № 4*.
+Наш простой парсер готов. Теперь запустим его набрав следующую команду:
+
+    $ ruby parser_example.rb test.c
+
+По окончанию работы мы должны увидеть файл с именем 'index.html'.
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/parser. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "iparser"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/iparser.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iparser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iparser"
+  spec.version       = Iparser::VERSION
+  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.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)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/iparser/version.rb

@@ -0,0 +1,3 @@
+module Iparser
+  VERSION = "1.1.1"
+end

data/lib/iparser.rb

@@ -0,0 +1,569 @@
+#--
+# 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"
+
+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
+
+      @statename = sname
+      @init    = nil  # method called after entry (state constructor).
+      @fini    = nil  # method called after leave (state destructor).
+      @handler = nil  # state machine for handler current state.
+      @ignore  = []
+      @ientry  = 0   # use to save compred index of this state.
+      @ileave  = 0   # use to save compred index of this state.
+      @entry   = []  # template chars for entry state.
+      @leave   = []  # template chars for leave state.
+      @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
+    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
+    end
+
+    def run_init( *args ) # :nodoc:
+      return @init.call( *args ) if @init != nil
+      return nil
+    end
+
+    def run_fini( *args ) # :nodoc:
+      return @fini.call( *args ) if @fini != nil
+      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
+    end
+
+    def run_handler( *args ) # :nodoc:
+      return @handler.call( *args ) if @handler != nil
+      return nil
+    end
+
+  end # class State
+  
+  
+  ##
+  #  Used for create parser machine.
+  #
+  class Machine
+
+    attr_reader :parserstate
+    #
+    # call-seq:
+    #  Machine.new( )
+    #
+    # Class constructor.
+    #
+    def initialize ( )
+      @buffer = [] # буфер для символов входного потока
+      @states = [] # массив с состояниями парсера, <ParserState> объекты
+      @chain  = [] # цепочка работающих состояний
+      #
+      # Машина состояний для метода classify.
+      #
+      @matchstate = {
+	:state => 0,
+	:index => 0
+      }
+      @parserstate = ''
+    end
+
+    #
+    # Сбрасывает чувствительные переменные.
+    #  
+    def reset ( ) # :nodoc:
+      @buffer = []
+      @states.each do |s|
+	s.ientry = 0
+	s.ileave = 0
+      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 'branches: '
+	st.branches.each do |br|
+	  puts '  ' + @states[br].statename
+	end
+      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
+	case state
+	  #
+	  # Сборка символов и проверка на наличие
+	  # экранирующего символа, значит это ESC-символы.
+	when 0
+	  if c == '\\' then
+	    state = 1
+	  else
+	    rv += c
+	  end
+	  #
+	  # Анализ ESC символа.
+	when 1
+	  case c
+	  when '0'
+	    rv += "\0"
+	  when 'n'
+	    rv += "\n"
+	  when 'r'
+	    rv += "\r"
+	  when '\\'
+	    rv += "\\"
+	  when 'a'
+	    rv += "\a"
+	  when 'b'
+	    rv += "\b"
+	  when 't'
+	    rv += "\t"
+	  when 'v'
+	    rv += "\v"
+	  when 'f'
+	    rv += "\f"
+	  else
+	    puts
+	    puts 'ERROR: unrecognized esc-symbols.'
+	    puts
+	    exit
+	  end
+	  state = 0
+	end
+      end
+      return rv
+    end
+    
+    #
+    # Обработка вывода для интерактивных режимов работы.
+    #
+    def interactive_output( istr ) # :nodoc:
+      str = []
+      istr.bytes.each do |c|
+	case c
+	when 0
+	  str << c.to_s + ":\\0"
+	when 10
+	  str << c.to_s + ":\\n"
+	when 13
+	  str << c.to_s + ":\\r"
+	when 7
+	  str << c.to_s + ":\\a"
+	when 8
+	  str << c.to_s + ":\\b"
+	when 9
+	  str << c.to_s + ":\\t"
+	when 11
+	  str << c.to_s + ":\\v"
+	when 12
+	  str << c.to_s + ":\\f"
+	else
+	  str << c.to_s + ":" + c.chr
+	end
+      end
+      return str
+    end
+    
+    #
+    # Run parser machine for check in interactive mode.
+    #
+    def interactive_parser ( )
+      puts 'Press <Enter> to exit...'
+      #
+      # Цикл обработки ввода.
+      loop {
+	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
+
+    #
+    # 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
+
+    #
+    # Сравнивает символы входного потока 
+    # с символами из указанного шаблона.
+    # В качестве шаблона выступают поля <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 ]
+	end
+      end
+      return false
+    end
+
+    #
+    # Поиск в массиве указанного диапазона,
+    # указанного в параметрах символа.
+    #
+    # >=0 : индекс совпавшего элемента.
+    #  -1 : нет совпадений.
+    #
+    def checkback ( tmp, len ) # :nodoc:
+      if len > 0 then
+	i = len
+	len.times {
+	  i = i - 1
+	  return i if cmp( tmp, i )
+	}
+      end
+      return -1
+    end
+
+    #
+    # Находит соответствие между символами входного потока
+    # и возможными переходами.
+    #
+    # При совпадени возвращает индекс состояния
+    # в массиве состояний, иначе:
+    #
+    # >0 : прыжок в новое состояние
+    # -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
+	  #
+	  # Возврат в предыдущее состояние.
+	  if state.ileave >= state.leave.size then
+	    return -1
+	  end
+	  backtag = 1
+	else
+	  #
+	  # Нет совпадения, но если уже часть сравнений
+	  # успешна, то возможно входной символ совпадает
+	  # с предыдущими, уже совпавшими символами,
+	  # т.е. как откат в режиме <wait>.
+	  #
+	  i = checkback( state.leave, state.ileave )
+
+	  if i != -1 then
+	    state.ileave = i.next
+	    backtag = 1
+	  else
+	    state.ileave = 0
+	    backtag = 0
+	  end
+	end
+	#
+	# Проверка возможных переходов для
+	# указанного в параметрах состояния.
+	#
+	state.branches.each do |b|
+	  if cmp( @states[b].entry, @states[b].ientry ) then
+	    mcount = mcount + 1
+	    mindex = b
+	    @states[b].ientry = @states[b].ientry.next
+	    #
+	    # состояние полностью пройдено.
+	    #
+	    if @states[ b ].ientry >= @states[ b ].entry.size then
+	      return b
+	    end
+	  else
+	    #
+	    # Нет совпадения, но если уже часть сравнений
+	    # успешна, то возможно входной символ совпадает
+	    # с предыдущими, уже совпавшими символами,
+	    # т.е. как откат в режиме <wait>.
+	    #
+	    i = checkback( @states[b].entry, @states[b].ientry )
+
+	    if i != -1 then
+	      mcount = mcount + 1
+	      mindex = b
+	      @states[b].ientry = i.next
+	    else
+	      @states[b].ientry = 0
+	    end
+	  end
+	end
+	#
+	# Анализ количества совпадений.
+	#
+	case mcount
+	#
+	# нет совпадений.
+	when 0
+	  return (-3 + backtag)
+	#
+	# однозначное совпадение, но весь массив шаблонов
+	# еще не пройден.
+	#
+	when 1
+	  @matchstate[:state] = 1
+	  @matchstate[:index] = mindex
+	  return -2
+	#
+	# нет однозначного соответствия.
+	else
+	  return -2
+	end
+      ##
+      # Состояние точно определено.
+      # :state = 1
+      #
+      when 1
+	i = @matchstate[:index]
+	if cmp( @states[ i ].entry, @states[ i ].ientry ) then
+	  #
+	  # Инкремент счетчика (индекса) вхождений.
+	  @states[ i ].ientry = @states[ i ].ientry.next
+	  #
+	  # Массив шаблонов совпадает полностью.
+	  # можно считать, что 100% совпадение.
+	  #
+	  if @states[ i ].ientry >= @states[ i ].entry.size then
+	    @matchstate[:state] = 0
+	    return i
+	  end
+	  return -2
+	end
+	#
+	# Нет совпадения, но если уже часть сравнений
+	# успешна, то возможно входной символ совпадает
+	# с предыдущими, уже совпавшими символами,
+	# т.е. как откат в режиме <wait>.
+	#
+	idx = checkback( @states[i].entry, @states[i].ientry )
+
+	if idx != -1 then
+	  @states[i].ientry = idx.next
+	  return -2
+	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'
+      retval = true
+      #
+      # * Фиксированное состояние (определенное): -1.
+      # * Не фиксированное состояние (неопределенное): -2.
+      # * Переход (смена состояний): >0.
+      # 
+      @buffer << c
+      
+      #
+      # Проверка переходов в другие состояния.
+      #
+      r = classify( @chain.last )
+
+      #
+      # Переход (прыжок) в другое состояние.
+      # <branch>:
+      #
+      if r >= 0 then
+	@chain << @states[r]
+	@chain.last.run_init( @buffer )
+	reset( )
+	@parserstate = 'branch'
+      #
+      # Возврат из текущего состояния.
+      # <back>:
+      #
+      elsif r == -1 then
+	@chain.last.run_fini( @buffer )
+	#
+	# если это состояние не первое в цепочке
+	# тогда откатываемся назад.
+	#
+	if @chain.size > 1 then
+	  @chain.delete_at( @chain.size - 1 )
+	end
+	reset( )
+	@parserstate = 'back'
+      #
+      # Нет совпадений.
+      # <miss>:
+      #
+      elsif r == -3 then
+	#
+	# если в процессе состояния <wait>
+	# мы попали в <miss>, то накопленный
+	# буфер надо обработать.
+	#
+	@buffer.each do |ch|
+	  @parserstate = 'miss'
+	  tag = true
+	  if @chain.last.ignore.size > 0 then
+	    tag = false if @chain.last.ignore.include?(ch)
+	  end
+	  if tag == true then
+	    r = @chain.last.run_handler( ch )
+	    #
+	    # Анализ результата обработки состояния.
+	    #
+	    case r.class.to_s
+	    #
+	    # Fixnum - переход на любое состояние (индекс).
+	    when 'Fixnum'
+	      if( (r >= 0) && (r < @states.size) ) then
+		@chain << @states[r]
+		reset( )
+		@parserstate = 'hardset'
+	      else
+		raise TypeError, "Method <#{@chain.last.statename}> return incorrectly index."
+	      end
+	    #
+	    # nil - ничего не возвращает.
+	    when 'NilClass'
+	    #
+	    # else - расценивается как ошибка обработки.
+	    # обработка ложится на плечи разработчика.
+	    #
+	    else
+	      @parserstate = 'error'
+	      retval = false
+	      break
+	    end
+	  end
+	end
+	@buffer = []
+      end
+      return retval
+    end
+    
+    private :reset, :cmp, :checkback, :interactive_input, :interactive_output
+
+  end # class Machine
+
+end # Module Iparser

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: iparser
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- gera-gas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Universal parser machine implementation with interactive mode.
+email:
+- gera_box@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- iparser.gemspec
+- lib/iparser.rb
+- lib/iparser/version.rb
+homepage: https://github.com/gera-gas/iparser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Universal parser machine to generate your specific parsers.
+test_files: []
+has_rdoc: