sal-tools-analyze 0.0.1

data/AUTHORS

@@ -0,0 +1 @@
+M. Ehehalt (flynn42ryder@rubyforge.org)

data/README

@@ -0,0 +1,20 @@
+= sal-tools - A library for the analyze of SAL code
+
+== SYNOPSIS
+
+This library gives the basic functionality to analyse Gupta source code.
+Copyright (c)2007-2011 by Michael Ehehalt
+Error and feature list at the end of the document
+
+== Other stuff
+
+Author::  M. Ehehalt <flynn42ryder@rubyforge.org>
+License:: Copyright (C) 2007, 2008, ... M. Ehehalt
+          Released under the GNU GPL 2 license
+
+== Warranty
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.

data/lib/sal/class.rb

@@ -0,0 +1,43 @@
+require_relative "item.rb"
+
+module Sal
+  
+  # The class repressents a class in the code
+  class Class
+
+    def initialize( item )
+      @item = item
+      item.code.chomp =~ /^(.*? Class): (.*)$/
+      @type = $1
+      @name = $2
+      @functions = nil
+    end
+
+    attr_accessor :name, :item, :type
+
+    # Getter for the functions (lazy loading)
+    def functions
+      if( @functions.nil? )            
+        _analyze            
+      end
+      return @functions
+    end
+
+  private
+
+    def _analyze
+      @functions = []
+      
+      @item.childs.each do | item |
+        if(item.level == 4 and item.code.start_with? "Functions")
+          item.childs.each do | item |
+            @functions << item if item.code.start_with? "Function"
+          end
+        end
+      end
+    end
+
+  end
+    
+end
+

data/lib/sal/code.rb

