docgenerator 2.1.1 → 3.0.0

data/lib/docgenerator/packages/multicol.rb

@@ -6,7 +6,7 @@ Example:
 =end
     class Multicols < Environments::Environment
       add_attributes( {
-          :colnum =>	Attribute.create( [:latex], [ Fixnum ], 1 ),
+          :colnum =>	Attribute.create( [:latex], [ Integer ], 1 ),
           :titleline =>	Attribute.create( [:latex], [ String,Element], 2 ),
         }#.update(HTML_ATTR_ALL)
         )

data/lib/docgenerator/packages/pdfpages.rb

@@ -37,8 +37,9 @@ Implement includepdf from pdfpages-package.
         add_attribute    :linkname,  Attribute.create( [ :texkeyval], [ String ] )
         add_attribute    :linktodoc,  Attribute.create( [ :texkeyval], [ true, false] )  #Lets the inserted pages be hyperlinks to the document from which they were extracted.
         #~ add_attribute :addtotoc, Attribute.create( [ :texkeyval], [ /.+,.+,.+,.+,.+/] ),  #
+        add_attribute    :options,  Attribute.create( [ :latex], [ String ] ) #any other option. This string is added at the end.
           
-        add_output( :latex,  '#{linebreak(@crbefore)}\includepdf[#{texkeyval()}]{#{@content}}#{linebreak(@crafter)}')
+        add_output( :latex,  '#{linebreak(@crbefore)}\includepdf[#{texkeyval()},#{@attr[:options]}]{#{@content}}#{linebreak(@crafter)}')
           
         end #IncludePDF
 =begin rdoc

data/lib/docgenerator/packages/rubycode4doc.rb

@@ -5,98 +5,101 @@ Ruby fragments are executed line by line.
 The source code is enriched with the results and can be shown.
 =end
 
-require 'docgenerator'
-require 'docgenerator/packages/listings'
+require_relative '../../docgenerator'
+require_relative '../packages/listings'
 #~ require '../../lib/packages/docgenerator_listings'
 
 #
 module Docgenerator
-module Rubycode
-
-
-class CodeTest
-  #Catch output.
-  #
-  #Used to replace $stdout
-  class MyIO  < String
-    def write( cont )
-      self  << cont
-    end
-  end  #MyIO
-  
-  Code_line = Struct.new('Code_line', :code, :line_number,  :result, :output, :outputtab, :comment )
-  @@all  = {}
+  module Rubycode
+=begin rdoc
+Basic Idea:
+* Execute ruby code line by line
+* Show result per line
+=end
+    class CodeTest
+      #Catch output.
+      #
+      #Used to replace $stdout
+      class MyIO  < String
+        def write( cont )
+          self  << cont
+        end
+      end  #MyIO
+      
+      Code_line = Struct.new('Code_line', :code, :line_number,  :result, :output, :outputtab, :comment )
+      @@all  = {}
 =begin rdoc
 Get some executable ruby code and analyse it.
 If a name is given, it is stored for later reuse (see CodeTest[])
 =end
-  def initialize( name, code = '' )
-    @name = name
-    if @@all[@name]
-      raise "Double definition of CodeTest #{name.inspect}"
-    else
-      @@all[@name] = self
-    end if name
-    #Keep binding for code execution
-    @bind = binding
-    #Collection of all coding lines (elements are Code_line-struct)
-    @codelines  = []
-    code.split(/\n/).each{|c|
-      self << c
-    }
-  end
+      def initialize( name, code = '' )
+        @name = name
+        if @@all[@name]
+          raise "Double definition of CodeTest #{name.inspect}"
+        else
+          @@all[@name] = self
+        end if name
+        #Keep binding for code execution
+        @bind = binding
+        #Collection of all coding lines (elements are Code_line-struct)
+        @codelines  = []
+        code.split(/\n/).each{|c|
+          self << c
+        }
+      end
 =begin rdoc
 Add one coding line.
 -Each line is executed,
--The result o fthe line is added to #result
+-The result of the line is added to #result
 -The output is added to #output
 
 Restrictions:
 -One line, one command (only last command returns its result)
 =end
