ctioga2 0.0

data/lib/ctioga2/commands/parsers/command-line.rb

@@ -0,0 +1,187 @@
+# command-line.rb: a command-line parser for ctioga2
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# 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 (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/log'
+require 'ctioga2/commands/commands'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module Commands
+
+    # In this modules are classes that parse a source of commands, and
+    # yield to the caller the commands (Command) along with their
+    # unprocessed arguments.
+    module Parsers
+
+      # An exception raised upon redefinition of a short or long
+      # option.
+      class OptionRedefined < Exception
+      end
+
+      # An exception raised when the parser encounters an unkown
+      # option.
+      class OptionUnkown < Exception
+      end
+
+      # This class is in charge of parsing a command-line against a
+      # list of known commands.
+      class CommandLineParser
+        include Log
+
+        # A hash 'short-option-letter' => [number of args, Command]
+        attr_reader :short_options
+
+        # A hash 'long-option-name'    => [number of args, Command]
+        attr_reader :long_options
+
+        # The list of commands
+        attr_reader :commands
+
+        # A [number of args, Command] for the default command, ie
+        # the one that applies on non-command files.
+        attr_reader :default_command
+        
+        # Creates a CommandLineParser that will understand the
+        # given _commands_
+        def initialize(commands, default = nil)
+          @commands = commands
+          prepare_option_hashes(default)
+        end
+
+
+        # Takes an _argv_ array representing the command-line and a
+        # target _intepreter_, and runs the commands found on the
+        # command line. Yields arguments which are not part of a
+        # command, or feed them to the #default_command if it was
+        # specified.
+        def parse_command_line(argv, interpreter)
+          # We duplicate the original array
+          argv = argv.dup
+          options = nil         # currently never used.
+          while argv.size > 0
+            current = argv.shift
+            if current =~ /^--(.*)/ # a long option
+              if @long_options.key?($1)
+                command, arguments, options = 
+                  extract_command_arguments(argv, @long_options[$1])
+
+                interpreter.run_command(command, arguments, options)
+              else
+                raise OptionUnkown, "Long option #{current} is not known"
+              end
+            elsif current =~ /^-(.*)/ # Short options
+              # We do the same as above, but splitting into letters first:
+              short_options = $1.split('')
+              for short in short_options
+                if @short_options.key?(short)
+                  command, arguments, options = 
+                    extract_command_arguments(argv, @short_options[short])
+                  interpreter.run_command(command, arguments, options)
+                else
+                  raise OptionUnkown, "Short option -#{short} is not known"
+                end
+              end
+            else
+              if @default_command
+                argv.unshift current
+                command, arguments, options = 
+                  extract_command_arguments(argv, @default_command)
+                interpreter.run_command(command, arguments, options)
+              else
+                yield current
+              end
+            end
+          end
+        end
+
+        protected
+        
+        # Prepares the #short_options and #long_options hashes for use
+        # in #parse_command_line
+        def prepare_option_hashes(default = nil)
+          @short_options = {} 
+          @long_options = {}
+          for cmd in @commands
+            short = cmd.short_option
+            boolean = (cmd.argument_number == 1 && 
+                       cmd.arguments.first.type.boolean?)
+            if short 
+              if @short_options.key? short
+                raise OptionRedefined, "Short option #{short} was already defined as command #{cmd.name}"
+              end
+              if boolean
+                @short_options[short] = [-1, cmd]
+              else
+                @short_options[short] = [cmd.argument_number, cmd]
+              end
+            end
+            long = cmd.long_option
+            if long
+              if @long_options.key? short
+                raise OptionRedefined, "Long option #{long} was already defined as command #{cmd.name}"
+              end
+              if boolean
+                @long_options[long] = [-1, cmd]
+                @long_options["no-#{long}"] = [-2, cmd]
+              else
+                @long_options[long] = [cmd.argument_number, cmd]
+              end
+            end
+          end
+          if default
+            @default_command = [default.argument_number, default]
+          end
+        end
+
+        # Extract command, arguments and potential options from the
+        # given _argv_ array. The second argument is what is stored in
+        # the #short_options and #long_options hashes.
+        #
+        # Returns an array
+        #  [command, arguments, options]
+        def extract_command_arguments(argv, cmd_val)
+          number, command = cmd_val
+          options = {}
+
+          # Special case for boolean arguments
+          if number < 0
+            arguments = [number == -1]
+          else
+            arguments = argv.slice!(0,number)
+          end
+          
+          # We try and go fishing for options, in the form
+          # /option=stuff.
+          while argv.first =~ /^\/([\w-]+)=(.*)/
+            if command.has_option? $1
+              options[$1] = $2
+              argv.shift
+            else
+              warn "Argument #{argv.first} looks like an option, but does not match any of the command #{command.name}"
+              break
+            end
+          end
+
+          return [command, arguments, options]
+
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/ctioga2/commands/parsers/file.rb