@@ -0,0 +1,236 @@
+require "ostruct"
+
+require_relative "externalfunction.rb"
+require_relative "external.rb"
+require_relative "format.rb"
+require_relative "item.rb"
+require_relative "library.rb"
+require_relative "version.rb"
+
+module Sal
+  
+  # The class code represent the complete code from a sal file.
+  # You can analyze the code now through the items, the libraries, ...
+  # Only code in text format could be analyzed
+  class Code
+  
+    # Initialize Code with filename
+    # The sourcecode will read and the format and version are analysed
+    def initialize( filename )
+      read_code_from_file filename
+      get_format_and_version_from_code
+    end
+    
+    # Save the items of code back to disk
+    # Without parameters, the original file will be overridden
+    def save( new_filename = filename )
+      save_code_to_file new_filename
+    end
+    
+    # Save the items of code back to disk in a new file
+    # Alias for save with a new filename
+    def save_as( new_filename )
+      save_code_to_file new_filename
+    end
+    
+    attr_accessor :format, :filename, :version, :code
+    
+    # Getter for the items (lazy loading)
+    def items
+      get_items_from_code if @items.nil?
+      @items
+    end
+    
+    # Getter for the libraries (lazy loading)
+    def libraries
+      if @libraries.nil?
+        @libraries = Array.new
+        items.each do | item |
+          if( item.level == 2 and !item.parent.nil? and item.parent.code =~ /Libraries/)
+            @libraries << Library.new(item) unless item.commented?
+          end
+        end
+      end
+      return @libraries
+    end
+    
+    # Add a new library to the libraries section in the code
+    def add_library(filename)
+      # .head 1 +  Libraries
+      # .head 2 -  File Include: qckttip.apl
+      # .head 2 -  File Include: vt.apl
+      items.each do | item |
+        if( item.level == 1 and item.code =~ /Libraries/ )
+          include_item = item.copy
+          include_item.parent = item
+          include_item.childs = []
+          include_item.code = "File Include: #{filename}"
+          include_item.level = item.level + 1
+          @items.insert(@items.index(item) + 1, include_item)
+          item.childs.insert(0, include_item)
+          item.refresh_child_indicator
+          include_item.refresh_child_indicator
+          @libraries = nil
+          return include_item
+        end
+      end
+    end
+  
+    # Getter for the externals (lazy loading)
+    def externals
+      if @externals.nil?
+        @externals = Array.new
+        items.each do | item |
+          if( item.level == 3 and !item.parent.nil? and item.parent.code =~ /External Functions/ )
+            @externals << External.new(item) unless item.commented?
+          end
+        end
+      end
+      return @externals
+    end
+    
+    # Getter for the classes (lazy loading)
+    def classes
+      if @classes.nil?
+        @classes = []
+        items.each do | item |
+          if( item.level == 3 and !item.parent.nil? and item.parent.code.start_with?("Class Definitions") )
+            @classes << Class.new(item) unless item.commented?
+          end
+        end
+      end
+      return @classes
+    end
+  
+    def to_s
+      @file_name
+    end
+    
+    # Returns the current code from the items
+    def generated_code
+      new_code = ""
+      items.each do | item |
+        new_code += item.line
+      end
+      new_code
+    end
+    
+    # Returns a short overview over the code (version, format, ...)
+    def display(smart = true)
+      disp  = "#{File.basename @filename} " 
+      disp += (smart ? "- " : ":\n")
+      disp += "Version = #{@version.td} "
+      disp += (smart ? "- " : "\n")
+      disp += "Format = #{@format}"
+    end
+    
+  private
+    
+    # Saves the current code
+    def save_code_to_file(new_filename)
+      fh = File.new(new_filename, "wb")
+      fh.write( items.join )
+      fh.close
+    end
+    
+    # Read the code from the file and sets the filename
+    def read_code_from_file(filename)
+      @filename = filename
+      @code = IO.binread filename 
+    end
+    
+    # Analyzes the file format (normal, text, indented) and the version
+    def get_format_and_version_from_code
+      @format = Format::get_from_code @code
+      @version = Version::from_code @code
+    end
+    
+    # Get the items from the code and generats the @items array
+    def get_items_from_code
+      @items = []
+      case format
+      when Format::TEXT
+        # _analyze_code_textmode
+        analyze_items Format::TEXT
+      when Format::INDENTED
+        # not realized at the moment
+        # _analyze_code_indented
+        # analyze_items Format::INDENTED
+      else
+        # Can't analyze indented and normal mode code
+      end
+    end
+    
+    # Analyzes the source code
+    def analyze_items(format)
+      vars = analyze_init(format)
+      get_lines(vars)
+      vars.lines.each do | line |
+        if line.length > 0
+          vars.line = line
+          @items << get_item(vars)
+        end
+      end
+    end
+    
+    # Initialization of the analyze, clears all infos
+    # As parameter communication an open struct is used
+    def analyze_init(format)
+      @items = Array.new
+      vars = OpenStruct.new
+      vars.counter = 0
+      vars.levels = Hash.new
+      vars.format = format
+      return vars
+    end
+    
+    # The source code is splitted into lines
+    def get_lines(vars)
+      vars.lines = []
+      if(vars.format == Format::TEXT)
+        code_split_text vars
+      elsif(vars.format == Format::INDENTED)
+        # code_split_indented vars # not realized at the moment
+      end
+    end
+    
+    # Split the source code into lines if source code is in text format
+    def code_split_text(vars)
+      lines = @code.split(/^\.head/)
+      lines.each do | line | 
+        vars.lines << ".head#{line}" if line.length > 0
+      end
+      vars.lines
+    end
+    
+    # Split the source code into lines if source code is in indented format
+    def code_split_indented(vars)
+      vars.lines = @code.split(/\n/)
+      vars.lines.collect { | line | line = line + "\n" }
+    end
+    
+    # create the item
+    def get_item(vars)
+      # item = Item.new vars.line, vars.format
+      if(vars.format == Format::TEXT)
+        item = Item.new vars.line, vars.format
+      else
+        item = Item.new(vars.line, Format::INDENTED)
+      end
+      item.code_line_nr = vars.counter + 1
+      vars.levels[item.level] = item
+      if(item.level > 0 and vars.levels.count > 1)
+        begin
+          item.parent = vars.levels[item.level-1]
+          item.parent.childs << item
+        rescue
+          warn "filename = #{@filename}"
+        end
+      end
+      vars.counter += 1 # Bei Textmode war vorher: item_counter = item_counter + code_line.split('\n').length
+      item
+    end
+    
+  end
+  
+end

data/lib/sal/command.rb

