cgialib 0.0.1

data/lib/cgialib/lp/Language.rb

@@ -0,0 +1,293 @@
+# File: Language.rb
+# Author: Jack Herrington
+# Purpose: The basic language classes
+# Date: 12/21/02
+
+# class : ClassVariable
+#
+# A data structure class to store all of the information about the variables
+# associated with a class
+
+module LanguageParser
+  class ClassVariable
+  
+    # initialize()
+    #
+    # Constructor
+    
+    def initialize()
+  
+      @name = nil
+      @type = nil
+      @static = false
+      @const = false
+      @visibility = nil
+      @value = nil
+      @comment = ""
+  
+    end
+  
+    attr_accessor :name         # The name of the variable
+  
+    attr_accessor :type         # The type of the variable
+  
+    attr_accessor :static       # True if it's static
+  
+    attr_accessor :const        # True if it's const
+  
+    attr_accessor :visibility   # "public", "private" or "protected"
+  
+    attr_accessor :value        # The value of the variable 
+  
+    attr_accessor :comment      # The comment surrounding the variable
+  
+    # to_s()
+    #
+    # Pretty printing the variable
+  
+    def to_s()
+  
+      text = "#{name} - #{type}"
+  
+      text += " - #{@visibility}" if ( @visibility )
+      text += " - const" if ( @const )
+      text += " - static" if ( @static )
+      text += " = #{@value}" if ( @value )
+  
+      text
+  
+    end
+  
+  end
+  
+  # class : LanguageClass
+  #
+  # This is a simple data structure that defines what we know about a given
+  # class.  Ruby already has a class named 'Class', so we called this one
+  # 'LanguageClass' to avoid collisions.
+  
+  class LanguageClass
+  
+    # initialize()
+    #
+    # Constructor
+  
+    def initialize()
+  
+      @type = "class"
+      @name = ""
+      @comments = ""
+      @parents = []
+      @methods = []
+      @variables = []
+  
+    end
+  
+    attr_accessor :type     # The type of class (could be interface, or struct)
+    attr_accessor :name     # The name of the class
+    attr_reader :methods    # The array of methods
+    attr_reader :variables  # The array of instance variables (or constants)
+    attr_accessor :comments # The text of any comments
+    attr_reader :parents    # An array of parent class names
+  
+    # add_method( method )
+    #
+    # method - The method object
+    #
+    # Adds a method
+  
+    def add_method( method )
+      @methods.push( method )
+    end
+  
+    # add_parent( parent )
+    #
+    # parent - The parent name as text 
+    #
+    # Adds a parent class
+  
+    def add_parent( parent )
+      @parents.push( parent )
+    end
+  
+    # add_variable( variable )
+    #
+    # variable - The variable object
+    #
+    # Adds a variable to the class definition
+  
+    def add_variable( variable )
+      @variables.push( variable )
+    end
+  
+    # to_s()
+    #
+    # Pretty printing string converter
+  
+    def to_s()
+  
+      text = "class : #{@name} - "
+      text += @parents.join( ", " )
+      text += "\n"
+  
+      text += "Methods:\n"
+  
+      methods.each { |method|
+        text += "  #{method}\n"
+      }
+  
+      text += "Variables:\n"
+  
+      variables.each { |var|
+        text += "  #{var}\n"
+      }
+  
+      text
+  
+    end
+  
+  end
+  
+  # class : PrototypeComment
+  #
+  # The class represents a comment in the prototype.
+  
+  class PrototypeComment
+  
+    # initialize()
+    #
+    # Constructs the object
+  
+    def initialize() @text = ""; end
+  
+    attr_accessor :text   # The text of the comment
+  
+    # to_s()
+    #
+    # Turns this object into text
+  
+    def to_s() @text; end
+  
+  end
+  
+  # class : PrototypeArgument
+  #
+  # This class represents arguments on the prototype.
+  
+  class PrototypeArgument
+  
+    # initialie()
+    #
+    # Constucts the argument object
+  
+    def initialize()
+  
+      @name = nil
+      @type = nil
+  
+    end
+  
+    attr_accessor :name    # The argument name
+    attr_accessor :type    # The argument type
+  
+    # to_s()
+    #
+    # Turns this argument into a string
+  
+    def to_s() @type ? "#{@name} - #{@type}" : @name; end
+  
+  end
+  
+  # class : Prototype
+  #
+  # This class stores all of the information about a prototype
+  
+  class Prototype
+  
+    # initialize()
+    #
+    # Constructs the Prototype object
+  
+    def initialize()
+  
+      @class_name = nil
+      @method_name = nil
+      @method_type = nil
+      @arguments = []
+      @comments = []
+      @static = false
+      @visibility = nil
+  
+    end
+  
+    attr_accessor :visibility    # Visibility of the method (public, private, etc.)
+    attr_accessor :static        # True if the method is static
+    attr_accessor :class_name    # The class name
+    attr_accessor :method_name   # The name of the method
+    attr_accessor :method_type   # The return type of the method
+    attr_reader :arguments       # The method arguments
+    attr_reader :comments        # Comments associated with the method
+  
+    # to_s()
+    #
+    # Returns the object pretty printed as a string
+  
+    def to_s()
+  
+      text = "#{method_name} - #{method_type} - "
+      text += "( #{@arguments.map{ |arg| arg.to_s }.join(', ')} )"
+  
+      text += " - #{@visibility}" if ( @visibility )
+      text += " - static" if ( @static )
+  
+      text
+  
+    end
+  
+    # add_argument( name, type )
+    #
+    # name - The name of the argument
+    # type - The type of the argument
+    #
+    # Adds an argument to the ordered argument list
+  
+    def add_argument( name, type = nil )
+  
+      arg = PrototypeArgument.new()
+      arg.name = name
+      arg.type = type
+      @arguments.push( arg )
+  
+    end
+  
+    # add_comment( text )
+    #
+    # text - The text of the comment
+    #
+    # Adds a comment to the prototype
+  
+    def add_comment( text )
+  
+      comment = PrototypeComment.new()
+      comment.text = text 
+      @comments.push( comment )
+  
+    end
+  
+  end
+  
+  # class : LanguageScanner
+  #
+  # This is the base class for scanners which turn tokens streams
+  # into prototypes and other language specific elements.  
+  # It is meant to be overridden for each language.
+  
+  class LanguageScanner
+  
+    def parse( tokens )
+  
+    end
+  
+  end
+
+end

