cgialib 0.0.1

data/lib/cgialib/lp/CPPLanguageScanner.rb

@@ -0,0 +1,326 @@
+# File: CPPLanguageScanner.rb
+# Author: Jack Herrington
+# Purpose: The CPPLanguageScanner object specialized to look for C++ language
+#          features.
+# Date: 12/21/02
+
+#require "Tokenizer"
+#require "CLanguageScanner"
+
+module LanguageParser
+  # Class : CPPLanguageScanner
+  # 
+  # The scanner specialized for processing C++ headers.
+  
+  class CPPLanguageScanner < CLanguageScanner
+  
+    # initialize()
+    #
+    # Constructs the scanner object
+  
+    def initialize()
+  
+      super()
+  
+      @classes = []
+  
+      @prototypeClass = Prototype
+      @variableClass = ClassVariable
+      @languageClass = LanguageClass
+  
+    end
+  
+    attr_reader :classes            # The classes found
+  
+    attr_accessor :languageClass    # The class to use when building class objects
+  
+    attr_accessor :variableClass    # The class to use when building variable objects
+  
+    # parse( tokens )
+    #
+    # tokens - Tokens returned from CTokenizer
+    #
+    # Parses the tokens read from the CTokenizer
+  
+    def parse( tokens )
+  
+      # Handle the function prototypes in the base class
+    
+      super( tokens )
+  
+      # Set up the code buffer
+    
+      codefrag = TokenStream.new()
+  
+      # Set up the state machine flags
+  
+      has_class = false
+      found_open = false
+      level = 0
+      comments = ""
+  
+      # Look through the tokens for classes, and build up the full class bodies
+      # in codefrag.  Then send the codefrags on to parse_class
+  
+      tokens.each_index { |index|
+  
+        tok = tokens[ index ]
+  
+        if ( has_class )
+  
+          comments = tokens.get_comments( index )
+  
+          codefrag.push( tok )
+  
+          if ( tok.to_s == "{" )
+  
+            level += 1
+  
+            found_open = true
+  
+          end
+  
+          level -= 1 if ( tok.to_s == "}" )
+  
+          if ( tok.to_s == ";" && level == 0 )
+  
+            parse_class( codefrag, comments ) if ( codefrag.length > 0 && found_open )
+  
+            codefrag = TokenStream.new()
+  
+            has_class = false
+            found_open = false
+  
+          end
+  
+        end
+  
+        has_class = true if ( tok.to_s.downcase == "class" && level == 0 )
+  
+      }
+  
+      parse_class( codefrag, comments ) if ( codefrag.length > 0 && found_open )
+  
+    end
+  
+    # to_s()
+    #
+    # A pretty printer for the object
+  
+    def to_s()
+  
+      text = ""
+  
+      classes.each { |cpp_class| text += cpp_class.to_s }
+  
+      text
+  
+    end
+  
+  protected
+  
+    # parse_class( codefrag, comments )
+    # 
+    # codefrag - The class tokens
+    # comments - The comments before the class
+    #
+    # Parse the class tokens to find methods, instance variables, constants,
+    # etc.
+    
+    def parse_class( codefrag, comments )
+  
+      class_data = build_class()
+  
+      proto = TokenStream.new()
+  
+      level = 0
+  
+      visibility = "public"
+  
+      comments = TokenStream.new()
+  
+      codefrag.each { |tok|
+  
+        break if ( tok.to_s == "}" && level == 1 )
+  
+        if ( level == 0 )
+  
+          next if tok.to_s == ":" || tok.to_s == "public"
+          next if tok.to_s == "private" || tok.to_s == ","
+  
+          next unless tok.is_a?( CodeToken )
+  
+          if ( class_data.name.length == 0 )
+  
+            class_data.name = tok.to_s
+  
+          else
+  
+            class_data.add_parent( tok.to_s ) unless ( tok.to_s == "{" )
+  
+          end
+  
+        else
+  
+          if ( tok.to_s =~ /^public$/ )
+  
+            visibility = "public"
+            comments = TokenStream.new()
+            proto = TokenStream.new()
+  
+          elsif ( tok.to_s =~ /^private$/ )
+  
+            visibility = "private"
+            comments = TokenStream.new()
+            proto = TokenStream.new()
+  
+          elsif ( tok.to_s =~ /^protected$/ )
+  
+            visibility = "protected"
+            comments = TokenStream.new()
+            proto = TokenStream.new()
+  
+          elsif ( tok.is_a?( CommentToken ) )
+            
+              comments.push( tok ) if ( level == 1 )
+  
+          elsif ( tok.to_s == ":" && level == 1 )
+  
+          elsif ( tok.to_s == ";" && level == 1 )
+            
+            parse_method_prototype( class_data, visibility, proto, comments ) if proto.length > 0
+            comments = TokenStream.new()
+            proto = TokenStream.new()
+  
+          elsif ( level ==  1 )
+  
+              proto.push( tok )
+  
+          end
+  
+        end
+  
+        if ( tok.to_s == "{" )
+  
+          parse_method_prototype( class_data, visibility, proto, comments ) if proto.length > 0
+          comments = TokenStream.new()
+        
+          level += 1
+  
+        end
+  
+      }
+  
+      @classes.push( class_data )
+  
+    end
+  
+    # parse_method_prototype( class_data, visibility, codefrag, comment )
+    #
+    # class_data - The current class object
+    # visibility - 'private', 'protected', or 'public'
+    # codefrag - The tokens of the prototype
+    # comment - The comments before the method declaration
+    
+    def parse_method_prototype( class_data, visibility, codefrag, comment )
+  
+      # Get down to just the code, no comments or whitespace
+  
+      code = codefrag.code_only
+  
+      # The primary switch is whether this is a method or an instance variable.
+      # That's decided on the existence of the paren.
+  
+      if ( code.find( "(" ) )
+  
+        # Get the prototype
+  
+        proto = parse_prototype( codefrag, comment )
+  
+        # Add in the visibility
+  
+        proto.visibility = visibility
+  
+        # Check for a static method
+  
+        if ( proto.method_type =~ /^static/ )
+  
+          proto.method_type.sub!( /^static\s+/, "" )
+          proto.static = true
+       
+        end
+  
+        # Add this method into the class
+  
+        class_data.add_method( proto )
+  
+      else
+  
+        # Build the variable object
+      
+        varItem = build_class_variable()
+  
+        # Parse the declaration
+      
+        varSpec = parse_declaration( codefrag )
+  
+        # Look for static
+  
+        static = false
+        if ( varSpec[ 'type' ] =~ /^static/ )
+  
+          varSpec[ 'type' ].sub!( /^static\s+/, "" )
+          static = true
+       
+        end
+  
+        # Look for const
+  
+        if ( varSpec[ 'type' ] =~ /^const/ )
+  
+          varSpec[ 'type' ].sub!( /^const\s+/, "" )
+          const = true
+       
+        end
+  
+        # Fill the fields of the object mainly with the return from
+        # parse_declaration
+  
+        varItem.name = varSpec[ 'name' ]
+        varItem.type = varSpec[ 'type' ]
+        varItem.value = varSpec[ 'value' ]
+        varItem.static = static
+        varItem.const = const
+        varItem.visibility = visibility
+        varItem.comment = comment
+  
+        # Add the variable to the class
+  
+        class_data.add_variable( varItem )
+  
+      end
+  
+    end
+  
+    # build_class_variable()
+    #
+    # Returns a new class variable object
+  
+    def build_class_variable
+  
+      @variableClass.new()
+  
+    end
+  
+    # build_class()
+    #
+    # REturns a new class object
+  
+    def build_class
+  
+      @languageClass.new()
+  
+    end
+  
+  end
+end