#!/usr/bin/ruby

class MethodDef
  def initialize(returnType, signature, optional)
    @returnType = returnType
    @signature = signature
    @optional = optional
  end

  attr_reader :returnType, :signature, :optional
  attr_writer :optional
end

class SignalDef
  def initialize(signature)
    @signature = signature
  end

  attr_reader :signature
end

class Parser
    def initialize(filename)
      @file = File.new filename, "r"
      @signatures = Hash.new
      parse
    end

    attr_reader :signatures

    private
    def addSignal(signature)
      unless @signatures.include? signature
        @signatures[signature] = SignalDef.new(signature)
      end
    end

    def addMethod(returnType, signature, optional)
      if @signatures.include? signature
        if returnType != ''
          if @signatures[signature].returnType == ''
            optional = false if @signatures[signature].optional == false
            @signatures[signature] = MethodDef.new(returnType, signature, optional)
          elsif @signatures[signature].returnType != returnType
            fail "same signature '#{signature}' but differing return types: #{returnType} and #{@signatures[signature].returnType}"
          end
        elsif not optional and @signatures[signature].optional
          @signatures[signature].optional = false
        end
      else
        @signatures[signature] = MethodDef.new(returnType, signature, optional)
      end
    end

    PARSER_RETURN_TYPE   = 0
    PARSER_RETURN_VAR    = 1
    PARSER_METHOD_NAME   = 2
    PARSER_ARGUMENT_TYPE = 3
    PARSER_ARGUMENT_VAR  = 4

    PARSER2_CLASSNAME     = 0
    PARSER2_METHODPREFIX  = 1

    PARSER3_QMETAOBJECT   = 0
    PARSER3_SCOPEDELIMIT  = 1
    PARSER3_INVOKEMETHOD  = 2
    PARSER3_OPENPARENTH   = 3
    PARSER3_BACKENDOBJ    = 4
    PARSER3_METHODNAME    = 5
    PARSER3_CONNECTION    = 6
    PARSER3_RET_OR_ARG    = 7
    PARSER3_RET_OPEN      = 8
    PARSER3_RET_TYPE      = 9
    PARSER3_RET_NAME      = 10
    PARSER3_RET_CLOSE     = 11
    PARSER3_ARG           = 12
    PARSER3_ARG_OPEN      = 13
    PARSER3_ARG_TYPE      = 14
    PARSER3_ARG_NAME      = 15
    PARSER3_ARG_CLOSE     = 16
    PARSER3_CLOSE         = 17
    PARSER3_DONE          = 18

    PARSER4_OPENING_PAREN                  = 0
    PARSER4_SENDER                         = 1
    PARSER4_PRIVATE_SENDER                 = 2
    PARSER4_COMMA_1                        = 3
    PARSER4_SIGNAL_MACRO                   = 4
    PARSER4_SIGNAL_OPENING_PAREN           = 5
    PARSER4_SIGNAL_SIGNATURE               = 6
    PARSER4_SIGNAL_SIGNATURE_OPENING_PAREN = 7
    PARSER4_SIGNAL_SIGNATURE_CONST         = 8
    PARSER4_SIGNAL_SIGNATURE_TYPE1         = 9
    PARSER4_SIGNAL_SIGNATURE_TYPE2_1       = 10
    PARSER4_SIGNAL_SIGNATURE_TYPE2_2       = 11
    PARSER4_SIGNAL_CLOSING_PAREN           = 12

    def parse
      inbackendcall = false
      innamedescriptioncall = false
      ininvokemethodcall = false
      invokemethodcallOnBackendObject = false
      inconnect = false
      optionalmethod = false
      lasttoken = ';'
      thistoken = ';'
      returnType = String.new
      signature = String.new
      parserstate = PARSER_RETURN_TYPE
      depth = 0
      tokenize do |token|
        #STDERR.puts token
        lasttoken = thistoken
        thistoken = token
        token = token[1..-1] if token[0,9] == "pBACKEND_"
        if token[0,8] == "BACKEND_"
          fail if innamedescriptioncall
          fail if inbackendcall
          fail if ininvokemethodcall
          fail if inconnect
          inbackendcall = true
          if token[8,3] != "GET" # skip return arg
            parserstate = PARSER_METHOD_NAME
            returnType = ''
          else
            parserstate = PARSER_RETURN_TYPE
          end
        elsif token == 'NAMEDESCRIPTIONFROMINDEX'
          fail if innamedescriptioncall
          fail if inbackendcall
          fail if ininvokemethodcall
          fail if inconnect
          innamedescriptioncall = true
          parserstate = PARSER2_CLASSNAME
        elsif token == 'QMetaObject'
          fail if innamedescriptioncall
          fail if inbackendcall
          fail if ininvokemethodcall
          fail if inconnect
          ininvokemethodcall = true
          parserstate = PARSER3_SCOPEDELIMIT
          optionalmethod = (lasttoken[-1,1] == '=' or lasttoken == '(' or lasttoken == '!') ? true : false
        elsif token == 'connect'
          fail if innamedescriptioncall
          fail if inbackendcall
          fail if ininvokemethodcall
          fail if inconnect
          inconnect = true
          parserstate = PARSER4_OPENING_PAREN
        elsif inconnect
          #puts "state = #{parserstate}, token = #{token}"
          lastparserstate = parserstate
          case parserstate
          when PARSER4_OPENING_PAREN
            parserstate = PARSER4_SENDER if token == '('
          when PARSER4_SENDER
            # d->m_backendObject or only m_backendObject
            parserstate = PARSER4_COMMA_1 if token == 'm_backendObject'
            parserstate = PARSER4_PRIVATE_SENDER if token == 'd'
          when PARSER4_PRIVATE_SENDER
            parserstate = PARSER4_SENDER if token == '->'
          when PARSER4_COMMA_1
            parserstate = PARSER4_SIGNAL_MACRO if token == ','
          when PARSER4_SIGNAL_MACRO
            parserstate = PARSER4_SIGNAL_OPENING_PAREN if token == 'SIGNAL'
          when PARSER4_SIGNAL_OPENING_PAREN
            parserstate = PARSER4_SIGNAL_SIGNATURE if token == '('
          when PARSER4_SIGNAL_SIGNATURE
            signature = token
            parserstate = PARSER4_SIGNAL_SIGNATURE_OPENING_PAREN
          when PARSER4_SIGNAL_SIGNATURE_OPENING_PAREN
            case token
            when '('
              signature += '('
              parserstate = PARSER4_SIGNAL_SIGNATURE_CONST
            when '()'
              signature += '()'
              parserstate = PARSER4_SIGNAL_CLOSING_PAREN
            end
          when PARSER4_SIGNAL_SIGNATURE_CONST
            case token
            when 'const'
              signature += 'const '
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE1
            when ')'
              signature += ')'
              parserstate = PARSER4_SIGNAL_CLOSING_PAREN
            else
              signature += token
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE2_1
            end
          when PARSER4_SIGNAL_SIGNATURE_TYPE1
            case token
            when 'const'
            when ')'
            else
              signature += token
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE2_1
            end
          when PARSER4_SIGNAL_SIGNATURE_TYPE2_1
            case token
            when ','
              signature += ', '
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE1
            when ')'
              signature += ')'
              parserstate = PARSER4_SIGNAL_CLOSING_PAREN
            else
              signature += token
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE2_2
            end
          when PARSER4_SIGNAL_SIGNATURE_TYPE2_2
            case token
            when ','
              signature += ', '
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE1
            when ')'
              signature += ')'
              parserstate = PARSER4_SIGNAL_CLOSING_PAREN
            else
              signature += token
              parserstate = PARSER4_SIGNAL_SIGNATURE_TYPE2_1
            end
          when PARSER4_SIGNAL_CLOSING_PAREN
            addSignal(signature) if token == ')'
          end
          if parserstate == lastparserstate
            inconnect = false
            signature = String.new
          end
        elsif ininvokemethodcall
          case parserstate
          when PARSER3_BACKENDOBJ
            if token == ','
              if invokemethodcallOnBackendObject
                parserstate += 1
              else
                ininvokemethodcall = false
              end
            elsif token =~ /backendObject/
              invokemethodcallOnBackendObject = true
            end
          when PARSER3_SCOPEDELIMIT
            if token == '::'
              parserstate += 1
            else
              ininvokemethodcall = false
            end
          when PARSER3_INVOKEMETHOD
            if token == 'invokeMethod'
              parserstate += 1
            else
              ininvokemethodcall = false
            end
          when PARSER3_OPENPARENTH
            fail if token != '('
            parserstate += 1
            invokemethodcallOnBackendObject = false
          when PARSER3_METHODNAME
            case token
            when ','
              signature += '('
              parserstate = PARSER3_CONNECTION
            else
              fail if signature.length > 0
              signature = token[1..-2]
            end
          when PARSER3_CONNECTION
            case token
            when ','
              parserstate = PARSER3_RET_OR_ARG
            when ')'
              parserstate = PARSER3_CLOSE