data/lib/cgialib/lp/Tokenizer.rb

@@ -0,0 +1,281 @@
+# File: Tokenizer.rb
+# Author: Jack Herrington
+# Purpose: The basic tokenizer classes
+# Date: 12/21/02
+
+# class : Token
+# 
+# The base type for all tokens
+
+module LanguageParser
+  class Token
+  
+    # initialize( text )
+    #
+    # text - The text of the token
+    #
+    # Initialieze the token with it's text
+  
+    def initialize( text ) @text = text; end
+  
+    # to_s()
+    #
+    # Overload of the to-string method to return the text
+    # of the token
+  
+    def to_s() @text; end
+  
+  end
+  
+  # class : CommentToken
+  #
+  # This represents a comment token
+  
+  class CommentToken < Token
+  
+  end
+  
+  # class : WhitespaceToken
+  #
+  # This represents a string of whitespace within a source file
+  
+  class WhitespaceToken < Token
+  
+  end
+  
+  # class : CodeToken
+  #
+  # This represents a code fragment within a source file
+  
+  class CodeToken < Token
+  
+  end
+  
+  # class : Tokenizer
+  #
+  # The base class for all Tokenizers. The Tokenizers are meant to be
+  # specialized to parse the text of various languages into token streams
+  # that consist of CodeToken, WhitespaceToken, and CommentToken objects
+  
+  class Tokenizer
+  
+    # initialize()
+    #
+    # Constructs the Tokenizer base class
+  
+    def initialize( )
+      @tokens = TokenStream.new()
+    end
+  
+    attr_reader :tokens       # The ordered array of tokens
+  
+    # parse( text )
+    #
+    # text - The string of code to be turned into tokens  
+    #
+    # This should be overridden by all derived classes. It is
+    # meant to parse the text into tokens. Which should be stored
+    # in @tokens.
+  
+    def parse( text )
+    end
+  
+  end
+  
+  # class : TokenStream
+  #
+  # An array of tokens with many useful helper methods
+  
+  class TokenStream < Array
+  
+    # initialize()
+    #
+    # Initalizes the array
+  
+    def initialize()
+  
+      super()
+  
+    end
+  
+    # to_s()
+    #
+    # Converts all of the tokens back to text
+  
+    def to_s()
+  
+      text = ""
+      each { |tok| text += tok.to_s }
+      text
+  
+    end
+  
+    # strip!()
+    #
+    # Deletes any leading or trailing whitespace
+  
+    def strip!()
+  
+      while( first.is_a?( WhitespaceToken ) )
+        shift
+      end
+      while( last.is_a?( WhitespaceToken ) )
+        pop
+      end
+  
+    end
+  
+    # code_only()
+    #
+    # Returns a new token stream with the code tokens only
+  
+    def code_only()
+  
+      out = TokenStream.new()
+  
+      each { |tok| out.push( tok ) if ( tok.is_a?( CodeToken ) ) }
+  
+      out
+  
+    end
+  
+    # comments_only()
+    #
+    # Returns a new token stream with the comments only
+  
+    def comments_only()
+  
+      out = TokenStream.new()
+  
+      each { |tok| out.push( tok ) if ( tok.is_a?( CommentToken ) ) }
+  
+      out
+  
+    end
+  
+    # find_pattern( pattern )
+    #
+    # pattern - A pattern array
+    #
+    # This searches the set of tokens for a pattern of strings.  The array should contain
+    # a series of strings and lambdas.  In the first pass the pattern finder looks for the
+    # strings.  If a match is found the lambdas are called with the token in the original
+    # string for that position.
+    #
+    # For example:
+    #
+    # find_pattern( "primary", "key", "(", lambda { |name| print name }, ")" )
+    #
+    # Would print "myname" if the original sequence was "primary key ( myname )"
+  
+    def find_pattern( pattern )
+  
+      code = code_only
+  
+      delta = ( code.length - pattern.length ) + 1
+  
+      delta.times { |start|
+  
+        found = true
+  
+        pattern.each_index { |index|
+  
+          if ( pattern[ index ].is_a?( String ) )
+  
+            unless ( pattern[ index ].downcase == code[ start + index ].to_s.downcase )
+              found = false 
+            end
+  
+          end
+  
+        }
+  
+        next unless ( found )
+  
+        pattern.each_index { |index|
+  
+          unless ( pattern[ index ].is_a?( String ) )
+  
+            pattern[index].call( code[ start + index ].to_s.downcase )
+  
+          end
+  
+        }
+  
+        return true
+  
+      }
+  
+      false
+  
+    end
+  
+    # get_comments( start )
+    #
+    # start - The start index
+    #
+    # This method looks backwards from the starting index to find all of the
+    # comments and to put them together into a comment stream.  It stops if it
+    # finds new CodeTokens.
+  
+    def get_comments( start )
+  
+      commentStream = TokenStream.new()
+  
+      index = start - 1
+  
+      while ( index > -1 )
+  
+        break if ( at( index ).is_a?( CodeToken ) )
+  
+        commentStream.unshift( at( index ) )
+  
+        index -= 1
+  
+      end
+  
+      comments = commentStream.map { |tok| tok.to_s }.join( "" )
+  
+      comments
+  
+    end
+  
+    # find( code_value )
+    #
+    # code_value - The code token text as a string
+    #
+    # This finds a CodeToken with the same text as the input (case insensitive)
+    # and returns the index.
+  
+    def find( code_value )
+  
+      each_index { |index|
+  
+        next unless ( at( index ).is_a?( CodeToken ) )
+  
+        return index if ( at( index ).to_s.downcase == code_value.to_s.downcase )
+  
+      }
+  
+      nil
+  
+    end
+  
+    # find_and_remove( code_value )
+    #
+    # code_value - The code token text as a string
+    #
+    # This is the same as find, but it removes the item.  It returns true if it
+    # found something and false if not.
+  
+    def find_and_remove( code_value )
+  
+      index = find( code_value )
+  
+      delete_at( index ) if ( index != nil )
+  
+      ( index == nil ) ? false : true
+  
+    end
+  end
+end