@@ -0,0 +1,35 @@
+module Sal
+  
+  # Checks if the code line to test is a line of code or other stuff (window parameters, ...)
+  module Command
+
+    @@commands = { 
+      :break => "Break", 
+      :call => "Call",
+      :case => "Case",                # => Select Case
+      :default => "Default",          # => Select Case
+      :else => "Else",
+      :else_if => "Else If",
+      :if => "If",
+      :loop => "Loop",
+      :on => "On",
+      :return => "Return",
+      :select_case => "Select Case",
+      :set => "Set",
+      :when => "When",
+      :while => "While"  
+    }
+    
+    # Checks if the line of code is code or other stuff
+    # with using of the @@commands array, that includes
+    # the source code starts
+    def Command.is_code_line?(line)
+      @@commands.each_value do | command |
+        return true if line.start_with? "#{command} "
+      end
+      return false
+    end
+  
+  end
+
+end

data/lib/sal/external.rb

@@ -0,0 +1,37 @@
+require_relative "item.rb"
+
+module Sal
+  
+  # The class represent an included external library (dll)
+  class External
+
+    def initialize( item )
+      @item = item
+      @name = item.code.gsub(/Library name: /,"")
+      @functions = nil
+    end
+
+    attr_accessor :name, :item
+
+    # Getter of the dll functions (lazy loading)
+    def functions
+      if( @functions.nil? )            
+        _analyze            
+      end
+      return @functions
+    end
+
+  private
+
+    def _analyze
+      @functions = Array.new
+      @item.childs.each do | item |
+        if item.code =~ /Function: /
+          @functions << ExternalFunction.new( self, item )
+        end
+      end
+    end
+
+  end
+    
+end

data/lib/sal/externalfunction.rb

@@ -0,0 +1,46 @@
+require_relative "item.rb"
+require_relative "external.rb"
+
+module Sal
+ 
+  # This class represent an external function as chilf from the external
+  # library (dll)
+  class ExternalFunction
+
+    def initialize( external, item )
+      @external = external
+      @item = item
+      @name = nil
+      @ordinal = -1
+      @parameters = Array.new
+      
+      #@appears = 0
+      #@defs = Array.new
+      #@calls = Hash.new # hash with files whith a child code line array
+      
+      _analyze
+      @key = @external.name + "::" + @name
+    end
+
+    attr_accessor :external, :item , :name, :ordinal, :key, :parameters # :appears, :defs, :calls
+
+  private
+
+    def _analyze
+      @name = $1 if @item.code =~ /Function: (.*)$/
+      @item.childs.each do | child |
+        # ordinal number
+        @ordinal = $1.to_i if child.code =~ /Export Ordinal: (\d+)/
+        
+        # parameter
+        if child.level == 5 and child.code =~ /Parameters/
+          child.childs.each do | parameter |
+            @parameters << parameter unless parameter.commented?
+          end
+        end
+      end
+    end
+  
+  end
+      
+end

data/lib/sal/format.rb

@@ -0,0 +1,43 @@
+module Sal
+    
+  # Analyzes the file format from the sal sourcecode
+  # The result is one of the constantsTEXT, NORMAL or INDENTED.
+  module Format
+    
+    TEXT = :t
+    NORMAL = :n
+    INDENTED = :i
+    
+    # Analyzes the file format for the given chunk of code
+    def Format.get_from_code( code )
+      if(code =~ /Outline Version - \d\.\d\.(\d\d)/m)
+        if(code =~ /^\.head/)
+          return Format::TEXT
+        else
+          return Format::INDENTED
+        end
+      else
+        return Format::NORMAL
+      end
+    end
+    
+    # Analyzes the file format for the file with the given filename
+    # The file is read and the source code sends to the method get_from_code
+    def Format.get_from_file( filename )
+      code = IO.binread(filename)
+      return get_from_code( code )
+    end
+        
+    def Format.get_from_line( line )
+      if(line.start_with? ".head")
+        return Format::TEXT
+      elsif(line.start_with? "Application Description" or line.start_with? "\t")
+        return Format::INDENTED
+      else
+        return Format::NORMAL
+      end
+    end
+    
+  end
+
+end