-  def << ( c )
-    #fixme: command mit Strings "#...
-    command, comment = c.chomp.split(/#/, 2 )
-    #~ if comment
-      #~ puts '--'*10 + 'comment'
-      #~ puts c.chomp
-      #~ puts command
-      #~ puts comment.inspect
-    #~ end
-    begin
-    $stdout = output = MyIO.new
-    codeline = Code_line.new( c.chomp, @codelines.size + 1, eval(c, @bind) )
-    rescue SyntaxError
-      $stdout = STDOUT
-      DOCGENERATOR_LOGGER.error("CodeTest #{@name}: Syntax Error with: '#{c}'") if DOCGENERATOR_LOGGER.error?
-      return
-    end
-    $stdout = STDOUT
-    codeline.outputtab  = []
-    if output.size > 0
-      codeline.output    = output.inspect
-      codeline.outputtab  = output.split("\n")
-    end      
-    codeline.comment  = comment
-    @codelines  << codeline
-  end
-  #Get 'plain' sourcecode
-  def sourcecode()
-    code  = []
-    @codelines.each{|codeline|
-      code << codeline.code
-    }
-    code.join("\n")
-  end
-  #Get 'plain' output
-  def output()
-    output  = []
-    @codelines.each{|codeline|
-      #~ output << codeline.output
-      output << codeline.outputtab
-    }
-    output.join("\n")
-  end
+      def << ( c )
+        #fixme: command mit Strings "#...
+        command, comment = c.chomp.split(/#/, 2 )
+        #~ if comment
+          #~ puts '--'*10 + 'comment'
+          #~ puts c.chomp
+          #~ puts command
+          #~ puts comment.inspect
+        #~ end
+        begin
+        $stdout = output = MyIO.new
+        codeline = Code_line.new( c.chomp, @codelines.size + 1, eval(c, @bind) )
+        rescue SyntaxError
+          $stdout = STDOUT
+          DOCGENERATOR_LOGGER.error("CodeTest #{@name}: Syntax Error with: '#{c}'") if DOCGENERATOR_LOGGER.error?
+          return
+        end
+        $stdout = STDOUT
+        codeline.outputtab  = []
+        if output.size > 0
+          codeline.output    = output.inspect
+          codeline.outputtab  = output.split("\n")
+        end      
+        codeline.comment  = comment
+        @codelines  << codeline
+      end
+      #Get 'plain' sourcecode
+      def sourcecode()
+        code  = []
+        @codelines.each{|codeline|
+          code << codeline.code
+        }
+        code.join("\n")
+      end
+      #Get 'plain' output
+      def output()
+        output  = []
+        @codelines.each{|codeline|
+          #~ output << codeline.output
+          output << codeline.outputtab
+        }
+        output.join("\n")
+      end
 =begin rdoc
 Get code and results  in a verbatim env.
 The comments starts after the column max. (default: longest code line + 3 )
@@ -108,120 +111,118 @@ becomes
 
 fixme: define scope, from-to line
 =end
-  def code_evaluation( max = @codelines.map{|f|f.code.size}.max  + 3 )
-    evaluated_code  = []
-    @codelines.each{|codeline|
-      #Prepare coding line with result of the line if not done before
-      evaluated_line  = "%-#{max}s" %  [ codeline.code ]
-      if codeline.result or codeline.output
-        evaluated_line  << " # "
-      end
-      if codeline.result
-        evaluated_line  << '-> %-10s' % [ codeline.result ]
-      end
-      if codeline.output
-        evaluated_line  << '=> %-10s' % [ codeline.output ]
+      def code_evaluation( max = @codelines.map{|f|f.code.size}.max  + 3 )
+        evaluated_code  = []
+        @codelines.each{|codeline|
+          #Prepare coding line with result of the line if not done before
+          evaluated_line  = "%-#{max}s" %  [ codeline.code ]
+          if codeline.result or codeline.output
+            evaluated_line  << " # "
+          end
+          if codeline.result
+            evaluated_line  << '-> %-10s' % [ codeline.result ]
+          end
+          if codeline.output
+            evaluated_line  << '=> %-10s' % [ codeline.output ]
+          end
+          evaluated_code << evaluated_line
+        }
+        evaluated_code.join("\n")
       end
-      evaluated_code << evaluated_line
-    }
-    evaluated_code.join("\n")
-  end
-  
-  #Get code and results  in a lstlistings environment.
-  def code_evaluation_lstlisting( max = @codelines.map{|f|f.code.size}.max  + 3 )
-    element(:lstlisting,{  :numbers => 'left',
-                    :numberstyle  => '\tiny',
-                    :class => 'rubycode_with_result',
-                  }, self.code_evaluation( max) ).cR
-  end #code_evaluation()
+      
+      #Get code and results  in a lstlistings environment.
+      def code_evaluation_lstlisting( max = @codelines.map{|f|f.code.size}.max  + 3 )
+        element(:lstlisting,{  :numbers => 'left',
+                        :numberstyle  => '\tiny',
+                        :class => 'rubycode_with_result',
+                      }, self.code_evaluation( max) ).cR
+      end #code_evaluation()
 =begin rdoc
 Get code 
 =end
-  def code()
-    element(:lstlisting,{  :numbers => 'left',
-                    :numberstyle  => '\tiny',
-                    :class => 'rubycode',
-                  }, @codelines.map{|codeline| codeline.code}.join("\n")).cR
-  end #code_evaluation()
+      def code()
+        element(:lstlisting,{  :numbers => 'left',
+                        :numberstyle  => '\tiny',
+                        :class => 'rubycode',
+                      }, @codelines.map{|codeline| codeline.code}.join("\n")).cR
+      end #code_evaluation()
 =begin rdoc
 return tabular with code, result and output.
 =end
-  def code_in_tab()
-    #~ element(:verbatim,{}, @code)
-#~ puts 'tabularx mag kein verbatim'
-    #~ tabular = element(:tabularx, {  
-            #~ :columndescription => 'lXllXX', 
-            #~ :width  => '\\textwidth',
-    tabular = element(:tabular, {  
-            :columndescription => 'lp{3cm}llp{3cm}', 
-            :columns => 5, 
-            :border => 1,
-          }).Cr
-      tabular << row = element(:row).cr.hline
-      row << element(:col, {}, 'No' )
-      row << element(:col, {}, 'Code' )
-      row << element(:col, {}, 'Result' )
-      row << element(:col, {}, 'Output' )
-      row << element(:col, {}, 'Output2' )
-    @codelines.each{|c|
-      tabular << row = element(:row).cr
-      row << element(:col, {}, c.line_number )
-      if c.code.include?("\n")
-        row << element(:col, {}, element(:lstlisting,{:class => 'rubycode' }, ["\n", c.code])  ).Cr
-      else
-        row << element(:col, {}, element(:lstinline,{:class => 'rubycode' }, c.code)  )
+      def code_in_tab()
+        #~ element(:verbatim,{}, @code)
+    #~ puts 'tabularx mag kein verbatim'
+        #~ tabular = element(:tabularx, {  
+                #~ :columndescription => 'lXllXX', 
+                #~ :width  => '\\textwidth',
+        tabular = element(:tabular, {  
+                :columndescription => 'lp{3cm}llp{3cm}', 
+                :columns => 5, 
+                :border => 1,
+              }).Cr
+          tabular << row = element(:row).cr.hline
+          row << element(:col, {}, 'No' )
+          row << element(:col, {}, 'Code' )
+          row << element(:col, {}, 'Result' )
+          row << element(:col, {}, 'Output' )
+          row << element(:col, {}, 'Output2' )
+        @codelines.each{|c|
+          tabular << row = element(:row).cr
+          row << element(:col, {}, c.line_number )
+          if c.code.include?("\n")
+            row << element(:col, {}, element(:lstlisting,{:class => 'rubycode' }, ["\n", c.code])  ).Cr
+          else
+            row << element(:col, {}, element(:lstinline,{:class => 'rubycode' }, c.code)  )
+          end
+          row << element(:col, {}, c.result  )
+          row << element(:col, {}, c.output ? element(:verb,{ :class => 'ruby_result_string' }, c.output) : nil )
+          #~ row << element(:col, {}, c.outputtab.map{|i| [i, element(:br)]}.flatten[0..-2] )
+          row << element(:col, {}, element(:verbatim,{:class => 'ruby_result'}, c.outputtab.join("\n") ) )
+        }
+        tabular
       end
-      row << element(:col, {}, c.result  )
-      row << element(:col, {}, c.output ? element(:verb,{ :class => 'ruby_result_string' }, c.output) : nil )
-      #~ row << element(:col, {}, c.outputtab.map{|i| [i, element(:br)]}.flatten[0..-2] )
-      row << element(:col, {}, element(:verbatim,{:class => 'ruby_result'}, c.outputtab.join("\n") ) )
-    }
-    tabular
-  end
 =begin rdoc
 Get the code fragment
 =end
-  def self.[](name)
-    @@all[name]
-  end
+      def self.[](name)
+        @@all[name]
+      end
 =begin rdoc
 Build a Document with required head-definitions
 (usepackage...)
 =end
-  def self.mk_document( title )
-    doc = Document.new(
-      :title => title
-    )
-    doc.head  << element(:usepackage,{ }, 'listings').cr
-    doc.head  << element(:usepackage,{ }, 'color').cr
-    doc.head  << element(:lstloadlanguages,{}, 'ruby' ).cr
-    doc.head  << element(:lstset,  {
-                        :language => 'ruby',
-                        :commentstyle  => '\color{blue}',
-                      } ).cr
-    return doc
-  end
-end  #CodeTest
-end #module Rubycode
+      def self.mk_document( title )
+        doc = Document.new(
+          :title => title
+        )
+        doc.head  << element(:usepackage,{ }, 'listings').cr
+        doc.head  << element(:usepackage,{ }, 'color').cr
+        doc.head  << element(:lstloadlanguages,{}, 'ruby' ).cr
+        doc.head  << element(:lstset,  {
+                            :language => 'ruby',
+                            :commentstyle  => '\color{blue}',
+                          } ).cr
+        return doc
+      end
+    end  #CodeTest
+  end #module Rubycode
 end #module Docgenerator
 
 if $0 == __FILE__
-test = CodeTest.new('codetest', <<CODE
-a = 5
-b = a * 5
-puts b
-puts b + 3
-CODE
-)
-puts test.code_evaluation
-
-puts "\n====Add more code====\n\n"
-test << <<TEST
-3.times{|i| 
-	puts i
-}
-TEST
+  test = Docgenerator::Rubycode::CodeTest.new('codetest', <<-CODE)
+  a = 5
+  b = a * 5
+  puts b
+  puts b + 3
+  CODE
+  puts test.code_evaluation
 
+  puts "\n====Add more code====\n\n"
+  test << <<-TEST
+  3.times{|i| 
+    puts i
+  }
+  TEST
 
-puts test.code_evaluation
+  puts test.code_evaluation
 end #if $0 == __FILE__

data/lib/docgenerator/packages/struktex.rb

@@ -30,18 +30,18 @@ end
 
 
 module Docgenerator
-module Packages
+  module Packages
 =begin rdoc
 Classes to provide support for the LaTeX-class struktex.
 
 * http://www.ctan.org/tex-archive/macros/latex/contrib/struktex/
 =end
-module Struktex
-USEPACKAGE_STRUKTEX	= element(:usepackage,{}, 'struktex').cr
-USEPACKAGE_STRUKTEX_PROOF = '\sProofOn '
+    module Struktex
+    USEPACKAGE_STRUKTEX	= element(:usepackage,{}, 'struktex').cr
+    USEPACKAGE_STRUKTEX_PROOF = '\sProofOn '
 
-#Bug: \pVar mag entgegen der Doku keine _ mag
-REPL_UNDERSCORE	= false
+    #Bug: \pVar mag entgegen der Doku keine _ mag
+    REPL_UNDERSCORE	= false
 
 =begin rdoc
 Code-generator for structex, a TeX-package to create Nassi-Shneidermann diagramms.
@@ -51,397 +51,413 @@ parameters.
 
 To define define ele Element-methods, module Element_methods is included.
 =end
-class Structogramm
-  
-  include Docgenerator::Element_methods #defines to_doc
-  
-	PARSTRUCT	= Struct.new('PARSTRUCT', :dir, :name, :text )
-  def self.head()
-    USEPACKAGE_STRUKTEX
-  end
-	attr_accessor :sourcecode
+    class Structogramm
+      
+      include Docgenerator::Element_methods #defines to_doc
+      
+      PARSTRUCT	= Struct.new('PARSTRUCT', :dir, :name, :text )
+      def self.head()
+        USEPACKAGE_STRUKTEX
+      end
+      attr_accessor :sourcecode
 =begin rdoc
 Define a structogramm.
 =end
-	def initialize( title, x, y, code = String.new )
-		@title	= title
-		@sourcecode	= code
-		@x		= x
-		@y		= y
-		@elements	= []
-    
-    @log = Log4r::Logger.new("Structogramm #{title}")
-    @log.outputters = Log4r::StdoutOutputter.new('log_stdout')
-	end
-  
-	def <<(code)
-		@sourcecode	<< code
-		@sourcecode	<< "\n"
-	end
-	#
-	#Analyse sourcecode and fill @elements
-	def analyse_sourcecode( code = @sourcecode )
-		stack	= [ @elements ]
-		lastcmd	= nil
-		code.each_line{|l|
-			l.strip!
-			case l
-			when /\A\s*#~/	#comment
-			when /\A%/
-				stack.last << l				
-			when	/ENDIF\s*(.*)/,  		/ENDCASE\s*(.*)/,
-						/ENDWHILE\s*(.*)/,	/ENDFOREVER\s*(.*)/,
-						/ENDSELECT\s*(.*)/
-				#~ @elements << "\\ifend"
-				stack.pop	#close actual IF
-				lastcmd	= nil
-			when /IF\s*(.*)/
-				#~ @elements << "\\ifthenelse{3}{3}{#{$1}}{\\pTrue}{\\pFalse}"
-				struct = Structogramm_IF.new(inline($1))
-				stack.last << struct
-				stack << struct
-				lastcmd	= nil
-			when /THEN\s*(\d)?\s*(.*)/
-				stack.last.thensize = $1 if $1
-				stack.last.thentext = inline($2) if $2 and ! $2.empty?
-				lastcmd	= nil
-			when /ELSE\s*(\d)?\s*(.*)/
-				stack.last.elsesize = $1 if $1
-				stack.last.elsetext = inline($2) if $2 and ! $2.empty?
-				#~ @elements << "\\change"
-				stack.last.else
-				lastcmd	= nil
-			when /CASE\s*(\d)?\s*(.*)/
-				struct = Structogramm_CASE.new( inline($2), $1, @log)
-				stack.last << struct
-				stack << struct
-				lastcmd	= nil
-			when /(?:SWITCH|WHEN)(?:\[([crl])\])?\s*(.*)/
-				stack.last.switch(inline($2), $1)
-				lastcmd	= nil
-			when /WHILE\s*(.*)/, /SELECT\s*(.*)/
-				struct = Structogramm_WHILE.new(inline($1))
-				stack.last << struct
-				stack << struct
-				lastcmd	= nil
-			when /REPEAT\s*(.*)/
-				struct = Structogramm_REPEAT.new(inline($1))
-				stack.last << struct
-				stack << struct
-				lastcmd	= nil
-			when /UNTIL\s*(.*)/
-				stack.last.condition = $1
-				stack.pop	#close actual IF			
-				lastcmd	= nil
-			when /FOREVER\s*(.*)/
-				struct = Structogramm_FOREVER.new()
-				stack.last << struct
-				stack << struct
-				lastcmd	= nil
-			when /<=\s*(.*)/
-				stack.last << lastcmd = Structogramm_CMD.new( "exit",		inline($1) ) 
-			when /=>\s*(.*)/
-				stack.last << lastcmd = Structogramm_CMD.new( "sub",		inline($1) ) 
-			when /<>\s*(.*)/
-				stack.last << lastcmd = Structogramm_CMD.new( "return",	inline($1) ) 
-			when /(<->|<-|->)\s*(\S+)\s*(.*)/
-				if ! lastcmd
-					@log.warn("description #{l} without command") if @log.warn?
-				else
-					lastcmd.par	<< PARSTRUCT.new($1, inline($2), $3 )
-				end
-			else
-				stack.last << lastcmd = Structogramm_CMD.new( "assign", inline(l) ) 
-			end
-		}
-	end
-	def inline( inp )
-		#~ return inp.gsub(/'(.*?)'/, '\\pKey{\1}')
-		return Document.texify(inp).gsub(/'(.*?)'/, '\\pKey{\1}').gsub(/->/, '$\to$')
-	end
-	def to_s()
-		@sourcecode
-	end
-  #Print the source code in a verbatim environmet
-	def verbatim()
-		return element(:verbatim,{},@sourcecode.gsub(/\t/, '  ')).cR
-	end
-  #
-  #Option:
-  #-:centernss Flag if the structogramm should be entered in an environment.
-	def to_latex( options = {} )
-    options = options.merge( :centernss => true )
-		analyse_sourcecode()
-		tex = [nil]
-		tex	<< '\begin{centernss}' if options[:centernss]
-		tex	<< "\\begin{struktogramm}(#{@x},#{@y})[#{@title}]"
-		tex << @elements.to_structex.map{|e|
-			#~ "\t#{e}"
-			"#{e}"
-		}
-		tex	<< '\end{struktogramm}'
-		tex	<< '\end{centernss}'		if options[:centernss]
-		tex	<< nil
-		#Gsub notwendig, da \pVar entgegen der Doku keine _ mag
-		if REPL_UNDERSCORE
-			return tex.join("\n").gsub(/_/, '\_')
-		else
-			return tex.join("\n")
-		end
-	end
-  #Return for wiki2docgenerator
-	def to_wiki( options = {} )
-    return <<xx
+      def initialize( title, x, y, code = String.new )
+        @title	= title
+        @sourcecode	= code
+        @x		= x
+        @y		= y
+        @elements	= []
+        
+        @log = Log4r::Logger.new("Structogramm #{title}")
+        @log.outputters = Log4r::StdoutOutputter.new('log_stdout')
+      end
+      
+      def <<(code)
+        @sourcecode	<< code
+        @sourcecode	<< "\n"
+      end
+=begin rdoc
+Analyse sourcecode and fill @elements
+
+Supported elements:
+* cmd
+* IF ... THEN ... ELSE ... ENDIF
+* CASE ... (SWITCH|WHEN) ... ENDCASE
+* WHILE ... ENDWHILE
+* SELECT ... ENDSELECT
+* REPEAT ... UNTIL
+* FOREVER ... ENDFOREVER
+* <=: exit-command
+* =>: sub-command
+* <>: return-command
+* (<->|<-|->) Define parameter for previous command
+
+Usage see unit test.
+=end
+      def analyse_sourcecode( code = @sourcecode )
+        stack	= [ @elements ]
+        lastcmd	= nil
+        code.each_line{|l|
+          l.strip!
+          case l
+          when /\A\s*#~/	#comment
+          when /\A%/
+            stack.last << l				
+          when	/ENDIF\s*(.*)/,  		/ENDCASE\s*(.*)/,
+                /ENDWHILE\s*(.*)/,	/ENDFOREVER\s*(.*)/,
+                /ENDSELECT\s*(.*)/
+            #~ @elements << "\\ifend"
+            stack.pop	#close actual IF
+            lastcmd	= nil
+          when /IF\s*(.*)/
+            #~ @elements << "\\ifthenelse{3}{3}{#{$1}}{\\pTrue}{\\pFalse}"
+            struct = Structogramm_IF.new(inline($1))
+            stack.last << struct
+            stack << struct
+            lastcmd	= nil
+          when /THEN\s*(\d)?\s*(.*)/
+            stack.last.thensize = $1 if $1
+            stack.last.thentext = inline($2) if $2 and ! $2.empty?
+            lastcmd	= nil
+          when /ELSE\s*(\d)?\s*(.*)/
+            stack.last.elsesize = $1 if $1
+            stack.last.elsetext = inline($2) if $2 and ! $2.empty?
+            #~ @elements << "\\change"
+            stack.last.else
+            lastcmd	= nil
+          when /CASE\s*(\d)?\s*(.*)/
+            struct = Structogramm_CASE.new( inline($2), $1, @log)
+            stack.last << struct
+            stack << struct
+            lastcmd	= nil
+          when /(?:SWITCH|WHEN)(?:\[([crl])\])?\s*(.*)/
+            stack.last.switch(inline($2), $1)
+            lastcmd	= nil
+          when /WHILE\s*(.*)/, /SELECT\s*(.*)/
+            struct = Structogramm_WHILE.new(inline($1))
+            stack.last << struct
+            stack << struct
+            lastcmd	= nil
+          when /REPEAT\s*(.*)/
+            struct = Structogramm_REPEAT.new(inline($1))
+            stack.last << struct
+            stack << struct
+            lastcmd	= nil
+          when /UNTIL\s*(.*)/
+            stack.last.condition = $1
+            stack.pop	#close actual IF			
+            lastcmd	= nil
+          when /FOREVER\s*(.*)/
+            struct = Structogramm_FOREVER.new()
+            stack.last << struct
+            stack << struct
+            lastcmd	= nil
+          when /<=\s*(.*)/
+            stack.last << lastcmd = Structogramm_CMD.new( "exit",		inline($1) ) 
+          when /=>\s*(.*)/
+            stack.last << lastcmd = Structogramm_CMD.new( "sub",		inline($1) ) 
+          when /<>\s*(.*)/
+            stack.last << lastcmd = Structogramm_CMD.new( "return",	inline($1) ) 
+          when /(<->|<-|->)\s*(\S+)\s*(.*)/
+            if ! lastcmd
+              @log.warn("description #{l} without command") if @log.warn?
+            else
+              lastcmd.par	<< PARSTRUCT.new($1, inline($2), $3 )
+            end
+          else
+            stack.last << lastcmd = Structogramm_CMD.new( "assign", inline(l) ) 
+          end
+        }
+      end
+      def inline( inp )
+        #~ return inp.gsub(/'(.*?)'/, '\\pKey{\1}')
+        return Document.texify(inp).gsub(/'(.*?)'/, '\\pKey{\1}').gsub(/->/, '$\to$')
+      end
+      def to_s()
+        @sourcecode
+      end
+      #Print the source code in a verbatim environmet
+      def verbatim()
+        return element(:verbatim,{},@sourcecode.gsub(/\t/, '  ')).cR
+      end
+      #
+      #Option:
+      #-:centernss Flag if the structogramm should be entered in an environment.
+      def to_latex( options = {} )
+        options = options.merge( :centernss => true )
+        analyse_sourcecode()
+        tex = [nil]
+        tex	<< '\begin{centernss}' if options[:centernss]
+        tex	<< "\\begin{struktogramm}(#{@x},#{@y})[#{@title}]"
+        tex << @elements.to_structex.map{|e|
+          #~ "\t#{e}"
+          "#{e}"
+        }
+        tex	<< '\end{struktogramm}'
+        tex	<< '\end{centernss}'		if options[:centernss]
+        tex	<< nil
+        #Gsub notwendig, da \pVar entgegen der Doku keine _ mag
+        if REPL_UNDERSCORE
+          return tex.join("\n").gsub(/_/, '\_')
+        else
+          return tex.join("\n")
+        end
+      end
+      #Return for wiki2docgenerator
+      def to_wiki( options = {} )
+        return <<xx
 >>>structogramm{#{@title};#{@x};#{@y}}
 #{@sourcecode}
 <<<    
 xx
-  end #to_wiki
-  #Return for creole2doc
-	def to_creole( options = {} )
-    return <<xx
+      end #to_wiki
+      #Return for creole2doc
+      def to_creole( options = {} )
+        return <<xx
 <<<structogramm|#{@title};#{@x};#{@y}
 #{@sourcecode}
 >>>
 xx
-  end #to_creole
-  
-  
-	#Save TEX-code
-	def save( filename, overwrite = false )
-		
-		old = nil
-		File.open( filename ){|f| old = f.readlines.to_s } if File.exists?(filename)
-		
-		if /\.nss/	=~ filename
-			new = self.to_latex(:centernss => false)
-		else
-			new = self.to_latex()
-		end
-		if old != new
-			if overwrite or old == nil
-				File.open( filename, 'w'){|f|
-					f	<< new
-				}
-				@log.INFO("Save changed #{filename}") if @log.INFO?
-			else
-				@log.info("Changed #{filename}")
-			end
-		else
-				@log.INFO("Unchanged #{filename}") if @log.INFO?
-		end
-		#~ doc = Document.new(:include)
-		#~ doc.body << self.to_tex()
-		#~ doc.save( filename, overwrite )
-	end		
-end #Structogramm
+      end #to_creole
+      
+      
+      #Save TEX-code
+      def save( filename, overwrite = false )
+        
+        old = nil
+        File.open( filename ){|f| old = f.readlines.to_s } if File.exists?(filename)
+        
+        if /\.nss/	=~ filename
+          new = self.to_latex(:centernss => false)
+        else
+          new = self.to_latex()
+        end
+        if old != new
+          if overwrite or old == nil
+            File.open( filename, 'w'){|f|
+              f	<< new
+            }
+            @log.INFO("Save changed #{filename}") if @log.INFO?
+          else
+            @log.info("Changed #{filename}")
+          end
+        else
+            @log.INFO("Unchanged #{filename}") if @log.INFO?
+        end
+        #~ doc = Document.new(:include)
+        #~ doc.body << self.to_tex()
+        #~ doc.save( filename, overwrite )
+      end		
+    end #Structogramm
 
 
-class Structogramm_CMD
-	def initialize( type, cmd )
-		@type	= type
-		@cmd	= [ cmd ]
-		@par		= []
-	end
-	#Interface definition of command.
-	attr_reader	:par
-	#Add command... into if or else-branch
-	#~ def << (add)
-		#~ @cmd << add
-	#~ end
-	def to_structex()
-		tex = []
-		tex << "\\#{@type}{#{@cmd.join}"
-		if ! @par.empty?
-			#~ tex	<< "\\\\\\\\\n" 
-			tex	<< "\\\\\n" 
-			tex	<< interface(@par, nil)
-			#~ tex	<< interface(@par, 'Interface')
-		end
-		tex << "}"
-		return tex.join()
-	end
-	def interface( list, text )
-		return nil if list.empty?
-		interface = [ "\\begin{declaration}[#{text}]" ]
-		list.each{|par|
-			dir = nil
-			case par.dir
-				when '->';	dir = '$\\Rightarrow$'
-				when '<-';	dir = '$\\Leftarrow$'
-				when '<->';	dir = '$\\Leftrightarrow$'
-			end
-			#par.name may contain _
-			interface <<	"\\description{#{dir}\t#{par.name}}{#{par.text}}"
-		}
-		interface <<	"\\end{declaration}\n"
-		return interface.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_CMD: #{@type}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end	
-end
+    class Structogramm_CMD
+      def initialize( type, cmd )
+        @type	= type
+        @cmd	= [ cmd ]
+        @par		= []
+      end
+      #Interface definition of command.
+      attr_reader	:par
+      #Add command... into if or else-branch
+      #~ def << (add)
+        #~ @cmd << add
+      #~ end
+      def to_structex()
+        tex = []
+        tex << "\\#{@type}{#{@cmd.join}"
+        if ! @par.empty?
+          #~ tex	<< "\\\\\\\\\n" 
+          tex	<< "\\\\\n" 
+          tex	<< interface(@par, nil)
+          #~ tex	<< interface(@par, 'Interface')
+        end
+        tex << "}"
+        return tex.join()
+      end
+      def interface( list, text )
+        return nil if list.empty?
+        interface = [ "\\begin{declaration}[#{text}]" ]
+        list.each{|par|
+          dir = nil
+          case par.dir
+            when '->';	dir = '$\\Rightarrow$'
+            when '<-';	dir = '$\\Leftarrow$'
+            when '<->';	dir = '$\\Leftrightarrow$'
+          end
+          #par.name may contain _
+          interface <<	"\\description{#{dir}\t#{par.name}}{#{par.text}}"
+        }
+        interface <<	"\\end{declaration}\n"
+        return interface.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_CMD: #{@type}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end	
+    end
 
-class Structogramm_WHILE
-	def initialize( whilestatement )
-		@whilestatement = whilestatement
-		@cmd	= []
-	end
-	#Add command... into if or else-branch
-	def << (add)
-		@cmd << add
-	end
-	def to_structex()
-		tex = []
-		tex << "\\while{#{@whilestatement}}"
-		tex	<< @cmd.to_structex
-		tex << "\\whileend"
-		return tex.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_WHILE: #{@whilestatement}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end	
-end
+    class Structogramm_WHILE
+      def initialize( whilestatement )
+        @whilestatement = whilestatement
+        @cmd	= []
+      end
+      #Add command... into if or else-branch
+      def << (add)
+        @cmd << add
+      end
+      def to_structex()
+        tex = []
+        tex << "\\while{#{@whilestatement}}"
+        tex	<< @cmd.to_structex
+        tex << "\\whileend"
+        return tex.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_WHILE: #{@whilestatement}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end	
+    end
 
-class Structogramm_REPEAT
-	def initialize( repeatstatement )
-		@condition = repeatstatement
-		@cmd	= []
-	end
-	attr_accessor :condition
-	#Add command... into if or else-branch
-	def << (add)
-		@cmd << add
-	end
-	def to_structex()
-		tex = []
-		tex << "\\until{#{@condition}}"
-		tex	<< @cmd.to_structex
-		tex << "\\untilend"
-		return tex.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_REPEAT: #{@condition}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end	
-end
+    class Structogramm_REPEAT
+      def initialize( repeatstatement )
+        @condition = repeatstatement
+        @cmd	= []
+      end
+      attr_accessor :condition
+      #Add command... into if or else-branch
+      def << (add)
+        @cmd << add
+      end
+      def to_structex()
+        tex = []
+        tex << "\\until{#{@condition}}"
+        tex	<< @cmd.to_structex
+        tex << "\\untilend"
+        return tex.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_REPEAT: #{@condition}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end	
+    end
 
-class Structogramm_FOREVER
-	def initialize()
-		@cmd	= []
-	end
-	#Add command... into if or else-branch
-	def << (add)
-		@cmd << add
-	end
-	def to_structex()
-		tex = []
-		tex << "\\forever"
-		tex	<< @cmd.to_structex
-		tex << "\\foreverend"
-		return tex.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_FOREVER>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end	
-end
+    class Structogramm_FOREVER
+      def initialize()
+        @cmd	= []
+      end
+      #Add command... into if or else-branch
+      def << (add)
+        @cmd << add
+      end
+      def to_structex()
+        tex = []
+        tex << "\\forever"
+        tex	<< @cmd.to_structex
+        tex << "\\foreverend"
+        return tex.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_FOREVER>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end	
+    end
 
-class Structogramm_IF
-	def initialize( ifstatement )
-		@ifstatement = ifstatement
-		@then	= []
-		@else	= nil	#keep it empty, until method 'else' is called
-		@thentext	= '\\pTrue'
-		@elsetext	= '\\pFalse'
-		@thensize	= 3
-		@elsesize	= 3
-	end
-	#Text for 'then'-Branch. default: \pTrue
-	attr_writer	:thentext
-	#Text for 'else'-Branch
-	attr_writer	:elsetext
-	#Textwidth for 'then'-Branch
-	attr_writer	:thensize
-	#Textwidth for 'else'-Branch
-	attr_writer	:elsesize
-	#Add command... into if or else-branch
-	def << (add)
-		@else ? @else << add : @then << add
-	end
-	#Change from then-branch to else-branch
-	def else()
-		@else = []
-	end
-	def to_structex()
-		tex = []
-		tex << "\\ifthenelse{#{@thensize}}{#{@elsesize}}{#{@ifstatement}}{#{@thentext}}{#{@elsetext}}"
-		tex	<< @then.to_structex
-		tex	<< "\\change"
-		tex	<< @else.to_structex
-		tex << "\\ifend"
-		return tex.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_IF: #{@ifstatement}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end
-end
+    class Structogramm_IF
+      def initialize( ifstatement )
+        @ifstatement = ifstatement
+        @then	= []
+        @else	= nil	#keep it empty, until method 'else' is called
+        @thentext	= '\\pTrue'
+        @elsetext	= '\\pFalse'
+        @thensize	= 3
+        @elsesize	= 3
+      end
+      #Text for 'then'-Branch. default: \pTrue
+      attr_writer	:thentext
+      #Text for 'else'-Branch
+      attr_writer	:elsetext
+      #Textwidth for 'then'-Branch
+      attr_writer	:thensize
+      #Textwidth for 'else'-Branch
+      attr_writer	:elsesize
+      #Add command... into if or else-branch
+      def << (add)
+        @else ? @else << add : @then << add
+      end
+      #Change from then-branch to else-branch
+      def else()
+        @else = []
+      end
+      def to_structex()
+        tex = []
+        tex << "\\ifthenelse{#{@thensize}}{#{@elsesize}}{#{@ifstatement}}{#{@thentext}}{#{@elsetext}}"
+        tex	<< @then.to_structex
+        tex	<< "\\change"
+        tex	<< @else.to_structex
+        tex << "\\ifend"
+        return tex.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_IF: #{@ifstatement}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end
+    end
 
-class Structogramm_CASE
-	def initialize( casevar, degree = 4, log = Log4r::Logger.new('log') )
-		@casevar	= casevar
-		@degree	= degree.to_i
-		if @degree == 0
-			@log.warn("CASE #{casevar} mit degree 0") if @log.warn?
-		end
-		@cmd		= []
-		@switches	= []	#List of branches. 
-	end
-	def << (add)
-		@cmd	<< add
-	end
-	#Change branch.
-	def switch( condition, option = nil )
-		switch	= Structogramm_SWITCH.new( condition, option )
-		#The first branch is part of the \case-statement
-		@cmd		<< switch	if ! @switches.empty?
-		@switches	<< switch
-	end
-	def to_structex()
-		tex = []
-		tex << "\\case{#{@degree}}{#{@switches.size}}{#{@casevar}}{#{@switches.first.value}}"
-		tex	<< @cmd.to_structex
-		tex << "\\caseend"
-		return tex.join("\n")
-	end
-	def inspect()
-		return "#<Structogramm_CASE: #{@casestatement}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end
-end
+    class Structogramm_CASE
+      def initialize( casevar, degree = 4, log = Log4r::Logger.new('log') )
+        @casevar	= casevar
+        @degree	= degree.to_i
+        if @degree == 0
+          @log.warn("CASE #{casevar} mit degree 0") if @log.warn?
+        end
+        @cmd		= []
+        @switches	= []	#List of branches. 
+      end
+      def << (add)
+        @cmd	<< add
+      end
+      #Change branch.
+      def switch( condition, option = nil )
+        switch	= Structogramm_SWITCH.new( condition, option )
+        #The first branch is part of the \case-statement
+        @cmd		<< switch	if ! @switches.empty?
+        @switches	<< switch
+      end
+      def to_structex()
+        tex = []
+        tex << "\\case{#{@degree}}{#{@switches.size}}{#{@casevar}}{#{@switches.first.value}}"
+        tex	<< @cmd.to_structex
+        tex << "\\caseend"
+        return tex.join("\n")
+      end
+      def inspect()
+        return "#<Structogramm_CASE: #{@casestatement}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end
+    end
 
-class Structogramm_SWITCH
-	def initialize( value, option )
-		@value	= value
-		@option	= option
-	end
-	attr_reader :value
-	def to_structex()
-		tex = []
-		tex << "\\switch"
-		tex << "[#{@option}]"	if @option
-		tex << "{#{@value}}"
-		return tex.join()
-	end
-	def inspect()
-		return "#<Structogramm_SWITCH: #{@value}>"
-		#~ return "#<IF: #{@ifstatement}>"
-	end
-end
+    class Structogramm_SWITCH
+      def initialize( value, option )
+        @value	= value
+        @option	= option
+      end
+      attr_reader :value
+      def to_structex()
+        tex = []
+        tex << "\\switch"
+        tex << "[#{@option}]"	if @option
+        tex << "{#{@value}}"
+        return tex.join()
+      end
+      def inspect()
+        return "#<Structogramm_SWITCH: #{@value}>"
+        #~ return "#<IF: #{@ifstatement}>"
+      end
+    end
 
-end #module Struktex
-end #module Packages
+    end #module Struktex
+  end #module Packages
 end #module Docgenerator