@@ -0,0 +1,186 @@
+# file.rb: a file parser for ctioga2
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# 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 (in the COPYING file).
+
+require 'stringio'
+require 'ctioga2/utils'
+require 'ctioga2/log'
+require 'ctioga2/commands/commands'
+require 'ctioga2/commands/strings'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module Commands
+
+    module Parsers
+
+      # Raised when EOF is encountered during a symbol parsing
+      class UnterminatedSymbol < Exception
+      end
+
+      # Unexepected character.
+      class UnexpectedCharacter < Exception
+      end
+
+      # Syntax error
+      class ParserSyntaxError < Exception
+      end
+
+      # This class is in charge of parsing a command-line against a list
+      # of known commands. 
+      class FileParser
+
+        include Log
+
+        # Runs a command file targeting the given _interpreter_.
+        def self.run_command_file(file, interpreter)
+          FileParser.new.run_command_file(file, interpreter)
+        end
+
+        # Runs the given command strings
+        def self.run_commands(strings, interpreter)
+          FileParser.new.run_commands(strings, interpreter)
+        end
+
+        # Runs a command file targeting the given _interpreter_.
+        def run_command_file(file, interpreter)
+          f = open(file)
+          parse_io_object(f, interpreter)
+        end
+
+        # Runs the given command strings
+        def run_commands(strings, interpreter)
+          io = StringIO.new(strings)
+          parse_io_object(io, interpreter)
+        end
+
+        # Parses a given _io_ object, sending commands/variable
+        # definitions to the given _interpreter_.
+        def parse_io_object(io, interpreter)
+          # The process is simple: we look for symbols and
+          # corresponding syntax element: parentheses or assignments
+          while(1)
+            symbol = up_to_next_symbol(io)
+            break if not symbol
+            
+            while(1)
+              c = io.getc
+              if ! c              # EOF
+                raise ParserSyntaxError, "Expecting something after symbol #{symbol}"
+              end
+              ch = c.chr
+              if ch =~ /\s/      # blank...
+                next
+              elsif ch == '('    # beginning of a function call
+                # Parse string:
+                str = InterpreterString.parse_until_unquoted(io,")")
+                # Now, we need to split str.
+                args = str.expand_and_split(/\s*,\s*/, interpreter)
+
+                cmd = interpreter.get_command(symbol)
+                real_args = args.slice!(0, cmd.argument_number)
+                # And now the options:
+                options = {}
+
+                # Problem: the space on the right of the = sign is
+                # *significant*. 
+                for o in args
+                  if o =~ /^\s*([\w-]+)\s*=(.*)/
+                    if cmd.has_option? $1
+                      options[$1] = $2
+                    else
+                      error "Command #{cmd.name} does not take option #{$1}"
+                    end
+                  end
+                end
+
+                interpreter.run_command(cmd, real_args, options)
+                io.getc         # Slurp up the )
+                break
+              elsif ch == ':'   # Assignment
+                c = io.getc
+                if ! c          # EOF
+                  raise ParserSyntaxError, "Expecting = after :"
+                end
+                ch = c.chr
+                if ch != '='
+                  raise ParserSyntaxError, "Expecting = after :"
+                end
+                str = InterpreterString.parse_until_unquoted(io,"\n", false)
+                interpreter.variables.define_variable(symbol, str, 
+                                                      interpreter)
+                break
+              elsif ch == '='
+                str = InterpreterString.parse_until_unquoted(io,"\n", false)
+                interpreter.variables.define_variable(symbol, str, nil) 
+                break
+              else
+                raise UnexpectedCharacter, "Did not expect #{ch} after #{symbol}"
+              end
+            end
+          end
+        end
+
+        protected
+
+        SYMBOL_CHAR_REGEX = /[a-zA-Z0-9_-]/
+        
+        # Parses the _io_ stream up to and including the next
+        # symbol. Only white space or comments may be found on the
+        # way. This function returns the symbol.
+        #
+        # Symbols are composed of the alphabet SYMBOL_CHAR_REGEX.
+        def up_to_next_symbol(io)
+
+          symbol = nil          # As long as no symbol as been started
+          # it will stay nil.
+          while(1)
+            c = io.getc
+            if ! c              # EOF
+              if symbol
+                raise UnterminatedSymbol, "EOF reached during symbol parsing"
+              else
+                # File is finished and we didn't meet any symbol.
+                # Nothing to do !
+                return nil
+              end
+            end
+            ch = c.chr
+            if symbol           # We have started
+              if ch =~ SYMBOL_CHAR_REGEX
+                symbol += ch
+              else
+                io.ungetc(c)
+                return symbol
+              end
+            else
+              if ch =~ SYMBOL_CHAR_REGEX
+                symbol = ch
+              elsif ch =~ /\s/
+                # Nothing
+              elsif ch == '#'
+                io.gets
+              else
+                raise UnexpectedCharacter, "Unexpected character: #{ch}, when looking for a symbol"
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/ctioga2/commands/strings.rb

