gen-text 0.0.2

data/.yardopts

@@ -0,0 +1,2 @@
+--files sample/*
+--load yardopts_extra.rb

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-9999 Humanity
+
+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,170 @@
+Description
+-----------
+
+A generator of texts from EBNF-like grammars.
+
+Install
+-------
+
+- Install [Ruby](http://ruby-lang.org) 1.9.3 or higher.
+- `gem install gen-text`
+
+Usage
+-----
+
+Run it with the command:
+
+    gen-text file.g
+
+Here `file.g` is a file containing the grammar description which consists of the rule definitions:
+
+    nonterminal1 = expr1 ;
+    
+    nonterminal2 = expr2 ;
+    
+    nonterminal3 = expr3 ;
+    
+Nonterminals start from a letter or "\_" and may contain alphanumeric characters, "\_", "-" or ":".
+
+You may also use backquoted nonterminals:
+    
+    `nonterminal1` = expr1 ;
+    
+    `Nonterminal with arbitrary characters: [:|:]\/!` = expr2 ;
+    
+You may use the following expressions in the right part:
+
+<table>
+  <thead>
+    <tr> <td><strong>Expression</strong></td> <td><strong>Meaning</strong></td> </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <tt>"str"</tt><br/>
+        <tt>'str'</tt>
+      </td>
+      <td>
+        <p>Generate a string.</p>
+        <p>Following escape sequences are allowed: "\n", "\t", "\e" and "\." where "." is an arbitrary character.</p>
+      </td>
+    </tr>
+    <tr>
+      <td><tt>U+HHHH</tt></td>
+      <td>Generate an UTF-8 character sequence corresponding to the Unicode code. E. g.: <tt>U+000A</tt> is equivalent to <tt>"\n"</tt>.</td>
+    </tr>
+    <tr>
+      <td><tt>n</tt> (a number)</td>
+      <td>Generate a number</td>
+    </tr>
+    <tr>
+      <td><tt>m...n</tt></td>
+      <td>Generate a random number between <tt>m</tt> and <tt>n</tt> (inclusive).</td>
+    </tr>
+    <tr>
+      <td><tt>nonterm</tt></td>
+      <td>–</td>
+    </tr>
+    <tr>
+      <td colspan="2"><center><strong>Combinators</strong></center></td>
+    </tr>
+    <tr>
+      <td> <tt>expr expr</tt> </td>
+      <td>Sequence.</td>
+    </tr>
+    <tr>
+      <td>
+        <tt>expr | expr</tt>
+      </td>
+      <td>Random choice.</td>
+    </tr>
+    <tr>
+      <td>
+        <tt>
+          | expr <br/>
+          | expr
+        </tt>
+      </td>
+      <td>Random choice (another form).</td>
+    </tr>
+    <tr>
+      <td>
+        <tt>
+          | [m%] expr <br/>
+          | [n%] expr <br/>
+          | expr
+        </tt>
+      </td>
+      <td>
+        <p>Random choice with specific probabilities.</p>
+        <p>If probability is unspecified then it is calculated automatically.</p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <tt>
+          | [0.1] expr <br/>
+          | [0.3] expr <br/>
+          | expr
+        </tt>
+      </td>
+      <td>
+        The same as above. Probabilities may be specified as floating point numbers between 0.0 and 1.0.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <tt>expr*</tt> <br/>
+        <tt>expr+</tt> <br/>
+        <tt>expr?</tt> <br/>
+        <tt>expr*[n]</tt> <br/>
+        <tt>expr*[m...n]</tt> <br/>
+      </td>
+      <td>
+        <p>Repeat <tt>expr</tt> many times:</p>
+        <ul>
+          <li>0 or more times</li>
+          <li>1 or more times</li>
+          <li>0 or 1 time</li>
+          <li>exactly <tt>n</tt> times</li>
+          <li>between <tt>m</tt> and <tt>n</tt> times</li>
+        </ul>
+        <p><strong>Note:</strong> you may use <tt>inf</tt> ("infinity") instead of <tt>m</tt> or <tt>n</tt>.</p>
+      </td>
+    </tr>
+    <tr>
+      <td colspan="2"><center><strong>Ruby code insertions</strong></center></td>
+    </tr>
+    <tr>
+      <td><tt>{ code }</tt></td>
+      <td>
+        <p>Execute the code. Generate nothing.</p>
+        <p><strong>Note</strong>: all code insertions inside a rule share the same scope.</p>
+      </td>
+    </tr>
+    <tr>
+      <td><tt>{= code }</tt></td>
+      <td>Generate a string returned by the code.</td>
+    </tr>
+    <tr>
+      <td><tt>{? code }</tt></td>
+      <td>
+        <p>Condition. A code which must evaluate to true.</p>
+        <p><strong>Note</strong>: presence of this expression turns on backtracking and output buffering and may result in enormous memory usage.</p>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+TODO: Capture the generated output.
+
+Examples
+--------
+
+See them in "sample" directory.
+
+Links
+-----
+
+- [Documentation](http://www.rubydoc.info/gems/gen-text/0.0.1)
+- [Source code](https://github.com/LavirtheWhiolet/gen-text)

data/bin/gen-text

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby
+require 'gen_text/vm'
+require 'gen_text/compile'
+require 'io/with_dummy_pos'
+require 'stringio'
+
+def usage
+  puts <<-TEXT
+Usage: #{File.basename __FILE__} [options] [grammar]
+
+Reads grammar and generates random text from it.
+
+If the grammar file is not specified the the grammar is read from standard
+input.
+
+Options:
+     -h, --help             Show this message and exit.
+     -d, --debug            Turn on debug mode.
+     -c, --compile          Compile the grammar. Do not generate text.
+
+TEXT
+end
+
+grammar_file = :'-'
+compile_only = false
+until ARGV.empty?
+  case x = ARGV.shift
+  when "-h", "--help"
+    usage
+    exit
+  when "-d", "--debug"
+    $DEBUG = true
+  when "-c", "--compile"
+    compile_only = true
+  else
+    grammar_file = x
+  end
+end
+grammar =
+  begin
+    case grammar_file
+    when :'-' then STDIN.read
+    else File.read(grammar_file)
+    end
+  rescue IOError => e
+    abort e.message
+  end
+program =
+  begin
+    GenText::Compile.new.(grammar, grammar_file.to_s)
+  rescue Parse::Error => e
+    abort "error: #{e.pos.file}:#{e.pos.line+1}:#{e.pos.column+1}: #{e.message}"
+  end
+# Optimization: If the program does not cause calling out.pos=(...) then
+#   there is no way for GenText::VM to put the garbage after the pos.
+buffered, out =
+  if GenText::VM.may_set_out_pos?(program) then
+    [true, StringIO.new]
+  else
+    [false, IO::WithDummyPos.new(STDOUT)]
+  end
+begin
+  srand(Time.now.to_i)
+  GenText::VM.new.run(program, out, compile_only)
+rescue GenText::CheckFailed => e
+  abort "error: #{e.pos.file}:#{e.pos.line+1}:#{e.pos.column+1}: #{e.message}"
+ensure
+  if buffered then
+    n = out.pos
+    out.pos = 0
+    IO.copy_stream(out, STDOUT, n)
+  end
+end

data/lib/gen_text/compile.rb

@@ -0,0 +1,547 @@
+require 'parse'
+require 'gen_text/vm'
+
+module GenText
+  
+  class Compile < Parse
+    
+    # @param (see Parse#call)
+    # @return the program as an Array of <code>[:method_id, *args]</code> where
+    #   <code>method_id</code> is ID of {VM}'s method. The program may raise
+    #   {CheckFailed}.
+    def call(*args)
+      super(*args).to_vm_code
+    end
+    
+    private
+    
+    # ---- Utils ----
+    
+    INF = Float::INFINITY
+    
+    # @!visibility private
+    module ::ASTNode
+      
+      module_function
+      
+      # @return [Array<Array<(:generated_from, String)>>]
+      def generated_from(pos)
+        if $DEBUG then
+          [[:generated_from, "#{pos.file}:#{pos.line+1}:#{pos.column+1}"]]
+        else
+          []
+        end
+      end
+      
+    end
+    
+    # ---- AST & Code Generation ----
+    
+    # @!visibility private
+    Context = Struct.new :rule_scope, :rule_labels
+    
+    # @!visibility private
+    class Label
+    end
+    
+    Program = ASTNode.new :rules do
+      
+      def to_vm_code
+        rule_labels = {}; begin
+          rules.each do |rule|
+            raise Parse::Error.new(rule.pos, "rule `#{rule.name}' is defined twice") if rule_labels.has_key? rule.name
+            rule_labels[rule.name] = Label.new
+          end
+        end
+        code =
+          [
+            [:call, rule_labels[rules.first.name]],
+            [:halt],
+            *rules.map do |rule|
+              [
+                *generated_from(rule.pos),
+                rule_labels[rule.name],
+                *rule.body.to_vm_code(Context.new(new_binding, rule_labels)),
+                [:ret]
+              ]
+            end.reduce(:concat)
+          ]
+        return replace_labels_with_addresses(code)
+      end
+      
+      private
+      
+      # @return [Binding]
+      def new_binding
+        binding
+      end
+      
+      def replace_labels_with_addresses(code)
+        # Remove labels and remember their addresses.
+        addresses = {}
+        new_code = []
+        code.each do |instruction|
+          case instruction
+          when Label
+            addresses[instruction] = new_code.size
+          else
+            new_code.push instruction
+          end
+        end
+        # Replace labels in instructions' arguments.
+        this = lambda do |x|
+          case x
+          when Array
+            x.map(&this)
+          when Label
+            addresses[x]
+          else
+            x
+          end
+        end
+        return this.(new_code)
+      end
+      
+    end
+    
+    GenString = ASTNode.new :string do
+      
+      def to_vm_code(context)
+        [
+          *generated_from(pos),
+          [:push, string],
+          [:gen]
+        ]
+      end
+      
+    end
+    
+    GenNumber = ASTNode.new :from, :to do
+      
+      def to_vm_code(context)
+        [
+          *generated_from(pos),
+          [:push_rand, from..to],
+          [:gen]
+        ]
+      end
+      
+    end
+    
+    Repeat = ASTNode.new :subexpr, :from_times, :to_times do
+      
+      def to_vm_code(context)
+        raise Parse::Error.new(pos, "`from' can not be greater than `to'") if from_times > to_times
+        # 
+        subexpr_code = subexpr.to_vm_code(context)
+        # Code.
+        subexpr_label = Label.new
+        generated_from(pos) +
+        # Mandatory part (0...from_times).
+        if from_times > 0
+          loop1 = Label.new
+          loop1_end = Label.new
+          [
+            [:push, from_times], # counter
+            loop1,
+            [:goto_if_not_0, loop1_end], # if counter == 0 then goto loop1_end
+            [:call, subexpr_label],
+            [:dec], # counter
+            [:goto, loop1],
+            loop1_end,
+            [:pop] # counter
+          ]
+        else
+          []
+        end +
+        # Optional part (from_times...to_times)
+        if (to_times - from_times) == 0
+          []
+        elsif (to_times - from_times) < INF
+          loop2 = Label.new
+          loop2_end = Label.new
+          [
+            [:push_rand, (to_times - from_times + 1)], # counter
+            loop2,
+            [:goto_if_not_0, loop2_end], # if counter == 0 then goto loop2_end
+            [:push_rescue_point, loop2_end],
+            [:call, subexpr_label],
+            [:pop], # rescue point
+            [:dec], # counter
+            [:goto, loop2],
+            loop2_end,
+            [:pop], # counter
+          ]
+        else # if (to_times - from_times) is infinite
+          loop2 = Label.new
+          loop2_end = Label.new
+          [
+            loop2,
+            [:goto_if_rand_gt, 0.5, loop2_end],
+            [:push_rescue_point],
+            [:call, subexpr_label],
+            [:pop], # rescue point
+            [:goto, loop2],
+            loop2_end
+          ]
+        end +
+        # Subexpr as subroutine.
+        begin
+          after_subexpr = Label.new
+          [
+            [:goto, after_subexpr],
+            subexpr_label,
+            *subexpr.to_vm_code(context),
+            [:ret],
+            after_subexpr
+          ]
+        end
+      end
+      
+    end
+    
+    GenCode = ASTNode.new :to_s do
+      
+      def to_vm_code(context)
+        [
+          *generated_from(pos),
+          [:eval_ruby_code, context.rule_scope, self.to_s, pos.file, pos.line+1],
+          [:gen]
+        ]
+      end
+      
+    end
+    
+    CheckCode = ASTNode.new :to_s do
+      
+      def to_vm_code(context)
+        passed = Label.new
+        [
+          *generated_from(pos),
+          [:eval_ruby_code, context.rule_scope, self.to_s, pos.file, pos.line+1],
+          [:goto_if, passed],
+          [:rescue_, lambda { raise CheckFailed.new(pos) }],
+          passed
+        ]
+      end
+      
+    end
+    
+    ActionCode = ASTNode.new :to_s do
+      
+      def to_vm_code(context)
+        [
+          *generated_from(pos),
+          [:eval_ruby_code, context.rule_scope, self.to_s, pos.file, pos.line+1],
+          [:pop]
+        ]
+      end
+      
+    end
+    
+    RuleCall = ASTNode.new :name do
+      
+      def to_vm_code(context)
+        [
+          *generated_from(pos),
+          [:call, (context.rule_labels[name] or raise Parse::Error.new(pos, "rule `#{name}' not defined"))]
+        ]
+      end
+      
+    end
+    
+    Choice = ASTNode.new :alternatives do
+      
+      def to_vm_code(context)
+        # Populate alternatives' weights.
+        if alternatives.map(&:probability).all? { |x| x == :auto } then
+          alternatives.each { |a| a.weight = 1 }
+        else
+          known_probabilities_sum =
+            alternatives.map(&:probability).reject { |x| x == :auto }.reduce(:+)
+          raise Parse::Error.new(pos, "probabilities sum exceed 100%") if known_probabilities_sum > 1.00 + 0.0001
+          auto_probability =
+            (1.00 - known_probabilities_sum) / alternatives.map(&:probability).select { |x| x == :auto }.size
+          alternatives.each do |alternative|
+            alternative.weight =
+              if alternative.probability == :auto then
+                auto_probability
+              else
+                alternative.probability
+              end
+          end
+        end
+        # Populate alternatives' labels.
+        alternatives.each { |a| a.label = Label.new }
+        # Generate the code.
+        initial_weights_and_labels = alternatives.map { |a| [a.weight, a.label] }
+        end_label = Label.new
+        [
+          *generated_from(pos),
+          [:push_dup, initial_weights_and_labels],
+          [:weighed_choice],
+          *alternatives.map do |alternative|
+            [
+              alternative.label,
+              *alternative.subexpr.to_vm_code(context),
+              [:goto, end_label],
+            ]
+          end.reduce(:concat),
+          end_label,
+          [:pop], # rescue_point
+          [:pop], # weights_and_labels
+        ]
+      end
+      
+    end
+    
+    ChoiceAlternative = ASTNode.new :probability, :subexpr do
+      
+      # Used by {Choice#to_vm_code} only.
+      # @return [Numeric]
+      attr_accessor :weight
+      
+      # Used by {Choice#to_vm_code} only.
+      # @return [Label]
+      attr_accessor :label
+      
+    end
+    
+    Seq = ASTNode.new :subexprs do
+      
+      def to_vm_code(context)
+        generated_from(pos) +
+          subexprs.map { |subexpr| subexpr.to_vm_code(context) }.reduce(:concat)
+      end
+      
+    end
+    
+    RuleDefinition = ASTNode.new :name, :body
+    
+    # ---- Syntax ----
+    
+    rule :start do
+      whitespace_and_comments and
+      rules = many { rule_definition } and
+      _(Program[rules])
+    end
+    
+    rule :expr do
+      choice
+    end
+    
+    rule :choice do
+      first = true
+      as = one_or_more {
+        p = choice_alternative_start(first) and s = seq and
+        act { first = false } and
+        _(ChoiceAlternative[p, s])
+      } and
+      if as.size == 1 then
+        as.first.subexpr
+      else
+        _(Choice[as])
+      end
+    end
+    
+    # Returns probability or :auto.
+    def choice_alternative_start(first)
+      _{
+        (_{ slash } or _{ pipe }) and
+        probability = (
+          _{
+            lbracket and
+            x = ufloat and opt { percent and act { x /= 100.0 } } and
+            rbracket and
+            x
+          } or
+          :auto
+        )
+      } or
+      (if first then :auto else nil end)
+    end
+    
+    rule :seq do
+      e = repeat and many {
+        e2 = repeat and e = _(Seq[to_seq_subexprs(e) + to_seq_subexprs(e2)])
+      } and
+      e
+    end
+    
+    def to_seq_subexprs(e)
+      case e
+      when Seq then e.subexprs
+      else [e]
+      end
+    end
+    
+    rule :repeat do
+      e = primary and many {
+        _{
+          asterisk and
+          from = 0 and to = INF and
+          opt {
+            lbracket and
+            n = times and act { from = n and to = n } and
+            opt {
+              ellipsis and
+              n = times and act { to = n }
+            } and
+            rbracket
+          } and
+          e = _(Repeat[e, from, to]) } or
+        _{ question and e = _(Repeat[e, 0, 1]) } or
+        _{ plus and e = _(Repeat[e, 1, INF]) }
+      } and
+      e
+    end
+    
+    def times
+      _{ uint } or
+      _{ inf and INF }
+    end
+    
+    rule :primary do
+      _{ s = string and _(GenString[s]) } or
+      _{ c = code("{=") and _(GenCode[c]) } or
+      _{ c = code("{?") and _(CheckCode[c]) } or
+      _{ action_code } or
+      _{ n = nonterm and not_follows(:eq) and _(RuleCall[n]) } or
+      _{ gen_number } or
+      _{ lparen and e = expr and rparen and e }
+    end
+    
+    def gen_number
+      n1 = number and n2 = opt { ellipsis and number } and
+      act { n2 = (n2.first or n1) } and
+      _(GenNumber[n1, n2])
+    end
+    
+    rule :action_code do
+      c = code("{") and _(ActionCode[c])
+    end
+    
+    rule :rule_definition do
+      n = nonterm and (_{eq} or _{larrow}) and e = choice and semicolon and
+      _(RuleDefinition[n, e])
+    end
+    
+    # ---- Tokens ----
+    
+    token :inf, "inf"
+    token :asterisk, "*"
+    token :question, "?"
+    token :plus, "+"
+    token :pipe, "|"
+    token :slash, "/"
+    token :eq, "="
+    token :semicolon, ";"
+    token :percent, "%"
+    token :ellipsis, "..."
+    token :lbrace, "{"
+    token :rbrace, "}"
+    token :lparen, "("
+    token :rparen, ")"
+    token :lbracket, "["
+    token :rbracket, "]"
+    token :dot, "."
+    token :larrow, "<-"
+    
+    # Parses "#{start} #{code_part} } #{whitespace_and_comments}".
+    # Returns the code_part.
+    def code(start)
+      p = pos and
+      scan(start) and c = code_part and
+      (rbrace or raise Expected.new(p, "`}' at the end")) and
+      c
+    end
+    
+    rule :code_part do
+      many {
+        _{ scan(/\\./) } or
+        _{ scan(/[^{}]+/) } or
+        _{
+          pp = pos and
+          p1 = scan("{") and p2 = code_part and
+          (p3 = scan("}") or raise Expected.new(pp, "`}' at the end")) and
+          p1 + p2 + p3
+        }
+      }.join
+    end
+    
+    token :string do
+      _{ string0('"') } or
+      _{ string0("'") } or
+      _{ scan("U+") and c = scan(/\h+/) and [c.hex].pack("U") }
+    end
+    
+    def string0(quote)
+      p = pos and scan(quote) and
+      s = many {
+        _{ scan(/\\n/) and "\n" } or
+        _{ scan(/\\t/) and "\t" } or
+        _{ scan(/\\e/) and "\e" } or
+        _{ scan(/\\./) } or
+        scan(/[^#{quote}]/)
+      }.join and
+      (scan(quote) or raise Expected.new(p, "`#{quote}' at the end")) and s
+    end
+    
+    token :nonterm do
+      _{ scan(/`.*?`/) } or
+      _{ scan(/[[:alpha:]_:][[:alnum:]\-_:]*/) }
+    end
+    
+    token :int, "integer number" do
+      n = number and n.is_a? Integer and n
+    end
+    
+    token :uint, "non-negative integer number" do
+      n = int and n >= 0 and n
+    end
+    
+    token :number do
+      s = scan(/[\-\+]?\d+(\.\d+)?([eE][\-\+]?\d+)?/) and
+      if /[\.eE]/ === s then
+        Float(s)
+      else
+        Integer(s)
+      end
+    end
+    
+    token :float, "floating point number" do
+      number
+    end
+    
+    token :ufloat, "non-negative floating point number" do
+      n = number and n >= 0 and n
+    end
+    
+    def whitespace_and_comments
+      many {
+        _{ scan(/\s+/) } or
+        _{ scan("//") and scan(/[^\n]*\n/m) } or
+        _{
+          p = pos and scan("/*") and
+          many { not_follows { scan("*/") } and scan(/./m) } and
+          (scan("*/") or raise Expected.new(p, "`*/' at the end"))
+        }
+      }
+    end
+    
+  end
+  
+  class CheckFailed < Exception
+    
+    # @param [Parse::Position] pos
+    def initialize(pos)
+      super("check failed")
+      @pos = pos
+    end
+    
+    # @return [Parse::Position] pos
+    attr_reader :pos
+    
+  end
+  
+end