data/lib/cgialib/lp.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'lp/Language'
+require 'lp/Tokenizer'
+require 'lp/CTokenizer'
+require 'lp/CLanguageScanner'
+require 'lp/CPPLanguageScanner'
+module LanguageParser
+  VERSION = '0.0.1'
+end

data/lib/cgialib/template/ut/c.rb

@@ -0,0 +1,41 @@
+module CGIA_UT_Template
+C_UT_TEMPLATE = <<'EOF'
+/*
+ * ==========================================================================
+ * WARNING: This code has been generated by 'testgen'. Any modifications
+ * you make to it will be lost when it is regenerated.
+ * ==========================================================================
+ */
+static int run_tests()
+{
+<%
+prototypes.each { |proto|
+  name = proto.method_name
+  proto.tests.each { |test| 
+    values = []
+    proto.arguments.each { |arg|
+      values.push( test.arguments[ arg.name.to_s ] )
+    }
+    args = values.join( ", " )
+    result = test.result
+    test_name = test.name
+%>
+  if ( <%= name %>( <%= args %> ) != <%= result %> )
+  {
+    printf( stderr, "Unit test <%= test_name %> failed!\n" );
+    return 0;
+  }
+<%
+  }
+}
+%>
+  return 1;
+}
+/*
+ * ==========================================================================
+ * WARNING: This code has been generated by 'testgen'. Any modifications
+ * you make to it will be lost when it is regenerated.
+ * ==========================================================================
+ */
+EOF
+end

data/lib/cgialib/template/ut.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'ut/c'
+module CGIA_UT_Template
+  VERSION = '0.0.1'
+end

data/lib/cgialib/template.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'template/ut'
+module CGIA_Template
+  VERSION = '0.0.1'
+end

data/lib/cgialib.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cgialib/lp'
+require 'cgialib/template'
+
+module Cgialib
+  VERSION = '0.0.1'
+end