# the connection is optional
            when 'Q_RETURN_ARG'
              parserstate = PARSER3_RET_OPEN
            when 'Q_ARG'
              returnType = ''
              parserstate = PARSER3_ARG_OPEN
            end
          when PARSER3_RET_OR_ARG
            if token == 'Q_RETURN_ARG'
              parserstate = PARSER3_RET_OPEN
            elsif token == 'Q_ARG'
              returnType = ''
              parserstate = PARSER3_ARG_OPEN
            else
              fail "unexpected token '#{token}"
            end
          when PARSER3_RET_TYPE
            if token == ','
              parserstate += 1
            else
              if token == '*' or token == '&' or token == '<' or token == '>' or token == '::' or returnType.empty? or returnType[-1,1] == '<' or returnType[-2,2] == '::'
                returnType += token
              else
                returnType += ' ' + token
              end
            end
          when PARSER3_RET_NAME
            parserstate = PARSER3_RET_CLOSE if token == ')'
          when PARSER3_RET_CLOSE
            case token
            when ')'
              parserstate = PARSER3_CLOSE
            when ','
              parserstate = PARSER3_ARG
            end
          when PARSER3_ARG
            if token == 'Q_ARG'
              parserstate = PARSER3_ARG_OPEN
            else
              fail "unexpected token '#{token}"
            end
          when PARSER3_ARG_TYPE
            if token == ','
              parserstate += 1
            else
              signature += ' ' if signature[-1,1] =~ /\w/ and token[0,1] =~ /\w/
              signature += token
            end
          when PARSER3_ARG_NAME
            case token
            when '('
              depth += 1
            when ')'
              if depth == 0
                parserstate = PARSER3_ARG_CLOSE
              else
                depth -= 1
              end
            end
          when PARSER3_ARG_CLOSE
            case token
            when ','
              signature += ','
              parserstate = PARSER3_ARG
            when ')'
              parserstate = PARSER3_CLOSE
            else
              fail
            end
          when PARSER3_ARG_OPEN, PARSER3_RET_OPEN
            fail if token != '('
            parserstate += 1
          when PARSER3_CLOSE
            signature += ')'
            addMethod returnType, signature, optionalmethod
            ininvokemethodcall = false
            returnType = String.new
            signature = String.new
          end
        elsif innamedescriptioncall
          case parserstate
          when PARSER2_CLASSNAME
            parserstate = PARSER2_METHODPREFIX if token == ','
          when PARSER2_METHODPREFIX
            addMethod 'QSet<int>', token + 'Indexes()', false
            addMethod 'int', token + 'Name()', false
            addMethod 'int', token + 'Description()', false
            innamedescriptioncall = false
          end
        elsif inbackendcall
          next if token == '(' # skip (
          if token == ';'
            if signature.length > 0
              signature += ')'
              addMethod returnType, signature, false
              signature = String.new
              returnType = String.new
            end
            inbackendcall = false
          else
            if token == ','
              if parserstate == PARSER_ARGUMENT_VAR
                signature += ','
                parserstate = PARSER_ARGUMENT_TYPE
              else
                parserstate += 1
              end
              next
            end
            case parserstate
            when PARSER_RETURN_TYPE
              returnType += token
            when PARSER_RETURN_VAR
            when PARSER_METHOD_NAME
              next if token == ')'
              fail if token[0,1] != '"' or token[-1,1] != '"'
              fail if signature.length > 0
              signature = token[1..-2] + '('
            when PARSER_ARGUMENT_TYPE
              signature += token
            end
          end
        end
      end
    end

    def tokenize
      incomment = false
      instring = false
      laststring = ''
      linenum = 0
      @file.each_line do |line|
        linenum += 1
        line.strip!
        next if line[0..1] == "//"
        next if line[0,1] == "#" # ignore preprocessor statements
        line.split(/(\b|\s+)/).each do |token|
          #STDERR.puts "string: #{instring} comment: #{incomment} token: '#{token}'"
          if instring
            indexOfEscapedQuote = token.index '\\"'
            if indexOfEscapedQuote != nil
              laststring += token
              next
            end
            indexOfQuote = token.index '"'
            if indexOfQuote and indexOfQuote > 0
              fail if token[indexOfQuote-1,1] == '\\'
              laststring += token[0..indexOfQuote-1]
              token = token[indexOfQuote..-1]
            end
            if token[0,2] == '""'
              laststring += token[2..-1]
              next
            elsif token[0,1] == '"'
              if laststring[-1,1] == '\\'
                laststring[-1,1] = '"'
                laststring += token[1..-1]
                next
              end
              instring = false
              yield laststring + '"'
              token = token[1..-1]
            else
              laststring += token
              next
            end
          end
          token.strip!
          next if token.empty?
          if incomment
            incomment = false if token[0..1] == "*/"
            next
          else
            if token[0..1] == "/*"
              incomment = true
              next
            end
            break if token == "//"
          end
          doublequote = token.index '""'
          if doublequote != nil
            if doublequote > 0
              yield token[0,doublequote]
            end
            yield '""'
            if token.length > doublequote+2
              token = token[doublequote+2..-1]
            else
              next
            end
          end
          quote = token.index '"'
          if quote != nil
            laststring = token[quote..-1]
            instring = true
            if quote > 0
              token = token[0,quote]
            else
              next
            end
          end
          semicolon = token.index ';'
          if not semicolon
            tokenize2(token) { |i| yield i }
          elsif semicolon > 0
            tokenize2(token[0..semicolon-1]) { |i| yield i }
            yield ';'
            if token.length > semicolon + 1
              tokenize2(token[semicolon+1..-1]) { |i| yield i }
            end
          elsif (semicolon == 0 and token.length > 1)
            yield ';'
            tokenize2(token[1..-1]) { |i| yield i }
          else
            yield token # a single ;
          end
        end
      end
    end

    def tokenize2(token)
      if token.length > 1
        #STDERR.puts "long token: #{token}"
        while token[0,1] == '(' or token[0,1] == ')' or token[0,1] == "'" or token[0,1] == '&'
          yield token[0,1]
          token = token[1..-1]
          #STDERR.puts "less long token: #{token}"
        end
        return if token.empty?
        if token.length == 1
          yield token
          return
        elsif token[-1,1] == ',' or token[-1,1] == "'"
          yield token[0..-2]
          yield token[-1,1]
          return
        end
      end
      yield token
    end
end

p = Parser.new ARGV[0]
p.signatures.each do |signature,method|
  if method.class == SignalDef
    puts "addSignal(\"#{signature}\");"
  else
    if method.optional
      puts "addMethod(\"#{method.returnType}\", \"#{signature}\", true);"
    else
      puts "addMethod(\"#{method.returnType}\", \"#{signature}\");"
    end
  end
end