"""Script to generate reports on translator classes from Doxygen sources.

  The main purpose of the script is to extract the information from sources

  related to internationalization (the translator classes). It uses the

  information to generate documentation (language.doc,

  translator_report.txt) from templates (language.tpl, maintainers.txt).

  Simply run the script without parameters to get the reports and

  documentation for all supported languages. If you want to generate the

  translator report only for some languages, pass their codes as arguments

  to the script. In that case, the language.doc will not be generated.

  Example:

    python translator.py en nl cz

  Originally, the script was written in Perl and was known as translator.pl.

  The last Perl version was dated 2002/05/21 (plus some later corrections)

                                         Petr Prikryl (prikryl at atlas dot cz)

  History:

  --------

  2002/05/21 - This was the last Perl version.

  2003/05/16 - List of language marks can be passed as arguments.

  2004/01/24 - Total reimplementation started: classes TrManager, and Transl.

  2004/02/05 - First version that produces translator report. No language.doc yet.

  2004/02/10 - First fully functional version that generates both the translator

               report and the documentation. It is a bit slower than the

               Perl version, but is much less tricky and much more flexible.

               It also solves some problems that were not solved by the Perl

               version. The translator report content should be more useful

               for developers.

  2004/02/11 - Some tuning-up to provide more useful information.

  2004/04/16 - Added new tokens to the tokenizer (to remove some warnings).

  2004/05/25 - Added from __future__ import generators not to force Python 2.3.

  2004/06/03 - Removed dependency on textwrap module.

  2004/07/07 - Fixed the bug in the fill() function.

  2004/07/21 - Better e-mail mangling for HTML part of language.doc.

             - Plural not used for reporting a single missing method.

             - Removal of not used translator adapters is suggested only

               when the report is not restricted to selected languages

               explicitly via script arguments.

  2004/07/26 - Better reporting of not-needed adapters.

  2004/10/04 - Reporting of not called translator methods added.

  2004/10/05 - Modified to check only doxygen/src sources for the previous report.

  2005/02/28 - Slight modification to generate "mailto.txt" auxiliary file.

  2005/08/15 - Doxygen's root directory determined primarily from DOXYGEN

               environment variable. When not found, then relatively to the script.

  2007/03/20 - The "translate me!" searched in comments and reported if found.

  2008/06/09 - Warning when the MAX_DOT_GRAPH_HEIGHT is still part of trLegendDocs().

  2009/05/09 - Changed HTML output to fit it with XHTML DTD

  2009/09/02 - Added percentage info to the report (implemented / to be implemented).

  2010/02/09 - Added checking/suggestion 'Reimplementation using UTF-8 suggested.

  2010/03/03 - Added [unreachable] prefix used in maintainers.txt.

  2010/05/28 - BOM skipped; minor code cleaning.

  2010/05/31 - e-mail mangled already in maintainers.txt

  2010/08/20 - maintainers.txt to UTF-8, related processing of unicode strings

             - [any mark] introduced instead of [unreachable] only

             - marks highlighted in HTML

  2010/08/30 - Highlighting in what will be the table in langhowto.html modified.

  2010/09/27 - The underscore in \latexonly part of the generated language.doc

               was prefixed by backslash (was LaTeX related error).

  2013/02/19 - Better diagnostics when translator_xx.h is too crippled.

  2013/06/25 - TranslatorDecoder checks removed after removing the class.

  2013/09/04 - Coloured status in langhowto. *ALMOST up-to-date* category

               of translators introduced.

  2014/06/16 - unified for Python 2.6+ and 3.0+

  """

from __future__ import print_function

import os

import platform

import re

import sys

import textwrap

def xopen(fname, mode='r', encoding='utf-8-sig'):

    '''Unified file opening for Python 2 an Python 3.

    Python 2 does not have the encoding argument. Python 3 has one, and

    the default 'utf-8-sig' is used (skips the BOM automatically).

    '''

    if sys.version_info[0] == 2:

        return open(fname, mode=mode) # Python 2 without encoding

    else:

        return open(fname, mode=mode, encoding=encoding) # Python 3 with encoding

def fill(s):

    """Returns string formatted to the wrapped paragraph multiline string.

    Replaces whitespaces by one space and then uses he textwrap.fill()."""

    # Replace all whitespace by spaces, remove whitespaces that are not

    # necessary, strip the left and right whitespaces, and break the string

    # to list of words.

    rexWS = re.compile(r'\s+')

    lst = rexWS.sub(' ', s).strip().split()

    # If the list is not empty, put the words together and form the lines

    # of maximum 70 characters. Build the list of lines.

    lines = []

    if lst:

        line = lst.pop(0)   # no separation space in front of the first word

        for word in lst:

            if len(line) + len(word) < 70:

                line += ' ' + word

            else:

                lines.append(line)  # another full line formed

                line = word         # next line started

        lines.append(line)          # the last line

    return '\n'.join(lines)

class Transl:

    """One instance is build for each translator.

    The abbreviation of the source file--part after 'translator_'--is used as

    the identification of the object. The empty string is used for the

    abstract Translator class from translator.h. The other information is

    extracted from inside the source file."""

    def __init__(self, fname, manager):

        """Bind to the manager and initialize."""

        # Store the filename and the reference to the manager object.

        self.fname = fname

        self.manager = manager

        # The instance is responsible for loading the source file, so it checks

        # for its existence and quits if something goes wrong.

        if not os.path.isfile(fname):

            sys.stderr.write("\a\nFile '%s' not found!\n" % fname)

            sys.exit(1)

        # Initialize the other collected information.

        self.classId = None

        self.baseClassId = None

        self.readableStatus = None   # 'up-to-date', '1.2.3', '1.3', etc.

        self.status = None           # '', '1.2.03', '1.3.00', etc.

        self.lang = None             # like 'Brasilian'

        self.langReadable = None     # like 'Brasilian Portuguese'

        self.note = None             # like 'should be cleaned up'

        self.prototypeDic = {}       # uniPrototype -> prototype

        self.translateMeText = 'translate me!'

        self.translateMeFlag = False # comments with "translate me!" found

        self.txtMAX_DOT_GRAPH_HEIGHT_flag = False # found in string in trLegendDocs()

        self.obsoleteMethods = None  # list of prototypes to be removed

        self.missingMethods = None   # list of prototypes to be implemented

        self.implementedMethods = None  # list of implemented required methods

        self.adaptMinClass = None    # The newest adapter class that can be used

    def __tokenGenerator(self):

        """Generator that reads the file and yields tokens as 4-tuples.

        The tokens have the form (tokenId, tokenString, lineNo). The

        last returned token has the form ('eof', None, None). When trying

        to access next token after that, the exception would be raised."""

        # Set the dictionary for recognizing tokenId for keywords, separators

        # and the similar categories. The key is the string to be recognized,

        # the value says its token identification.

        tokenDic = { 'class':     'class',

                     'const':     'const',

                     'public':    'public',

                     'protected': 'protected',

                     'private':   'private',

                     'static':    'static',

                     'virtual':   'virtual',

                     ':':         'colon',

                     ';':         'semic',

                     ',':         'comma',

                     '[':         'lsqbra',

                     ']':         'rsqbra',

                     '(':         'lpar',

                     ')':         'rpar',

                     '{':         'lcurly',

                     '}':         'rcurly',

                     '=':         'assign',

                     '*':         'star',

                     '&':         'amp',

                     '+':         'plus',

                     '-':         'minus',

                     '!':         'excl',

                     '?':         'qmark',

                     '<':         'lt',

                     '>':         'gt',

                     "'":         'quot',

                     '"':         'dquot',

                     '.':         'dot',

                     '%':         'perc',

                     '~':         'tilde',

                     '^':         'caret',

                   }

        # Regular expression for recognizing identifiers.

        rexId = re.compile(r'^[a-zA-Z]\w*$')

        # Open the file for reading and extracting tokens until the eof.

        # Initialize the finite automaton.

        f = xopen(self.fname)

        lineNo = 0

        line = ''         # init -- see the pos initialization below

        linelen = 0       # init

        pos = 100         # init -- pos after the end of line

        status = 0

        tokenId = None    # init

        tokenStr = ''     # init -- the characters will be appended.

        tokenLineNo = 0

        while status != 777:

            # Get the next character. Read next line first, if necessary.

            if pos < linelen:

                c = line[pos]

            else:

                lineNo += 1

                line = f.readline()

                linelen = len(line)

                pos = 0

                if line == '':         # eof

                    status = 777

                else:

                    c = line[pos]

            # Consume the character based on the status

            if status == 0:     # basic status

                # This is the initial status. If tokenId is set, yield the

                # token here and only here (except when eof is found).

                # Initialize the token variables after the yield.

                if tokenId:

                    # If it is an unknown item, it can still be recognized

                    # here. Keywords and separators are the example.

                    if tokenId == 'unknown':

                        if tokenStr in tokenDic:

                            tokenId = tokenDic[tokenStr]

                        elif tokenStr.isdigit():

                            tokenId = 'num'

                        elif rexId.match(tokenStr):

                            tokenId = 'id'

                        else:

                            msg = '\aWarning: unknown token "' + tokenStr + '"'

                            msg += '\tfound on line %d' % tokenLineNo

                            msg += ' in "' + self.fname + '".\n'

                            sys.stderr.write(msg)

                    yield (tokenId, tokenStr, tokenLineNo)

                    # If it is a comment that contains the self.translateMeText

                    # string, set the flag -- the situation will be reported.

                    if tokenId == 'comment' and tokenStr.find(self.translateMeText) >= 0:

                        self.translateMeFlag = True

                    tokenId = None

                    tokenStr = ''

                    tokenLineNo = 0

                # Now process the character. When we just skip it (spaces),

                # stay in this status. All characters that will be part of

                # some token cause moving to the specific status. And only

                # when moving to the status == 0 (or the final state 777),

                # the token is yielded. With respect to that the automaton

                # behaves as Moore's one (output bound to status). When

                # collecting tokens, the automaton is the Mealy's one

                # (actions bound to transitions).

                if c.isspace():

                    pass                 # just skip whitespace characters

                elif c == '/':           # Possibly comment starts here, but

                    tokenId = 'unknown'  # it could be only a slash in code.

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 1

                elif c == '#':

                    tokenId = 'preproc'  # preprocessor directive

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 5

                elif c == '"':           # string starts here

                    tokenId = 'string'

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 6

                elif c == "'":           # char literal starts here

                    tokenId = 'charlit'

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 8

                elif c in tokenDic:  # known one-char token

                    tokenId = tokenDic[c]

                    tokenStr = c

                    tokenLineNo = lineNo

                    # stay in this state to yield token immediately

                else:

                    tokenId = 'unknown'  # totally unknown

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 333

                pos += 1                 # move position in any case

            elif status == 1:            # possibly a comment

                if c == '/':             # ... definitely the C++ comment

                    tokenId = 'comment'

                    tokenStr += c

                    pos += 1

                    status = 2

                elif c == '*':           # ... definitely the C comment

                    tokenId = 'comment'

                    tokenStr += c

                    pos += 1

                    status = 3

                else:

                    status = 0           # unrecognized, don't move pos

            elif status == 2:            # inside the C++ comment

                if c == '\n':            # the end of C++ comment

                    status = 0           # yield the token

                else:

                    tokenStr += c        # collect the C++ comment

                pos += 1

            elif status == 3:            # inside the C comment

                if c == '*':             # possibly the end of the C comment

                    tokenStr += c

                    status = 4

                else:

                    tokenStr += c        # collect the C comment

                pos += 1

            elif status == 4:            # possibly the end of the C comment

                if c == '/':             # definitely the end of the C comment

                    tokenStr += c

                    status = 0           # yield the token

                elif c == '*':           # more stars inside the comment

                    tokenStr += c

                else:

                    tokenStr += c        # this cannot be the end of comment

                    status = 3

                pos += 1

            elif status == 5:            # inside the preprocessor directive

                if c == '\n':            # the end of the preproc. command

                    status = 0           # yield the token

                else:

                    tokenStr += c        # collect the preproc

                pos += 1

            elif status == 6:            # inside the string

                if c == '\\':            # escaped char inside the string

                    tokenStr += c

                    status = 7

                elif c == '"':           # end of the string

                    tokenStr += c

                    status = 0

                else:

                    tokenStr += c        # collect the chars of the string

                pos += 1

            elif status == 7:            # escaped char inside the string

                tokenStr += c            # collect the char of the string

                status = 6

                pos += 1

            elif status == 8:            # inside the char literal

                tokenStr += c            # collect the char of the literal

                status = 9

                pos += 1

            elif status == 9:            # end of char literal expected

                if c == "'":             # ... and found

                    tokenStr += c

                    status = 0

                    pos += 1

                else:

                    tokenId = 'error'    # end of literal was expected

                    tokenStr += c

                    status = 0

            elif status == 333:          # start of the unknown token

                if c.isspace():

                    pos += 1

                    status = 0           # tokenId may be determined later

                elif c in tokenDic:  # separator, don't move pos

                    status = 0

                else:

                    tokenStr += c        # collect

                    pos += 1

        # We should have finished in the final status. If some token

        # have been extracted, yield it first.

        assert(status == 777)

        if tokenId:

            yield (tokenId, tokenStr, tokenLineNo)

            tokenId = None

            tokenStr = ''

            tokenLineNo = 0

        # The file content is processed. Close the file. Then always yield

        # the eof token.

        f.close()

        yield ('eof', None, None)

    def __collectClassInfo(self, tokenIterator):

        """Collect the information about the class and base class.

        The tokens including the opening left curly brace of the class are

        consumed."""

        status = 0  # initial state

        while status != 777:   # final state

            # Always assume that the previous tokens were processed. Get

            # the next one.

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

            # Process the token and never return back.

            if status == 0:    # waiting for the 'class' keyword.

                if tokenId == 'class':

                    status = 1

            elif status == 1:  # expecting the class identification

                if tokenId == 'id':

                    self.classId = tokenStr

                    status = 2

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 2:  # expecting the curly brace or base class info

                if tokenId == 'lcurly':

                    status = 777        # correctly finished

                elif tokenId == 'colon':

                    status = 3

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 3:  # expecting the 'public' in front of base class id

                if tokenId == 'public':

                    status = 4

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 4:  # expecting the base class id

                if tokenId == 'id':

                    self.baseClassId = tokenStr

                    status = 5

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 5:  # expecting the curly brace and quitting

                if tokenId == 'lcurly':

                    status = 777        # correctly finished

                elif tokenId == 'comment':

                    pass

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

        # Extract the status of the TranslatorXxxx class. The readable form

        # will be used in reports the status form is a string that can be

        # compared lexically (unified length, padding with zeros, etc.).

        if self.baseClassId:

            lst = self.baseClassId.split('_')

            if lst[0] == 'Translator':

                self.readableStatus = 'up-to-date'

                self.status = ''

            elif lst[0] == 'TranslatorAdapter':

                self.status = lst[1] + '.' + lst[2]

                self.readableStatus = self.status

                if len(lst) > 3:        # add the last part of the number

                    self.status += '.' + ('%02d' % int(lst[3]))

                    self.readableStatus += '.' + lst[3]

                else:

                    self.status += '.00'

            elif lst[0] == 'TranslatorEnglish':

                # Obsolete or Based on English.

                if self.classId[-2:] == 'En':

                    self.readableStatus = 'English based'

                    self.status = 'En'

                else:

                    self.readableStatus = 'obsolete'

                    self.status = '0.0.00'

            # Check whether status was set, or set 'strange'.

            if self.status == None:

                self.status = 'strange'

            if not self.readableStatus:

                self.readableStatus = 'strange'

            # Extract the name of the language and the readable form.

            self.lang = self.classId[10:]  # without 'Translator'

            if self.lang == 'Brazilian':

                self.langReadable = 'Brazilian Portuguese'

            elif self.lang == 'Chinesetraditional':

                self.langReadable = 'Chinese Traditional'

            else:

                self.langReadable = self.lang

    def __unexpectedToken(self, status, tokenId, tokenLineNo):

        """Reports unexpected token and quits with exit code 1."""

        import inspect

        calledFrom = inspect.stack()[1][3]

        msg = "\a\nUnexpected token '%s' on the line %d in '%s'.\n"

        msg = msg % (tokenId, tokenLineNo, self.fname)

        msg += 'status = %d in %s()\n' % (status, calledFrom)

        sys.stderr.write(msg)

        sys.exit(1)

    def collectPureVirtualPrototypes(self):

        """Returns dictionary 'unified prototype' -> 'full prototype'.

        The method is expected to be called only for the translator.h. It

        extracts only the pure virtual method and build the dictionary where

        key is the unified prototype without argument identifiers."""

        # Prepare empty dictionary that will be returned.

        resultDic = {}

        # Start the token generator which parses the class source file.

        tokenIterator = self.__tokenGenerator()

        # Collect the class and the base class identifiers.

        self.__collectClassInfo(tokenIterator)

        assert(self.classId == 'Translator')

        # Let's collect readable form of the public virtual pure method

        # prototypes in the readable form -- as defined in translator.h.

        # Let's collect also unified form of the same prototype that omits

        # everything that can be omitted, namely 'virtual' and argument

        # identifiers.

        prototype = ''    # readable prototype (with everything)

        uniPrototype = '' # unified prototype (without arg. identifiers)

        # Collect the pure virtual method prototypes. Stop on the closing

        # curly brace followed by the semicolon (end of class).

        status = 0

        curlyCnt = 0      # counter for the level of curly braces

        # Loop until the final state 777 is reached. The errors are processed

        # immediately. In this implementation, it always quits the application.

        while status != 777:

            # Get the next token.

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

            if status == 0:      # waiting for 'public:'

                if tokenId == 'public':

                    status = 1

            elif status == 1:    # colon after the 'public'

                if tokenId == 'colon':

                    status = 2

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 2:    # waiting for 'virtual'

                if tokenId == 'virtual':

                    prototype = tokenStr  # but not to unified prototype

                    status = 3

                elif tokenId == 'comment':

                    pass

                elif tokenId == 'rcurly':

                    status = 11         # expected end of class

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 3:    # return type of the method expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    uniPrototype = tokenStr  # start collecting the unified prototype

                    status = 4

                elif tokenId == 'tilde':

                    status = 4

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 4:    # method identifier expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    uniPrototype += ' ' + tokenStr

                    status = 5

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 5:    # left bracket of the argument list expected

                if tokenId == 'lpar':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 6

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 6:    # collecting arguments of the method

                if tokenId == 'rpar':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 7

                elif tokenId == 'const':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 12

                elif tokenId == 'id':           # type identifier

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 13

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 7:    # assignment expected or left curly brace

                if tokenId == 'assign':

                    status = 8

                elif tokenId == 'lcurly':

                    curlyCnt = 1      # method body entered

                    status = 10

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 8:    # zero expected

                if tokenId == 'num' and tokenStr == '0':

                    status = 9

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 9:    # after semicolon, produce the dic item

                if tokenId == 'semic':

                    assert(uniPrototype not in resultDic)

                    resultDic[uniPrototype] = prototype

                    status = 2

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 10:   # consuming the body of the method

                if tokenId == 'rcurly':

                    curlyCnt -= 1

                    if curlyCnt == 0:

                        status = 2     # body consumed

                elif tokenId == 'lcurly':

                    curlyCnt += 1

            elif status == 11:   # probably the end of class

                if tokenId == 'semic':

                    status = 777

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 12:   # type id for argument expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    uniPrototype += ' ' + tokenStr

                    status = 13

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 13:   # namespace qualification or * or & expected

                if tokenId == 'colon':        # was namespace id

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 14

                elif tokenId == 'star' or tokenId == 'amp':  # pointer or reference

                    prototype += ' ' + tokenStr

                    uniPrototype += ' ' + tokenStr

                    status = 16

                elif tokenId == 'id':         # argument identifier

                    prototype += ' ' + tokenStr

                    # don't put this into unified prototype

                    status = 17

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 14:   # second colon for namespace:: expected

                if tokenId == 'colon':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 15

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 15:   # type after namespace:: expected

                if tokenId == 'id':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 13

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 16:   # argument identifier expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    # don't put this into unified prototype

                    status = 17

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 17:   # comma or ')' after argument identifier expected

                if tokenId == 'comma':

                    prototype += ', '

                    uniPrototype += ', '

                    status = 6

                elif tokenId == 'rpar':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 7

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

        # Eat the rest of the source to cause closing the file.

        while tokenId != 'eof':

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

        # Return the resulting dictionary with 'uniPrototype -> prototype'.

        return resultDic

    def __collectPublicMethodPrototypes(self, tokenIterator):

        """Collects prototypes of public methods and fills self.prototypeDic.

        The dictionary is filled by items: uniPrototype -> prototype.

        The method is expected to be called only for TranslatorXxxx classes,

        i.e. for the classes that implement translation to some language.

        It assumes that the opening curly brace of the class was already

        consumed. The source is consumed until the end of the class.

        The caller should consume the source until the eof to cause closing

        the source file."""

        assert(self.classId != 'Translator')

        assert(self.baseClassId != None)

        # The following finite automaton slightly differs from the one

        # inside self.collectPureVirtualPrototypes(). It produces the

        # dictionary item just after consuming the body of the method

        # (transition from state 10 to state 2). It also does not allow

        # definitions of public pure virtual methods, except for

        # TranslatorAdapterBase (states 8 and 9). Argument identifier inside

        # method argument lists can be omitted or commented.

        #

        # Let's collect readable form of all public method prototypes in

        # the readable form -- as defined in the source file.

        # Let's collect also unified form of the same prototype that omits

        # everything that can be omitted, namely 'virtual' and argument

        # identifiers.

        prototype = ''    # readable prototype (with everything)

        uniPrototype = '' # unified prototype (without arg. identifiers)

        warning = ''      # warning message -- if something special detected

        methodId = None   # processed method id

        # Collect the method prototypes. Stop on the closing

        # curly brace followed by the semicolon (end of class).

        status = 0

        curlyCnt = 0      # counter for the level of curly braces

        # Loop until the final state 777 is reached. The errors are processed

        # immediately. In this implementation, it always quits the application.

        while status != 777:

            # Get the next token.

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

            if status == 0:      # waiting for 'public:'

                if tokenId == 'public':

                    status = 1

                elif tokenId == 'eof':  # non-public things until the eof

                    status = 777

            elif status == 1:    # colon after the 'public'

                if tokenId == 'colon':

                    status = 2

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 2:    # waiting for 'virtual' (can be omitted)

                if tokenId == 'virtual':

                    prototype = tokenStr  # but not to unified prototype

                    status = 3

                elif tokenId == 'id':     # 'virtual' was omitted

                    prototype = tokenStr

                    uniPrototype = tokenStr  # start collecting the unified prototype

                    status = 4

                elif tokenId == 'comment':

                    pass

                elif tokenId == 'protected' or tokenId == 'private':

                    status = 0

                elif tokenId == 'rcurly':

                    status = 11         # expected end of class

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 3:    # return type of the method expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    uniPrototype = tokenStr  # start collecting the unified prototype

                    status = 4

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 4:    # method identifier expected

                if tokenId == 'id':

                    prototype += ' ' + tokenStr

                    uniPrototype += ' ' + tokenStr

                    methodId = tokenStr    # for reporting

                    status = 5

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 5:    # left bracket of the argument list expected

                if tokenId == 'lpar':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 6

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 6:    # collecting arguments of the method

                if tokenId == 'rpar':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 7

                elif tokenId == 'const':

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 12

                elif tokenId == 'id':           # type identifier

                    prototype += tokenStr

                    uniPrototype += tokenStr

                    status = 13

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 7:    # left curly brace expected

                if tokenId == 'lcurly':

                    curlyCnt = 1      # method body entered

                    status = 10

                elif tokenId == 'comment':

                    pass

                elif tokenId == 'assign': # allowed only for TranslatorAdapterBase

                    assert(self.classId == 'TranslatorAdapterBase')

                    status = 8

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 8:    # zero expected (TranslatorAdapterBase)

                assert(self.classId == 'TranslatorAdapterBase')

                if tokenId == 'num' and tokenStr == '0':

                    status = 9

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 9:    # after semicolon (TranslatorAdapterBase)

                assert(self.classId == 'TranslatorAdapterBase')

                if tokenId == 'semic':

                    status = 2

                else:

                    self.__unexpectedToken(status, tokenId, tokenLineNo)

            elif status == 10:   # consuming the body of the method, then dic item

                if tokenId == 'rcurly':

                    curlyCnt -= 1

                    if curlyCnt == 0:

                        # Check for possible copy/paste error when name

                        # of the method was not corrected (i.e. the same

                        # name already exists).

                        if uniPrototype in self.prototypeDic:

                            msg = "'%s' prototype found again (duplicity)\n"

                            msg += "in '%s'.\n" % self.fname

                            msg = msg % uniPrototype

                            sys.stderr.write(msg)

                            assert False

                        assert(uniPrototype not in self.prototypeDic)

                        # Insert new dictionary item.

                        self.prototypeDic[uniPrototype] = prototype

                        status = 2      # body consumed