appswarm 0.0.1

data/lib/appswarm/secure_connection.rb

@@ -0,0 +1,79 @@
+require 'tools.rb'
+
+module Secure
+  
+  class Client
+    def initialize(socket)
+      @socket=socket
+      @data=""
+    end
+    def send(*m)
+      
+    end
+    def register(&b)
+      
+    end
+    
+    def run
+      @thread=Thread.new {
+        begin
+          loop do
+            @data+=@socket.read(1024)
+            check 
          end
+        rescue Exception=>e
+          log e,e.backtrace
+        end
+      }
+    end
+    
+    private
+    
+    def check
+      
+    end
+  end
+  
+  class Server
+    attr_reader :clients
+    def initialize(port,host="localhost")
+      @port=port
+      @host=host
+addr=      Socket.pack_sockaddr_in( @port,@host)
+      @server=TCPServer.new(port,addr)
+      @clients=[]
+      @mainThread=nil
+      @mutex=Mutex.new
+    end
+    
+    def clients
+      @mutex.synchronize {
+        @clients.dup
+      }
+    end
+    
+    def kill
+      @mainThread.kill if @mainThread
+    end
+    
+    def run
+      @mainThread=Thread.new {
+        client=@server.accept
+        c=Client.new(client)
+        @mutex.synchronize {
+          @clients<<c
+        }
+        begin
+          c.run
+        rescue Exception=>e
+          log e
+          @mutex.synchronize {
+            @clients.delete(c)
+          }
+        end
+      }
+    end
+    
+    
+  end
+
+end

data/lib/appswarm/secure_marshal.rb

@@ -0,0 +1,137 @@
+require 'tools.rb'
+
+module Secure
+  module Marshal
+    class OutOfData<Exception
+      def initialize(data)
+        @data=data
+      end
+    end
+  end
+  
+  # This is an interal class to keep track of data parsing, so that
+  # not too much data is copied from here to there.
+  class Data
+    def initialize(data)
+      @data=data
+      @pos=0
+    end
+    def read(len)
+      raise Secure::Marshal::OutOfData.new(@data) if @data.length<@pos+len
+      cur=@data[@pos...(@pos+len)]
+      @pos+=cur.length
+      cur
+    end
+    def til(str)
+      tmp=@data[(@pos..-1)]
+      i=tmp.index(str)
+      if i.nil?
+        raise Secure::Marshal::OutOfData.new(@data)
+      end
+      cur=tmp[0...i]
+      @pos+=cur.length+str.length
+      cur
+    end
+    def str
+      @data[@pos..-1]
+    end
+  end
+  
+  module Marshal
+    # this function work pretty much like ruby standard marshaling. But it supports only
+    # some small set of types, being some basic-types like symbols, numbers, strings, hashes, arrays and structs.
+    # This is good, because you won't be able to pass custom-objects through the network and thus causing
+    # security vulnerabilities. You can however create structs with Struct.new(...) and add functions to this
+    # struct.
+    # The encoding is PHP-serialization-alike, because it's relatively compact but still is halfway human-readable.
+    # It may become necessary to create a shorter syntax in the future.
+    def self.dump(o)
+      case o
+        when String
+          "s:"+dump(o.length)+o
+        when Integer
+          "i:"+o.to_s+":" 
+        when Float
+          "f:"+o.to_s+":"
+        when Array
+          "a:"+dump(o.length)+o.map{|elem|dump(elem)}.join("")
+        when NilClass
+          "b:n" # nil
+        when TrueClass
+          "b:t" # true
+        when FalseClass
+          "b:f"
+        when Hash
+          "h:"+dump(o.to_a)
+        when Symbol
+          "y:"+dump(o.to_s)
+        else
+          if o.respond_to?(:members) and o.respond_to?(:values) 
+            n=o.class.to_s
+            hash={}
+            o.members.each{|m|
+              hash[m]=o.send(m)
+            }
+            "o:"+dump(n)+dump(hash)
+          else
+            raise "Unknown Type to marshal #{o}"
+          end
+      end
+    end
+    
+    # load takes either a string or an object of type Secure::Data. It tries to load an object and return it.
+    # If no parsable object is found, an OutOfData exception will be raised.
+    def self.load(o)
+      unless o.is_a?(Data)
+        return load(Data.new(o))
+      end
+      orig=o.str
+      bt=o.dup
+      result=case o.read(2)[0..0]
+        when "b"
+          case o.read(1)
+            when "n"
+              nil
+            when "t"
+              true
+            when "f"
+              false
+          end
+        when "s"
+          len=load(o)
+          r=o.read(len)
+          r
+        when "i"
+          o.til(":").to_i
+        when "f"
+          o.til(":").to_f
+        when "a"
+          len=load(o)
+          assert{len.is_a?(Numeric)}
+          (0...len).to_a.map{|i|
+            load(o)
+          }
+        when "h"
+          a=load(o)
+          h={}
+          a.each{|p|
+            h[p[0]]=p[1]
+          }
+          h
+        when "y"
+          load(o).to_sym
+        when "o"
+          name=load(o)
+          hash=load(o)
+          klass=getClass(name)
+          mo=klass.new
+          hash.each{|k,v|
+            mo.send(k+"=",v) if mo.members.member?(k) and mo.respond_to?(k+"=")
+          }
+          mo
+      end
+      #pp "LOADING: #{orig.inspect} now:#{o.str.inspect} RES:#{result.inspect}"
+      result
+    end
+  end
+end

data/lib/appswarm/service.rb

@@ -0,0 +1,76 @@
+require 'application.rb'
+
+class Service<Application
+
+  def self.event(name,arity=nil)
+    name=name.to_s
+    onName="on"+name[0..0].upcase+name[1..-1]
+    isName="is"+name[0..0].upcase+name[1..-1]
+    
+    assert{not self.respond_to?(onName)}
+    @@eventArity||={}
+    if arity
+      @@eventArity[name]=arity
+    end
+    self.module_eval("
+      def #{onName}(&block)
+        assert{block_given?}
+        if @@eventArity[:#{name}]
+          assert{@@eventArity[:#{name}]==block.arity}
+        end
+        @eventReceivers||={}
+        @eventReceivers[:#{name}]||=[]
+        @eventReceivers[:#{name}] << block
+      end
+    private
+      def #{isName}(*args)
+        if @@eventArity[:#{name}]
+          assert{@@eventArity[:#{name}]==args.length}
+        end
+        @eventReceivers||={}
+        @eventReceivers[:#{name}]||=[]
+        @eventReceivers[:#{name}].each{|b|
+          b.call(*args)
+        }
+      end
+    ")
+  end
+    
+  def initialize(cluster,options,name)
+    super(cluster,options)
+    @name=name
+    @cronMutex=Mutex.new
+    provides(name)
+  end
+  
+  def cronTime
+    @options[:cronTime]||10
+  end
+  
+  def run
+    @threads << Thread.new {
+      while not quit?
+        begin
+          runCron
+        rescue Object=>e
+          log e
+          log e.backtrace if e.is_a?(Exception)
+        end
+        sleep(cronTime)
+      end
+    }
+  end
+  def stop
+    super
+  end
+  def runCron
+    @cronMutex.synchronize {
+      cron
+    }
+  end
+  
+  def cron
+    
+  end
+end
+

data/lib/appswarm/simple_marshal.rb

@@ -0,0 +1,96 @@
+#require 'treetop'
+#require File.expand_path("../simple_marshal_parser.rb",__FILE__)
+require File.expand_path("../tools/parser/parser_test.rb",__FILE__)
+
+require 'time'
+
+module Simple
+  module Marshal
+    INDENT="  "
+    def self.dump(data)
+      case data
+        when String
+          "\""+data.gsub("\\"){"\\\\"}.gsub("\"","\\\"").gsub("\n","\\n")+"\""
+        when Numeric
+          data.to_s
+        when Array
+          "[\n"+data.map{|d|INDENT+dump(d)}.join(",\n")+"\n]"
+        when Hash
+          "{\n"+INDENT+data.map{|k,v|dump(k)+" => "+dump(v)}.join(",\n").gsub("\n","\n"+INDENT)+"\n}"
+        when Symbol
+          ":"+data.to_s
+        when NilClass
+          "nil"
+        when FalseClass
+          "false"
+        when TrueClass
+          "true"
+        else
+          o=data
+          hash=nil
+          n=o.class.to_s
+          case o
+            when Time
+              hash={:data=>o.to_s}
+          end
+          if o.respond_to?(:members) and o.respond_to?(:values) 
+            hash={}
+            o.members.each{|m|
+              hash[m.to_sym]=o.send(m)
+            }
+          end
+          if hash
+            "("+n+"\n"+hash.map{|k,v|INDENT+dump(k)+" => "+dump(v)}.join(",\n")+"\n)"
+          else
+            raise "Unknown Type to marshal #{data} #{data.class}"
+          end
+      end
+    end
+    
+    Buf=Struct.new(:str,:pos)
+    
+    class Buf
+      def buf
+        str[pos..-1]
+      end
+    end
+    
+    
+    def self.load(str)
+      if false
+        @@parser||=nil
+        unless @@parser
+
+          Treetop. load File.expand_path("../simple_marshal_parser.tt",__FILE__)
+          @@parser=true
+        end
+        kcode=$KCODE
+        parser = SimpleMarshalParser.new
+        result = parser.parse(str)
+  #pp result
+        $KCODE=kcode
+        if result
+          pp "GOT RESULT"
+          return result.sload
+        else
+          nil
+        end
+      else
+        @@parser||=nil
+        unless @@parser
+
+          #Treetop.load File.expand_path("../simple_marshal_parser.tt",__FILE__)
+          @@parser=true
+        end
+        parser = SimpleMarshalParser #.new
+        result = parser.parse(str)
+        if result
+          #pp "GOT RESULT"
+          return result.convert
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/appswarm/simple_marshal_parser.rb

@@ -0,0 +1,1243 @@
+module SimpleMarshal
+  include Treetop::Runtime
+
+  def root
+    @root || :Elements
+  end
+
+  module Elements0
+    def Fill
+      elements[0]
+    end
+
+    def e
+      elements[1]
+    end
+
+    def Fill
+      elements[2]
+    end
+  end
+
+  module Elements1
+    def sload
+      e.sload
+    end
+  end
+
+  def _nt_Elements
+    start_index = index
+    if node_cache[:Elements].has_key?(index)
+      cached = node_cache[:Elements][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_Fill
+    s0 << r1
+    if r1
+      r2 = _nt_Element
+      s0 << r2
+      if r2
+        r3 = _nt_Fill
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Elements0)
+      r0.extend(Elements1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:Elements][start_index] = r0
+
+    return r0
+  end
+
+  module Element0
+    def Fill
+      elements[0]
+    end
+
+    def e
+      elements[1]
+    end
+
+    def Fill
+      elements[2]
+    end
+  end
+
+  module Element1
+    def sload
+      e.sload
+    end
+  end
+
+  def _nt_Element
+    start_index = index
+    if node_cache[:Element].has_key?(index)
+      cached = node_cache[:Element][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_Fill
+    s0 << r1
+    if r1
+      r2 = _nt_RElement
+      s0 << r2
+      if r2
+        r3 = _nt_Fill
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Element0)
+      r0.extend(Element1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:Element][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_RElement
+    start_index = index
+    if node_cache[:RElement].has_key?(index)
+      cached = node_cache[:RElement][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_Struct
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_Hash
+      if r2
+        r0 = r2
+      else
+        r3 = _nt_Symbol
+        if r3
+          r0 = r3
+        else
+          r4 = _nt_String
+          if r4
+            r0 = r4
+          else
+            r5 = _nt_Array
+            if r5
+              r0 = r5
+            else
+              r6 = _nt_Boolean
+              if r6
+                r0 = r6
+              else
+                r7 = _nt_Nil
+                if r7
+                  r0 = r7
+                else
+                  r8 = _nt_Number
+                  if r8
+                    r0 = r8
+                  else
+                    self.index = i0
+                    r0 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:RElement][start_index] = r0
+
+    return r0
+  end
+
+  module Symbol0
+  end
+
+  module Symbol1
+    def name
+      elements[1]
+    end
+  end
+
+  module Symbol2
+    def sload
+      name.text_value.to_sym
+    end
+  end
+
+  def _nt_Symbol
+    start_index = index
+    if node_cache[:Symbol].has_key?(index)
+      cached = node_cache[:Symbol][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index(':', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure(':')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i2, s2 = index, []
+      if input.index(Regexp.new('[_a-zA-Z]'), index) == index
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        r3 = nil
+      end
+      s2 << r3
+      if r3
+        s4, i4 = [], index
+        loop do
+          if input.index(Regexp.new('[0-9a-zA-Z_]'), index) == index
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            r5 = nil
+          end
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(Symbol0)
+      else
+        self.index = i2
+        r2 = nil
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Symbol1)
+      r0.extend(Symbol2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:Symbol][start_index] = r0
+
+    return r0
+  end
+
+  module Boolean0
+    def sload
+      true
+    end
+  end
+
+  module Boolean1
+    def sload
+      false
+    end
+  end
+
+  def _nt_Boolean
+    start_index = index
+    if node_cache[:Boolean].has_key?(index)
+      cached = node_cache[:Boolean][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    if input.index('true', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
+      r1.extend(Boolean0)
+      @index += 4
+    else
+      terminal_parse_failure('true')
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      if input.index('false', index) == index
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
+        r2.extend(Boolean1)
+        @index += 5
+      else
+        terminal_parse_failure('false')
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        self.index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:Boolean][start_index] = r0
+
+    return r0
+  end
+
+  module Nil0
+    def sload
+      nil
+    end
+  end
+
+  def _nt_Nil
+    start_index = index
+    if node_cache[:Nil].has_key?(index)
+      cached = node_cache[:Nil][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    if input.index('nil', index) == index
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 3))
+      r0.extend(Nil0)
+      @index += 3
+    else
+      terminal_parse_failure('nil')
+      r0 = nil
+    end
+
+    node_cache[:Nil][start_index] = r0
+
+    return r0
+  end
+
+  module Hash0
+    def Fill
+      elements[1]
+    end
+
+  end
+
+  module Hash1
+    def sload
+      {}
+    end
+  end
+
+  module Hash2
+    def l
+      elements[1]
+    end
+
+  end
+
+  module Hash3
+    def sload
+      l.sload
+    end
+  end
+
+  def _nt_Hash
+    start_index = index
+    if node_cache[:Hash].has_key?(index)
+      cached = node_cache[:Hash][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if input.index('{', index) == index
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('{')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_Fill
+      s1 << r3
+      if r3
+        if input.index('}', index) == index
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('}')
+          r4 = nil
+        end
+        s1 << r4
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Hash0)
+      r1.extend(Hash1)
+    else
+      self.index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i5, s5 = index, []
+      if input.index('{', index) == index
+        r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('{')
+        r6 = nil
+      end
+      s5 << r6
+      if r6
+        r7 = _nt_HashList
+        s5 << r7
+        if r7
+          if input.index('}', index) == index
+            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('}')
+            r8 = nil
+          end
+          s5 << r8
+        end
+      end
+      if s5.last
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        r5.extend(Hash2)
+        r5.extend(Hash3)
+      else
+        self.index = i5
+        r5 = nil
+      end
+      if r5
+        r0 = r5
+      else
+        self.index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:Hash][start_index] = r0
+
+    return r0
+  end
+
+  module HashList0
+    def ek
+      elements[1]
+    end
+
+    def ev
+      elements[3]
+    end
+  end
+
+  module HashList1
+    def k
+      elements[0]
+    end
+
+    def v
+      elements[2]
+    end
+
+    def mein_rest
+      elements[3]
+    end
+  end
+
+  module HashList2
+    def sload
+      h={}
+      h[k.sload]=v.sload
+      mein_rest.elements.each{|x|
+        h[x.ek.sload]=x.ev.sload
+      }
+      h
+    end
+  end
+
+  def _nt_HashList
+    start_index = index
+    if node_cache[:HashList].has_key?(index)
+      cached = node_cache[:HashList][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_Element
+    s0 << r1
+    if r1
+      if input.index('=>', index) == index
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('=>')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_Element
+        s0 << r3
+        if r3
+          s4, i4 = [], index
+          loop do
+            i5, s5 = index, []
+            if input.index(',', index) == index
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure(',')
+              r6 = nil
+            end
+            s5 << r6
+            if r6
+              r7 = _nt_Element
+              s5 << r7
+              if r7
+                if input.index('=>', index) == index
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                  @index += 2
+                else
+                  terminal_parse_failure('=>')
+                  r8 = nil
+                end
+                s5 << r8
+                if r8
+                  r9 = _nt_Element
+                  s5 << r9
+                end
+              end
+            end
+            if s5.last
+              r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+              r5.extend(HashList0)
+            else
+              self.index = i5
+              r5 = nil
+            end
+            if r5
+              s4 << r5
+            else
+              break
+            end
+          end
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(HashList1)
+      r0.extend(HashList2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:HashList][start_index] = r0
+
+    return r0
+  end
+
+  module Number0
+  end
+
+  module Number1
+  end
+
+  module Number2
+    def sload
+      s=text_value
+      if s=~/\./
+        return s.to_f
+      else
+        return s.to_i
+      end
+    end
+  end
+
+  def _nt_Number
+    start_index = index
+    if node_cache[:Number].has_key?(index)
+      cached = node_cache[:Number][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index('-', index) == index
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('-')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      s3, i3 = [], index
+      loop do
+        if input.index(Regexp.new('[0-9]'), index) == index
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r4 = nil
+        end
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s0 << r3
+      if r3
+        i6, s6 = index, []
+        if input.index('.', index) == index
+          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('.')
+          r7 = nil
+        end
+        s6 << r7
+        if r7
+          s8, i8 = [], index
+          loop do
+            if input.index(Regexp.new('[0-9]'), index) == index
+              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              r9 = nil
+            end
+            if r9
+              s8 << r9
+            else
+              break
+            end
+          end
+          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+          s6 << r8
+        end
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(Number0)
+        else
+          self.index = i6
+          r6 = nil
+        end
+        if r6
+          r5 = r6
+        else
+          r5 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r5
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Number1)
+      r0.extend(Number2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:Number][start_index] = r0
+
+    return r0
+  end
+
+  module String0
+  end
+
+  module String1
+  end
+
+  module String2
+    def sload
+#pp "TV:",text_value
+      text_value[1..-2].gsub("\\n","\n").gsub("\\\"","\"").gsub("\\\\","\\")
+    end
+  end
+
+  def _nt_String
+    start_index = index
+    if node_cache[:String].has_key?(index)
+      cached = node_cache[:String][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index('"', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        i4, s4 = index, []
+        if input.index('\\', index) == index
+          r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('\\')
+          r5 = nil
+        end
+        s4 << r5
+        if r5
+          if index < input_length
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("any character")
+            r6 = nil
+          end
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(String0)
+        else
+          self.index = i4
+          r4 = nil
+        end
+        if r4
+          r3 = r4
+        else
+          if input.index(Regexp.new('[^"\\\\]'), index) == index
+            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            r7 = nil
+          end
+          if r7
+            r3 = r7
+          else
+            self.index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if input.index('"', index) == index
+          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('"')
+          r8 = nil
+        end
+        s0 << r8
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(String1)
+      r0.extend(String2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:String][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_Fill
+    start_index = index
+    if node_cache[:Fill].has_key?(index)
+      cached = node_cache[:Fill][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    r0 = _nt_Whitespaces
+
+    node_cache[:Fill][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_Whitespaces
+    start_index = index
+    if node_cache[:Whitespaces].has_key?(index)
+      cached = node_cache[:Whitespaces][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_Whitespace
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:Whitespaces][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_Whitespace
+    start_index = index
+    if node_cache[:Whitespace].has_key?(index)
+      cached = node_cache[:Whitespace][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    if input.index(' ', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure(' ')
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      if input.index("\n", index) == index
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("\n")
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        if input.index("\t", index) == index
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\t")
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          self.index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:Whitespace][start_index] = r0
+
+    return r0
+  end
+
+  module Array0
+    def Fill
+      elements[1]
+    end
+
+  end
+
+  module Array1
+    def sload
+      []
+    end
+  end
+
+  module Array2
+    def e
+      elements[1]
+    end
+
+  end
+
+  module Array3
+
+    def sload
+      e.sload
+    end
+  end
+
+  def _nt_Array
+    start_index = index
+    if node_cache[:Array].has_key?(index)
+      cached = node_cache[:Array][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if input.index('[', index) == index
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_Fill
+      s1 << r3
+      if r3
+        if input.index(']', index) == index
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(']')
+          r4 = nil
+        end
+        s1 << r4
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Array0)
+      r1.extend(Array1)
+    else
+      self.index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i5, s5 = index, []
+      if input.index('[', index) == index
+        r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('[')
+        r6 = nil
+      end
+      s5 << r6
+      if r6
+        r7 = _nt_ElementList
+        s5 << r7
+        if r7
+          if input.index(']', index) == index
+            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(']')
+            r8 = nil
+          end
+          s5 << r8
+        end
+      end
+      if s5.last
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        r5.extend(Array2)
+        r5.extend(Array3)
+      else
+        self.index = i5
+        r5 = nil
+      end
+      if r5
+        r0 = r5
+      else
+        self.index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:Array][start_index] = r0
+
+    return r0
+  end
+
+  module ElementList0
+    def el
+      elements[1]
+    end
+  end
+
+  module ElementList1
+    def e
+      elements[0]
+    end
+
+    def mein_rest
+      elements[1]
+    end
+  end
+
+  module ElementList2
+    def sload
+      [e.sload]+mein_rest.elements.map{|x|x.el.sload}
+    end
+  end
+
+  def _nt_ElementList
+    start_index = index
+    if node_cache[:ElementList].has_key?(index)
+      cached = node_cache[:ElementList][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_Element
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if input.index(',', index) == index
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(',')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_Element
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(ElementList0)
+        else
+          self.index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ElementList1)
+      r0.extend(ElementList2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:ElementList][start_index] = r0
+
+    return r0
+  end
+
+  module StructName0
+  end
+
+  def _nt_StructName
+    start_index = index
+    if node_cache[:StructName].has_key?(index)
+      cached = node_cache[:StructName][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index(Regexp.new('[A-Z]'), index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if input.index(Regexp.new('[A-Za-z0-9_:]'), index) == index
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(StructName0)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:StructName][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_Any
+    start_index = index
+    if node_cache[:Any].has_key?(index)
+      cached = node_cache[:Any][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if index < input_length
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("any character")
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:Any][start_index] = r0
+
+    return r0
+  end
+
+  module Struct0
+    def name
+      elements[1]
+    end
+
+    def Whitespace
+      elements[2]
+    end
+
+    def l
+      elements[3]
+    end
+
+  end
+
+  module Struct1
+
+    def sload
+        klass=getClass(name.text_value)
+        mo=nil
+        hash=l.sload
+        if klass==Time
+          mo=Time.parse(hash[:data])
+        else
+            mo=klass.new
+            hash.each{|k,v|
+              k=k.to_s
+              mo.send(k+"=",v) if mo.members.member?(k) and mo.respond_to?(k+"=")
+            }
+        end
+        mo
+      
+    end
+  end
+
+  def _nt_Struct
+    start_index = index
+    if node_cache[:Struct].has_key?(index)
+      cached = node_cache[:Struct][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index('(', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('(')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_StructName
+      s0 << r2
+      if r2
+        r3 = _nt_Whitespace
+        s0 << r3
+        if r3
+          r4 = _nt_HashList
+          s0 << r4
+          if r4
+            if input.index(')', index) == index
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure(')')
+              r5 = nil
+            end
+            s0 << r5
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Struct0)
+      r0.extend(Struct1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:Struct][start_index] = r0
+
+    return r0
+  end
+
+end
+
+class SimpleMarshalParser < Treetop::Runtime::CompiledParser
+  include SimpleMarshal
+end