@@ -0,0 +1,303 @@
+# strings.rb: the core of the file-based interpretation: strings !
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# 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 (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'stringio'              # For debugging purposes
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module Commands
+
+    class UnterminatedString < Exception
+    end
+
+    # All variables and arguments are only strings. There is no type
+    # in ctioga, at least not on the variable/strings level. Ruby
+    # functions of course work with typed objects, but all user input
+    # is taken to be a string and is converted using the
+    # CTioga2::Metabuilder::Type system.
+    #
+    # A string is however not a simple Ruby String, as it can contain
+    # elements that are expanded, and it needs to provide a way to be
+    # split into substrings for arguments/options processing.
+    #
+    # A string is composed of an array of [type, value, ... ? ]
+    # arrays, where _type_ can have the following meanings:
+    # * :unquoted : an unquoted string (can be split)
+    # * :unquoted_variable : an unquoted variable (replacement text
+    #   can be split)
+    # * :quoted : a quoted string (cannot be split)
+    # * :quoted_variable : a quoted variable (cannot be split)
+    class InterpreterString
+
+      # A small lexical parser. It's job is to carry out the function
+      # of InterpreterString.parse_until_unquoted.
+      class LexicalAnalyzer
+        # The state of the parser:
+        # * :start -> first starting elements
+        # * :top -> toplevel
+        # * :single -> in a single quoted string
+        # * :double -> in a double quoted string
+        # * :dollar -> last element was a dollar at top-level
+        # * :dq_dollar -> last element was an unescaped dollar within
+        #   a double quoted string
+        # * :escape -> last element was an unescaped escape char
+        #   within a double-quoted string.
+        # * :var -> in a $(variable)
+        # * :dq_var -> in a $(variable) within a double-quoted string
+        attr_accessor :state
+
+        # The current string result, as described in InterpreterString
+        attr_accessor :parsed
+
+        # The current object on the way of being parsed
+        attr_accessor :current_string
+        
+        # The io device with which the parser is interacting.
+        attr_accessor :io
+
+        # The terminating element
+        attr_accessor :term
+
+        # Initializes the parser.
+        def initialize(io, term)
+          @io = io
+          @term = term
+        end
+
+        # Parse the string from the _io_ object
+        def parse(eoerror = true)
+          @state = :start
+          @parsed = []
+          @current_string = ''
+          
+          i = -1
+          while(1)
+            c = @io.getc
+            if ! c              # EOF
+              if eoerror
+                raise UnterminatedString, "EOF reached before the end of this string"
+              else
+                push_current_element
+                return @parsed
+              end
+            end
+            # Convert the integer to a string.
+            ch = c.chr
+            i += 1
+            if (@state == :start || @state == :top) and
+                (term.include?(ch)) # Finished
+              push_current_element
+              @io.ungetc(c)     # We push back the last char.
+              return @parsed
+            end
+
+            # puts "#{@state.inspect} -- #{ch}"
+
+            # We skip white space at the beginning of the string.
+            if @state == :start
+              # Skip white space
+              if ! (ch =~ /\s/)
+                @state = :top
+              end
+            end
+
+            case @state
+            when :escape
+              # Evaluating escape chars
+              @current_string += eval("\"\\#{ch}\"")
+              @state = :double
+            when :dollar, :dq_dollar
+              @state = (@state == :dollar ? :top : :double)
+              if ch == '('      # Beginning of a variable within a
+                # quoted string
+                push_current_element
+                @state = (@state == :top ? :var : :dq_var)
+              else
+                @current_string += "$#{ch}"
+              end
+            when :single        # The simplest string
+              if ch == "'"      # End of string
+                push_current_element
+                @state = :top
+              else
+                @current_string += ch
+              end
+            when :var, :dq_var
+              if ch == ")"
+                push_current_element
+                @state = (@state == :var ? :top : :double)
+              else
+                @current_string += ch
+              end
+            when :top
+              if ch == "'"      # We start a single-quoted string
+                push_current_element
+                @state = :single
+              elsif ch == '$'   # Dollar state
+                @state = :dollar
+              elsif ch == '"'
+                push_current_element
+                @state = :double
+              elsif ch == '#'   # A comment: we read until end-of-line
+                @io.gets        # and ignore the results
+              else
+                @current_string += ch
+              end
+            when :double
+              if ch == '"'      # (necessarily unquoted)
+                push_current_element
+                @state = :top
+              elsif ch == '$'
+                @state = :dq_dollar
+              elsif ch == "\\"
+                @state = :escape
+              else
+                @current_string += ch
+              end
+            end
+          end
+          
+        end
+
+        # Pushes the element currently being parsed unto the
+        # result
+        def push_current_element
+          if @current_string.size == 0
+            return
+          end
+          case @state
+          when :top
+            # We push an unquoted string
+            @parsed << [:unquoted, @current_string]
+          when :single, :double
+            @parsed << [:quoted, @current_string]
+          when :var
+            @parsed << [:unquoted_variable, @current_string]
+          when :dq_var
+            @parsed << [:quoted_variable, @current_string]
+          when :dollar
+            @parsed << [:unquoted, @current_string + '$']
+          when :dq_dollar
+            @parsed << [:quoted, @current_string + '$']
+          when :escape
+            @parsed << [:quoted, @current_string + "\\" ]
+          when :start
+            # Empty string at the beginning. Nothing interesting, move
+            # along !
+          else
+            raise "Fatal bug of the lexical analyzer here : unkown state"
+          end
+          # Flush current string
+          @current_string = ""
+        end
+
+      end
+
+
+      # The array of the aforementioned [_type_, _value_, ...] arrays
+      attr_accessor :contents
+      
+      # Read the given _io_ stream until an unquoted element of
+      # _term_ is found. Returns the parsed InterpreterString.
+      # The terminating element is pushed back onto the stream.
+      #
+      # If _io_ encounters EOF before the parsing is finished, an
+      # UnterminatedString exception is raised, unless the _eoerror_
+      # is false.
+      #
+      # This is the *central* function of the parsing of files.
+      def self.parse_until_unquoted(io, term, eoerror = true)
+        string = InterpreterString.new
+        string.contents = LexicalAnalyzer.new(io, term).parse(eoerror)
+        return string
+      end
+
+      def initialize(contents = [])
+        @contents = contents
+      end
+
+      # Fully expand the InterpreterString to obtain a String object.
+      # _interpreter_ is the Interpreter object in which the expansion
+      # takes place.
+      def expand_to_string(interpreter)
+        pre_expanded = expand_all_variables(interpreter)
+        retval = ""
+        for type, value in pre_expanded.contents 
+          retval += value
+        end
+        return retval
+      end
+
+      # Splits the string, after expansion, in the *unquoted* parts,
+      # where _re_ matches, and returns the corresponding array of
+      # strings.
+      #
+      # An empty expanded string expands to a null array.
+      def expand_and_split(re, interpreter)
+        pre_expanded = expand_all_variables(interpreter)
+        retval = []
+        cur_str = ""
+        for type, value in pre_expanded.contents
+          case type
+          when :quoted
+            cur_str += value
+          when :unquoted
+            tmp = value.split(re, -1)
+            cur_str += tmp[0]
+            # Push splitted stuff here:
+            while tmp.size > 1
+              retval << cur_str
+              tmp.shift
+              cur_str = tmp[0]
+            end
+          end
+        end
+        retval << cur_str
+        if (retval.size == 1) && (retval.first == "")
+          return []
+        end
+        return retval
+      end
+
+      protected
+
+      # Returns a new InterpreterString object with all variables
+      # expanded. _interpreter_ is the Interpreter in which the
+      # expansion takes place.
+      def expand_all_variables(interpreter)
+        c = []
+        for type, value in @contents
+          case type
+          when :quoted_variable
+            c << [:quoted, interpreter.variables.
+                  expand_variable(value, interpreter)]
+          when :unquoted_variable
+            c << [:unquoted, interpreter.variables.
+                  expand_variable(value, interpreter)]
+          else
+            c << [type, value]
+          end
+        end
+        return InterpreterString.new(c)
+      end
+      
+
+    end
+
+  end
+
+end
+