data/lib/gen_text/vm.rb

@@ -0,0 +1,269 @@
+
+module GenText
+  
+  class VM
+    
+    # @param program Array of <code>[:method_id, *args]</code>.
+    # @return [Boolean] true if +program+ may result in calling
+    #   {IO#pos=} and false otherwise.
+    def self.may_set_out_pos?(program)
+      program.any? { |instruction| instruction.first == :rescue_ }
+    end
+    
+    # Executes +program+.
+    # 
+    # After the execution the +out+ may contain garbage after its {IO#pos}.
+    # It is up to the caller to truncate the garbage or to copy the useful data.
+    # 
+    # @param program Array of <code>[:method_id, *args]</code>.
+    # @param [IO] out
+    # @param [Boolean] do_not_run if true then +program+ will not be run
+    #   (some checks and initializations will be performed only).
+    # @return [void]
+    def run(program, out, do_not_run = false)
+      # 
+      if $DEBUG
+        STDERR.puts "PROGRAM:"
+        program.each_with_index do |instruction, addr|
+          STDERR.puts "  #{addr}: #{inspect_instruction(instruction)}"
+        end
+      end
+      #
+      return if do_not_run
+      # Init.
+      @stack = []
+      @out = out
+      @pc = 0
+      @halted = false
+      # Run.
+      STDERR.puts "RUN TRACE:" if $DEBUG
+      until halted?
+        instruction = program[@pc]
+        method_id, *args = *instruction
+        STDERR.puts "  #{@pc}: #{inspect_instruction(instruction)}" if $DEBUG
+        self.__send__(method_id, *args)
+        if $DEBUG then
+          STDERR.puts "    PC: #{@pc}"
+          STDERR.puts "    STACK: #{@stack.inspect}"
+        end
+      end
+    end
+    
+    # @return [Integer]
+    attr_reader :pc
+    
+    # @return [IO]
+    attr_reader :out
+    
+    # @return [Boolean]
+    def halted?
+      @halted
+    end
+    
+    # Sets {#halted?} to true.
+    # 
+    # @return [void]
+    def halt
+      @halted = true
+    end
+    
+    # NOP
+    # 
+    # @return [void]
+    def generated_from(*args)
+      @pc += 1
+    end
+    
+    # Pushes +o+ to the stack.
+    # 
+    # @param [Object] o
+    # @return [void]
+    def push(o)
+      @stack.push o
+      @pc += 1
+    end
+    
+    # {#push}(o.dup)
+    # 
+    # @param [Object] o
+    # @return [void]
+    def push_dup(o)
+      push(o.dup)
+    end
+    
+    # {#push}(rand(+r+) if +r+ is specified; rand() otherwise)
+    # 
+    # @param [Object, nil] r
+    # @return [void]
+    def push_rand(r = nil)
+      push(if r then rand(r) else rand end)
+    end
+    
+    # Pops the value from the stack.
+    # 
+    # @return [Object] the popped value.
+    def pop
+      @stack.pop
+      @pc += 1
+    end
+    
+    # If {#pop} is true then {#pc} := +addr+.
+    # 
+    # @param [Integer] addr
+    # @return [void]
+    def goto_if(addr)
+      if @stack.pop then
+        @pc = addr
+      else
+        @pc += 1
+      end
+    end
+    
+    # @return [void]
+    def dec
+      @stack[-1] -= 1
+      @pc += 1
+    end
+    
+    # If the value on the stack != 0 then {#goto}(+addr).
+    # 
+    # @param [Integer] addr
+    # @return [void]
+    def goto_if_not_0(addr)
+      if @stack.last != 0 then
+        @pc += 1
+      else
+        @pc = addr
+      end
+    end
+    
+    # If rand > +v+ then {#goto}(addr)
+    # 
+    # @param [Numeric] v
+    # @param [Integer] addr
+    # @return [void]
+    # 
+    def goto_if_rand_gt(v, addr)
+      if rand > v then
+        @pc = addr
+      else
+        @pc += 1
+      end
+    end
+    
+    # @param [Integer] addr
+    # @return [void]
+    def goto(addr)
+      @pc = addr
+    end
+    
+    # Writes {#pop} to {#out}.
+    # 
+    # @return [void]
+    def gen
+      @out.write @stack.pop
+      @pc += 1
+    end
+    
+    # {#push}(eval(+ruby_code+, +file+, +line+))
+    # 
+    # @param [Binding] binding_
+    # @param [String] ruby_code
+    # @param [String] file original file of +ruby_code+.
+    # @param [Integer] line original line of +ruby_code+.
+    # @return [void]
+    def eval_ruby_code(binding_, ruby_code, file, line)
+      @stack.push binding_.eval(ruby_code, file, line)
+      @pc += 1
+    end
+    
+    # {#push}({#out}'s {IO#pos} and {#pc} as {RescuePoint})
+    # 
+    # @param [Integer, nil] pc if specified then it is pushed instead of {#pc}.
+    # @return [void]
+    def push_rescue_point(pc = nil)
+      @stack.push RescuePoint[(pc or @pc), @out.pos]
+      @pc += 1
+    end
+    
+    # {#pop}s until a {RescuePoint} is found then restore {#out} and {#pc} from
+    # the {RescuePoint}.
+    # 
+    # @param [Proc] on_failure is called if no {RescuePoint} is found
+    # @return [void]
+    def rescue_(on_failure)
+      @stack.pop until @stack.empty? or @stack.last.is_a? RescuePoint
+      if @stack.empty? then
+        on_failure.()
+      else
+        rescue_point = @stack.pop
+        @pc = rescue_point.pc
+        @out.pos = rescue_point.out_pos
+      end
+    end
+    
+    # @param [Integer] addr
+    # @return [void]
+    def call(addr)
+      @stack.push(@pc + 1)
+      @pc = addr
+    end
+    
+    # @return [void]
+    def ret
+      @pc = @stack.pop
+    end
+    
+    # Let stack contains +wa+ = [[weight1, address1], [weight2, address2], ...].
+    # This function:
+    # 
+    # 1. Picks a random address from +wa+ (the more weight the
+    #    address has, the more often it is picked);
+    # 2. Deletes the chosen address from +wa+;
+    # 3. If there was the only address in +wa+ then it does {#push}(nil);
+    #    otherwise it does {#push_rescue_point};
+    # 4. {#goto}(the chosen address).
+    # 
+    # @return [void]
+    def weighed_choice
+      weights_and_addresses = @stack.last
+      # If no alternatives left...
+      if weights_and_addresses.size == 1 then
+        _, address = *weights_and_addresses.first
+        @stack.push nil
+        @pc = address
+      # If there are alternatives...
+      else
+        chosen_weight_and_address = sample_weighed(weights_and_addresses)
+        weights_and_addresses.delete chosen_weight_and_address
+        _, chosen_address = *chosen_weight_and_address
+        push_rescue_point
+        @pc = chosen_address
+      end
+    end
+    
+    RescuePoint = Struct.new :pc, :out_pos
+    
+    private
+    
+    # @param [Array<Array<(Numeric, Object)>>] weights_and_items
+    # @return [Array<(Numeric, Object)>]
+    def sample_weighed(weights_and_items)
+      weight_sum = weights_and_items.map(&:first).reduce(:+)
+      chosen_partial_weight_sum = rand(0...weight_sum)
+      current_partial_weight_sum = 0
+      weights_and_items.find do |weight, item|
+        current_partial_weight_sum += weight
+        current_partial_weight_sum > chosen_partial_weight_sum
+      end or
+      weights_and_items.last
+    end
+    
+    def inspect_instruction(instruction)
+      method_id, *args = *instruction
+      "#{method_id} #{args.map(&:inspect).join(", ")}"
+    end
+    
+  end
+  
+end

data/lib/io/with_dummy_pos.rb

@@ -0,0 +1,20 @@
+
+class IO
+  
+  # {IO} with {IO#pos} returning invalid value.
+  class WithDummyPos
+    
+    def self.new(io)
+      def io.pos
+        0
+      end
+      return io
+    end
+    
+  end
+  
+  # To disable YARD warnings:
+  #@!method pos
+  #@!method pos=(p)
+  
+end

data/yardopts_extra.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+
+# register ".sdl" extension using "pre" markup
+YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS[:pre] = ['g']

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: gen-text
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Lavir the Whiolet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parse-framework
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'A generator of texts from EBNF-like grammars. It features probability
+  management, code insertions and conditional generation with conditions written in
+  Ruby.
+
+'
+email: Lavir.th.Whiolet@gmail.com
+executables:
+- gen-text
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gen_text/vm.rb
+- lib/gen_text/compile.rb
+- lib/io/with_dummy_pos.rb
+- README.md
+- LICENSE
+- .yardopts
+- yardopts_extra.rb
+- bin/gen-text
+homepage: http://lavirthewhiolet.github.io/gen-text
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A generator of texts from EBNF-like grammars.
+test_files: []
+has_rdoc: