Merge branch 'master' into devel

{

  m_lab->setEnabled(state);

  if (m_le)  m_le->setEnabled(state);

  if (m_im)  m_le->setEnabled(state);

  if (m_im)  m_im->setEnabled(state);

  if (m_br)  m_br->setEnabled(state);

  if (m_com) m_com->setEnabled(state);

  updateDefault();

# - check for python ----------------------------------------------------------

python_version=0

printf "  Checking for python... "

if test "$f_python" = NO; then

  python_names="python2 python"

  python_names="python3 python2 python"

  python_dirs="$bin_dirs /usr/bin /usr/local/bin /bin /sbin"

  python_prog=NO

  python_found=NO

    for j in $python_dirs; do

      if test -x "$j/$i"; then

        python_found=YES

        if test `$j/$i -c "import sys; print sys.version_info[0]"` = 2; then

          python_prog="$j/$i"

        if test `$j/$i -c "import sys; print(sys.version_info[0])"` = 3; then

          python_prog="$j/$i";

          python_version=`$j/$i -c "import platform; print(platform.python_version())"`;

          break 2

        elif test `$j/$i -c "import sys; print(sys.version_info[0])"` = 2; then

          if test `$j/$i -c "import sys; print(sys.version_info[1])"` -ge 6; then

            python_prog="$j/$i";

            python_version=`$j/$i -c "import platform; print(platform.python_version())"`;

            break 2

          fi

        fi

      fi

    done

if test "$f_python" = NO; then

  if test "$python_found" = YES; then

    echo "version should be python 2."

    echo "version should be python 2.6 or higher."

  else

    echo "not found!";

  fi

  echo

  exit 2

fi

echo "using $f_python";

echo "using $f_python (version $python_version)";

# - check for perl ------------------------------------------------------------

<li>GNU bison version 2.5 (Linux) and 2.3 (MacOSX)

<li>GNU make version 3.81

<li>Perl version 5.12

<li>Python verion 2.7 and 3.4

<li>TeX Live 2009 (or later)

</ul>

               of translators introduced.

  """

from __future__ import generators

import codecs

import os

import platform

import re

import sys

import textwrap

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

    '''Unified open of text files with UTF-8 default encoding.

    The 'utf-8-sig' skips the BOM automatically.

    '''

    # Use UTF-8 without BOM when writing to a text file.

    if encoding == 'utf-8-sig' and mode == 'w':

        encoding = 'utf-8'

    major, minor, patch = (int(e) for e in platform.python_version_tuple())

    if major == 2:

        if mode == 'w':

            mode = 'wU'

        import codecs

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

    else:

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

def fill(s):

    return '\n'.join(lines)

# The following function dedent() is the verbatim copy from the textwrap.py

# module. The textwrap.py was introduced in Python 2.3. To make this script

# working also in older Python versions, I have decided to copy it.

# Notice that the textwrap.py is copyrighted:

#

# Copyright (C) 1999-2001 Gregory P. Ward.

# Copyright (C) 2002, 2003 Python Software Foundation.

# Written by Greg Ward <gward@python.net>

#

# The explicit permission to use the code here was sent by Guido van Rossum

# (4th June, 2004).

#

def dedent(text):

    """dedent(text : string) -> string

    Remove any whitespace than can be uniformly removed from the left

    of every line in `text`.

    This can be used e.g. to make triple-quoted strings line up with

    the left edge of screen/whatever, while still presenting it in the

    source code in indented form.

    For example:

        def test():

            # end first line with \ to avoid the empty line!

            s = '''\

            hello

              world

            '''

            print repr(s)          # prints '    hello\n      world\n    '

            print repr(dedent(s))  # prints 'hello\n  world\n'

    """

    lines = text.expandtabs().split('\n')

    margin = None

    for line in lines:

        content = line.lstrip()

        if not content:

            continue

        indent = len(line) - len(content)

        if margin is None:

            margin = indent

        else:

            margin = min(margin, indent)

    if margin is not None and margin > 0:

        for i in range(len(lines)):

            lines[i] = lines[i][margin:]

    return '\n'.join(lines)

class Transl:

    """One instance is build for each translator.

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

        # Initialize the finite automaton.

        f = open(self.fname)

        f = xopen(self.fname)

        lineNo = 0

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

        linelen = 0       # init

            else:

                lineNo += 1

                line = f.readline()

                if line.startswith('\xef\xbb\xbf'):

                    line = line[3:]    # skip the BOM

                linelen = len(line)

                pos = 0

                if line == '':         # eof

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

                    # here. Keywords and separators are the example.

                    if tokenId == 'unknown':

                        if tokenDic.has_key(tokenStr):

                        if tokenStr in tokenDic:

                            tokenId = tokenDic[tokenStr]

                        elif tokenStr.isdigit():

                            tokenId = 'num'

                    tokenStr = c

                    tokenLineNo = lineNo

                    status = 8

                elif tokenDic.has_key(c):  # known one-char token

                elif c in tokenDic:  # known one-char token

                    tokenId = tokenDic[c]

                    tokenStr = c

                    tokenLineNo = lineNo

                if c.isspace():

                    pos += 1

                    status = 0           # tokenId may be determined later

                elif tokenDic.has_key(c):  # separator, don't move pos

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

                    status = 0

                else:

                    tokenStr += c        # collect

            # Always assume that the previous tokens were processed. Get

            # the next one.

            tokenId, tokenStr, tokenLineNo = tokenIterator.next()

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

            # Process the token and never return back.

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

        while status != 777:

            # Get the next token.

            tokenId, tokenStr, tokenLineNo = tokenIterator.next()

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

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

                if tokenId == 'public':

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

                if tokenId == 'semic':

                    assert(not resultDic.has_key(uniPrototype))

                    assert(uniPrototype not in resultDic)

                    resultDic[uniPrototype] = prototype

                    status = 2

                else:

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

        while tokenId != 'eof':

            tokenId, tokenStr, tokenLineNo = tokenIterator.next()

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

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

        return resultDic

        while status != 777:

            # Get the next token.

            tokenId, tokenStr, tokenLineNo = tokenIterator.next()

            tokenId, tokenStr, tokenLineNo = next(tokenIterator)

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

                if tokenId == 'public':

                            sys.stderr.write(msg)

                            assert False

                        assert(not self.prototypeDic.has_key(uniPrototype))

                        assert(uniPrototype not in self.prototypeDic)

                        # Insert new dictionary item.

                        self.prototypeDic[uniPrototype] = prototype

                        status = 2      # body consumed

                # For the required methods, update the dictionary of methods

                # implemented by the adapter.

                for protoUni in self.prototypeDic:

                    if reqDic.has_key(protoUni):

                    if protoUni in reqDic:

                        # This required method will be marked as implemented

                        # by this adapter class. This implementation assumes

                        # that newer adapters do not reimplement any required

                        # methods already implemented by older adapters.

                        assert(not adaptDic.has_key(protoUni))

                        assert(protoUni not in adaptDic)

                        adaptDic[protoUni] = (version, self.classId)

                # Clear the dictionary object and the information related

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

        while True:

            try:

                t = tokenIterator.next()

                t = next(tokenIterator)

            except StopIteration:

                break

        # Build the list of obsolete methods.

        self.obsoleteMethods = []

        for p in myDic:

            if not reqDic.has_key(p):

            if p not in reqDic:

                self.obsoleteMethods.append(p)

        # Build the list of missing methods and the list of implemented

        self.missingMethods = []

        self.implementedMethods = []

        for p in reqDic:

            if myDic.has_key(p):

            if p in myDic:

                self.implementedMethods.append(p)

            else:

                self.missingMethods.append(p)

                adaptMinVersion = '9.9.99'

                adaptMinClass = 'TranslatorAdapter_9_9_99'

                for uniProto in self.missingMethods:

                    if adaptDic.has_key(uniProto):

                    if uniProto in adaptDic:

                        version, cls = adaptDic[uniProto]

                        if version < adaptMinVersion:

                            adaptMinVersion = version

                    sys.exit(1)

        else:

            lst = os.listdir(self.src_path)

            lst = filter(lambda x: x[:11] == 'translator_'

            lst = [x for x in lst if x[:11] == 'translator_'

                                   and x[-2:] == '.h'

                                   and x != 'translator_adapter.h', lst)

                                   and x != 'translator_adapter.h']

        # Build the object for the translator_xx.h files, and process the

        # content of the file. Then insert the object to the dictionary

        # Build the auxiliary list with strings compound of the status,

        # readable form of the language, and classId.

        statLst = []

        for obj in self.__translDic.values():

        for obj in list(self.__translDic.values()):

            assert(obj.classId != 'Translator')

            s = obj.status + '|' + obj.langReadable + '|' + obj.classId

            statLst.append(s)

        # Build the list of tuples that contain (langReadable, obj).

        # Sort it by readable name.

        self.langLst = []

        for obj in self.__translDic.values():

        for obj in list(self.__translDic.values()):

            self.langLst.append((obj.langReadable, obj))

        self.langLst.sort(lambda a, b: cmp(a[0], b[0]))

        self.langLst.sort(key=lambda x: x[0])

        # Create the list with readable language names. If the language has

        # also the English-based version, modify the item by appending

            # of the English-based object. If the object exists, modify the

            # name for the readable list of supported languages.

            classIdEn = obj.classId + 'En'

            if self.__translDic.has_key(classIdEn):

            if classIdEn in self.__translDic:

                name += ' (+En)'

            # Append the result name of the language, possibly with note.

        for name, obj in self.langLst:

            if obj.status == 'En':

                classId = obj.classId[:-2]

                if self.__translDic.has_key(classId):

                if classId in self.__translDic:

                    self.numLang -= 1    # the couple will be counted as one

        # Extract the version of Doxygen.

        f = open(os.path.join(self.doxy_path, 'VERSION'))

        f = xopen(os.path.join(self.doxy_path, 'VERSION'))

        self.doxVersion = f.readline().strip()

        f.close()

        # Update the last modification time.

        for tr in self.__translDic.values():

        for tr in list(self.__translDic.values()):

            tim = tr.getmtime()

            if tim > self.lastModificationTime:

                self.lastModificationTime = tim

        probably used should be checked first and the resulting reduced

        dictionary should be used for checking the next files (speed up).

        """

        lst_in = dic.keys()   # identifiers to be searched for

        lst_in = list(dic.keys())   # identifiers to be searched for

        # Read content of the file as one string.

        assert os.path.isfile(fname)

        f = open(fname)

        f = xopen(fname)

        cont = f.read()

        f.close()

        # Build the dictionary of the required method prototypes with

        # method identifiers used as keys.

        trdic = {}

        for prototype in self.requiredMethodsDic.keys():

        for prototype in list(self.requiredMethodsDic.keys()):

            ri = prototype.split('(')[0]

            identifier = ri.split()[1].strip()

            trdic[identifier] = prototype

        output = os.path.join(self.doc_path, self.translatorReportFileName)

        # Open the textual report file for the output.

        f = open(output, 'w')

        f = xopen(output, 'w')

        # Output the information about the version.

        f.write('(' + self.doxVersion + ')\n\n')

        # The e-mail addresses of the maintainers will be collected to

        # the auxiliary file in the order of translator classes listed

        # in the translator report.

        fmail = open('mailto.txt', 'w')

        fmail = xopen('mailto.txt', 'w')

        # Write the list of "up-to-date" translator classes.

        if self.upToDateIdLst:

            # adapters.

            if not self.script_argLst:

                to_remove = {}

                for version, adaptClassId in self.adaptMethodsDic.values():

                for version, adaptClassId in list(self.adaptMethodsDic.values()):

                    if version < adaptMinVersion:

                        to_remove[adaptClassId] = True

                if to_remove:

                    lst = to_remove.keys()

                    lst = list(to_remove.keys())

                    lst.sort()

                    plural = len(lst) > 1

                    note = 'Note: The adapter class'

                f.write('\n' + '=' * 70 + '\n')

                f.write(fill(s) + '\n\n')

                keys = dic.keys()

                keys = list(dic.keys())

                keys.sort()

                for key in keys:

                    f.write('  ' + dic[key] + '\n')

        f.write('\n' + '=' * 70)

        f.write('\nDetails for translators (classes sorted alphabetically):\n')

        cls = self.__translDic.keys()

        cls = list(self.__translDic.keys())

        cls.sort()

        for c in cls:

            self.lastModificationTime = tim

        # Process the content of the maintainers file.

        f = codecs.open(fname, 'r', 'utf-8')

        f = xopen(fname)

        inside = False  # inside the record for the language

        lineReady = True

        classId = None

            lineReady = line != ''         # when eof, then line == ''

            line = line.strip()            # eof should also behave as separator

            if line != u'' and line[0] == u'%':    # skip the comment line

            if line != '' and line[0] == '%':    # skip the comment line

                continue

            if not inside:                 # if outside of the record

                if line != u'':            # should be language identifier

                if line != '':            # should be language identifier

                    classId = line

                    maintainersLst = []

                    inside = True

                # Otherwise skip empty line that do not act as separator.

            else:                          # if inside the record

                if line == u'':            # separator found

                if line == '':            # separator found

                    inside = False

                else:

                    # If it is the first maintainer, create the empty list.

                    if not self.__maintainersDic.has_key(classId):

                    if classId not in self.__maintainersDic:

                        self.__maintainersDic[classId] = []

                    # Split the information about the maintainer and append

                    # the tuple. The address may be prefixed '[unreachable]'

                    # or whatever '[xxx]'. This will be processed later.

                    lst = line.split(u':', 1)

                    lst = line.split(':', 1)

                    assert(len(lst) == 2)

                    t = (lst[0].strip(), lst[1].strip())

                    self.__maintainersDic[classId].append(t)

        #

        # Read the template of the documentation, and remove the first

        # attention lines.

        f = codecs.open(fTplName, 'r', 'utf-8')

        f = xopen(fTplName)

        doctpl = f.read()

        f.close()

        # document template.

        tplDic = {}

        s = u'Do not edit this file. It was generated by the %s script.\n * Instead edit %s and %s' % (self.script_name, self.languageTplFileName, self.maintainersFileName)

        s = u'Do not edit this file. It was generated by the %s script. * Instead edit %s and %s' % (self.script_name, self.languageTplFileName, self.maintainersFileName)

        tplDic['editnote'] = s

        tplDic['doxVersion'] = self.doxVersion

            </table>

            \\endhtmlonly

            '''

        htmlTableTpl = dedent(htmlTableTpl)

        htmlTableTpl = textwrap.dedent(htmlTableTpl)

        htmlTrTpl = u'\n  <tr bgcolor="#ffffff">%s\n  </tr>'

        htmlTdTpl = u'\n    <td>%s</td>'

        htmlTdStatusColorTpl = u'\n    <td bgcolor="%s">%s</td>'

            if obj.readableStatus.startswith('1.4'):

                bkcolor = self.getBgcolorByReadableStatus('1.4')

            else:

                bkcolor = '#ffffff'

                bkcolor = u'#ffffff'

            lst = [ htmlTdStatusColorTpl % (bkcolor, obj.langReadable) ]