#!/usr/bin/python -u

#

# This is the API builder, it parses the C sources and build the

# API formal description in XML.

#

# See Copyright for the status of this software.

#

# daniel@veillard.com

#

import os, sys

import string

import glob

debug=0

#debugsym='ignorableWhitespaceSAXFunc'

debugsym=None

#

# C parser analysis code

#

ignored_files = {

  "trio": "too many non standard macros",

  "trio.c": "too many non standard macros",

  "trionan.c": "too many non standard macros",

  "triostr.c": "too many non standard macros",

  "acconfig.h": "generated portability layer",

  "config.h": "generated portability layer",

  "libxml.h": "internal only",

  "testOOM.c": "out of memory tester",

  "testOOMlib.h": "out of memory tester",

  "testOOMlib.c": "out of memory tester",

  "rngparser.c": "not yet integrated",

  "rngparser.h": "not yet integrated",

  "elfgcchack.h": "not a normal header",

  "testHTML.c": "test tool",

  "testReader.c": "test tool",

  "testSchemas.c": "test tool",

  "testXPath.c": "test tool",

  "testAutomata.c": "test tool",

  "testModule.c": "test tool",

  "testRegexp.c": "test tool",

  "testThreads.c": "test tool",

  "testC14N.c": "test tool",

  "testRelax.c": "test tool",

  "testThreadsWin32.c": "test tool",

  "testSAX.c": "test tool",

  "testURI.c": "test tool",

  "testapi.c": "generated regression tests",

  "runtest.c": "regression tests program",

  "runsuite.c": "regression tests program",

  "tst.c": "not part of the library",

  "test.c": "not part of the library",

  "testdso.c": "test for dynamid shared libraries",

  "testrecurse.c": "test for entities recursions",

  "xzlib.h": "Internal API only 2.8.0",

  "buf.h": "Internal API only 2.9.0",

  "enc.h": "Internal API only 2.9.0",

  "/save.h": "Internal API only 2.9.0",

  "timsort.h": "Internal header only for xpath.c 2.9.0",

}

ignored_words = {

  "WINAPI": (0, "Windows keyword"),

  "LIBXML_DLL_IMPORT": (0, "Special macro to flag external keywords"),

  "XMLPUBVAR": (0, "Special macro for extern vars for win32"),

  "XSLTPUBVAR": (0, "Special macro for extern vars for win32"),

  "EXSLTPUBVAR": (0, "Special macro for extern vars for win32"),

  "XMLPUBFUN": (0, "Special macro for extern funcs for win32"),

  "XSLTPUBFUN": (0, "Special macro for extern funcs for win32"),

  "EXSLTPUBFUN": (0, "Special macro for extern funcs for win32"),

  "XMLCALL": (0, "Special macro for win32 calls"),

  "XSLTCALL": (0, "Special macro for win32 calls"),

  "XMLCDECL": (0, "Special macro for win32 calls"),

  "EXSLTCALL": (0, "Special macro for win32 calls"),

  "__declspec": (3, "Windows keyword"),

  "__stdcall": (0, "Windows keyword"),

  "ATTRIBUTE_UNUSED": (0, "macro keyword"),

  "LIBEXSLT_PUBLIC": (0, "macro keyword"),

  "X_IN_Y": (5, "macro function builder"),

  "ATTRIBUTE_ALLOC_SIZE": (3, "macro for gcc checking extension"),

  "ATTRIBUTE_PRINTF": (5, "macro for gcc printf args checking extension"),

  "LIBXML_ATTR_FORMAT": (5, "macro for gcc printf args checking extension"),

  "LIBXML_ATTR_ALLOC_SIZE": (3, "macro for gcc checking extension"),

  "__XML_EXTERNC": (0, "Special macro added for os400"),

}

def escape(raw):

    raw = raw.replace('&', '&')

    raw = raw.replace('<', '<')

    raw = raw.replace('>', '>')

    raw = raw.replace("'", ''')

    raw = raw.replace('"', '"')

    return raw

def uniq(items):

    d = {}

    for item in items:

        d[item]=1

    return list(d.keys())

class identifier:

    def __init__(self, name, header=None, module=None, type=None, lineno = 0,

                 info=None, extra=None, conditionals = None):

        self.name = name

        self.header = header

        self.module = module

        self.type = type

        self.info = info

        self.extra = extra

        self.lineno = lineno

        self.static = 0

        if conditionals == None or len(conditionals) == 0:

            self.conditionals = None

        else:

            self.conditionals = conditionals[:]

        if self.name == debugsym:

            print("=> define %s : %s" % (debugsym, (module, type, info,

                                         extra, conditionals)))

    def __repr__(self):

        r = "%s %s:" % (self.type, self.name)

        if self.static:

            r = r + " static"

        if self.module != None:

            r = r + " from %s" % (self.module)

        if self.info != None:

            r = r + " " +  repr(self.info)

        if self.extra != None:

            r = r + " " + repr(self.extra)

        if self.conditionals != None:

            r = r + " " + repr(self.conditionals)

        return r

    def set_header(self, header):

        self.header = header

    def set_module(self, module):

        self.module = module

    def set_type(self, type):

        self.type = type

    def set_info(self, info):

        self.info = info

    def set_extra(self, extra):

        self.extra = extra

    def set_lineno(self, lineno):

        self.lineno = lineno

    def set_static(self, static):

        self.static = static

    def set_conditionals(self, conditionals):

        if conditionals == None or len(conditionals) == 0:

            self.conditionals = None

        else:

            self.conditionals = conditionals[:]

    def get_name(self):

        return self.name

    def get_header(self):

        return self.module

    def get_module(self):

        return self.module

    def get_type(self):

        return self.type

    def get_info(self):

        return self.info

    def get_lineno(self):

        return self.lineno

    def get_extra(self):

        return self.extra

    def get_static(self):

        return self.static

    def get_conditionals(self):

        return self.conditionals

    def update(self, header, module, type = None, info = None, extra=None,

               conditionals=None):

        if self.name == debugsym:

            print("=> update %s : %s" % (debugsym, (module, type, info,

                                         extra, conditionals)))

        if header != None and self.header == None:

            self.set_header(module)

        if module != None and (self.module == None or self.header == self.module):

            self.set_module(module)

        if type != None and self.type == None:

            self.set_type(type)

        if info != None:

            self.set_info(info)

        if extra != None:

            self.set_extra(extra)

        if conditionals != None:

            self.set_conditionals(conditionals)

class index:

    def __init__(self, name = "noname"):

        self.name = name

        self.identifiers = {}

        self.functions = {}

        self.variables = {}

        self.includes = {}

        self.structs = {}

        self.enums = {}

        self.typedefs = {}

        self.macros = {}

        self.references = {}

        self.info = {}

    def add_ref(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):

        if name[0:2] == '__':

            return None

        d = None

        try:

           d = self.identifiers[name]

           d.update(header, module, type, lineno, info, extra, conditionals)

        except:

           d = identifier(name, header, module, type, lineno, info, extra, conditionals)

           self.identifiers[name] = d

        if d != None and static == 1:

            d.set_static(1)

        if d != None and name != None and type != None:

            self.references[name] = d

        if name == debugsym:

            print("New ref: %s" % (d))

        return d

    def add(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):

        if name[0:2] == '__':

            return None

        d = None

        try:

           d = self.identifiers[name]

           d.update(header, module, type, lineno, info, extra, conditionals)

        except:

           d = identifier(name, header, module, type, lineno, info, extra, conditionals)

           self.identifiers[name] = d

        if d != None and static == 1:

            d.set_static(1)

        if d != None and name != None and type != None:

            if type == "function":

                self.functions[name] = d

            elif type == "functype":

                self.functions[name] = d

            elif type == "variable":

                self.variables[name] = d

            elif type == "include":

                self.includes[name] = d

            elif type == "struct":

                self.structs[name] = d

            elif type == "enum":

                self.enums[name] = d

            elif type == "typedef":

                self.typedefs[name] = d

            elif type == "macro":

                self.macros[name] = d

            else:

                print("Unable to register type ", type)

        if name == debugsym:

            print("New symbol: %s" % (d))

        return d

    def merge(self, idx):

        for id in list(idx.functions.keys()):

              #

              # macro might be used to override functions or variables

              # definitions

              #

             if id in self.macros:

                 del self.macros[id]

             if id in self.functions:

                 print("function %s from %s redeclared in %s" % (

                    id, self.functions[id].header, idx.functions[id].header))

             else:

                 self.functions[id] = idx.functions[id]

                 self.identifiers[id] = idx.functions[id]

        for id in list(idx.variables.keys()):

              #

              # macro might be used to override functions or variables

              # definitions

              #

             if id in self.macros:

                 del self.macros[id]

             if id in self.variables:

                 print("variable %s from %s redeclared in %s" % (

                    id, self.variables[id].header, idx.variables[id].header))

             else:

                 self.variables[id] = idx.variables[id]

                 self.identifiers[id] = idx.variables[id]

        for id in list(idx.structs.keys()):

             if id in self.structs:

                 print("struct %s from %s redeclared in %s" % (

                    id, self.structs[id].header, idx.structs[id].header))

             else:

                 self.structs[id] = idx.structs[id]

                 self.identifiers[id] = idx.structs[id]

        for id in list(idx.typedefs.keys()):

             if id in self.typedefs:

                 print("typedef %s from %s redeclared in %s" % (

                    id, self.typedefs[id].header, idx.typedefs[id].header))

             else:

                 self.typedefs[id] = idx.typedefs[id]

                 self.identifiers[id] = idx.typedefs[id]

        for id in list(idx.macros.keys()):

              #

              # macro might be used to override functions or variables

              # definitions

              #

             if id in self.variables:

                 continue

             if id in self.functions:

                 continue

             if id in self.enums:

                 continue

             if id in self.macros:

                 print("macro %s from %s redeclared in %s" % (

                    id, self.macros[id].header, idx.macros[id].header))

             else:

                 self.macros[id] = idx.macros[id]

                 self.identifiers[id] = idx.macros[id]

        for id in list(idx.enums.keys()):

             if id in self.enums:

                 print("enum %s from %s redeclared in %s" % (

                    id, self.enums[id].header, idx.enums[id].header))

             else:

                 self.enums[id] = idx.enums[id]

                 self.identifiers[id] = idx.enums[id]

    def merge_public(self, idx):

        for id in list(idx.functions.keys()):

             if id in self.functions:

                 # check that function condition agrees with header

                 if idx.functions[id].conditionals != \

                    self.functions[id].conditionals:

                     print("Header condition differs from Function for %s:" \

                        % id)

                     print("  H: %s" % self.functions[id].conditionals)

                     print("  C: %s" % idx.functions[id].conditionals)

                 up = idx.functions[id]

                 self.functions[id].update(None, up.module, up.type, up.info, up.extra)

         #     else:

         #         print "Function %s from %s is not declared in headers" % (

         #                id, idx.functions[id].module)

         # TODO: do the same for variables.

    def analyze_dict(self, type, dict):

        count = 0

        public = 0

        for name in list(dict.keys()):

            id = dict[name]

            count = count + 1

            if id.static == 0:

                public = public + 1

        if count != public:

            print("  %d %s , %d public" % (count, type, public))

        elif count != 0:

            print("  %d public %s" % (count, type))

    def analyze(self):

        self.analyze_dict("functions", self.functions)

        self.analyze_dict("variables", self.variables)

        self.analyze_dict("structs", self.structs)

        self.analyze_dict("typedefs", self.typedefs)

        self.analyze_dict("macros", self.macros)

class CLexer:

    """A lexer for the C language, tokenize the input by reading and

       analyzing it line by line"""

    def __init__(self, input):

        self.input = input

        self.tokens = []

        self.line = ""

        self.lineno = 0

    def getline(self):

        line = ''

        while line == '':

            line = self.input.readline()

            if not line:

                return None

            self.lineno = self.lineno + 1

            line = line.lstrip()

            line = line.rstrip()

            if line == '':

                continue

            while line[-1] == '\\':

                line = line[:-1]

                n = self.input.readline()

                self.lineno = self.lineno + 1

                n = n.lstrip()

                n = n.rstrip()

                if not n:

                    break

                else:

                    line = line + n

        return line

    def getlineno(self):

        return self.lineno

    def push(self, token):

        self.tokens.insert(0, token);

    def debug(self):

        print("Last token: ", self.last)

        print("Token queue: ", self.tokens)

        print("Line %d end: " % (self.lineno), self.line)

    def token(self):

        while self.tokens == []:

            if self.line == "":

                line = self.getline()

            else:

                line = self.line

                self.line = ""

            if line == None:

                return None

            if line[0] == '#':

                self.tokens = list(map((lambda x: ('preproc', x)),

                                  line.split()))

                break;

            l = len(line)

            if line[0] == '"' or line[0] == "'":

                end = line[0]

                line = line[1:]

                found = 0

                tok = ""

                while found == 0:

                    i = 0

                    l = len(line)

                    while i < l:

                        if line[i] == end:

                            self.line = line[i+1:]

                            line = line[:i]

                            l = i

                            found = 1

                            break

                        if line[i] == '\\':

                            i = i + 1

                        i = i + 1

                    tok = tok + line

                    if found == 0:

                        line = self.getline()

                        if line == None:

                            return None

                self.last = ('string', tok)

                return self.last

            if l >= 2 and line[0] == '/' and line[1] == '*':

                line = line[2:]

                found = 0

                tok = ""

                while found == 0:

                    i = 0

                    l = len(line)

                    while i < l:

                        if line[i] == '*' and i+1 < l and line[i+1] == '/':

                            self.line = line[i+2:]

                            line = line[:i-1]

                            l = i

                            found = 1

                            break

                        i = i + 1

                    if tok != "":

                        tok = tok + "\n"

                    tok = tok + line

                    if found == 0:

                        line = self.getline()

                        if line == None:

                            return None

                self.last = ('comment', tok)

                return self.last

            if l >= 2 and line[0] == '/' and line[1] == '/':

                line = line[2:]

                self.last = ('comment', line)

                return self.last

            i = 0

            while i < l:

                if line[i] == '/' and i+1 < l and line[i+1] == '/':

                    self.line = line[i:]

                    line = line[:i]

                    break

                if line[i] == '/' and i+1 < l and line[i+1] == '*':

                    self.line = line[i:]

                    line = line[:i]

                    break

                if line[i] == '"' or line[i] == "'":

                    self.line = line[i:]

                    line = line[:i]

                    break

                i = i + 1

            l = len(line)

            i = 0

            while i < l:

                if line[i] == ' ' or line[i] == '\t':

                    i = i + 1

                    continue

                o = ord(line[i])

                if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \

                   (o >= 48 and o <= 57):

                    s = i

                    while i < l:

                        o = ord(line[i])

                        if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \

                           (o >= 48 and o <= 57) or \

			   (" \t(){}:;,+-*/%&!|[]=><".find(line[i])) == -1:

                            i = i + 1

                        else:

                            break

                    self.tokens.append(('name', line[s:i]))

                    continue

                if "(){}:;,[]".find(line[i]) != -1:

#                 if line[i] == '(' or line[i] == ')' or line[i] == '{' or \

#                    line[i] == '}' or line[i] == ':' or line[i] == ';' or \

#                    line[i] == ',' or line[i] == '[' or line[i] == ']':

                    self.tokens.append(('sep', line[i]))

                    i = i + 1

                    continue

                if "+-*><=/%&!|.".find(line[i]) != -1:

#                 if line[i] == '+' or line[i] == '-' or line[i] == '*' or \

#                    line[i] == '>' or line[i] == '<' or line[i] == '=' or \

#                    line[i] == '/' or line[i] == '%' or line[i] == '&' or \

#                    line[i] == '!' or line[i] == '|' or line[i] == '.':

                    if line[i] == '.' and  i + 2 < l and \

                       line[i+1] == '.' and line[i+2] == '.':

                        self.tokens.append(('name', '...'))

                        i = i + 3

                        continue

                    j = i + 1

                    if j < l and (

                       "+-*><=/%&!|".find(line[j]) != -1):

#                        line[j] == '+' or line[j] == '-' or line[j] == '*' or \

#                        line[j] == '>' or line[j] == '<' or line[j] == '=' or \

#                        line[j] == '/' or line[j] == '%' or line[j] == '&' or \

#                        line[j] == '!' or line[j] == '|'):

                        self.tokens.append(('op', line[i:j+1]))

                        i = j + 1

                    else:

                        self.tokens.append(('op', line[i]))

                        i = i + 1

                    continue

                s = i

                while i < l:

                    o = ord(line[i])

                    if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \

                       (o >= 48 and o <= 57) or (

                        " \t(){}:;,+-*/%&!|[]=><".find(line[i]) == -1):

#                         line[i] != ' ' and line[i] != '\t' and

#                         line[i] != '(' and line[i] != ')' and

#                         line[i] != '{'  and line[i] != '}' and

#                         line[i] != ':' and line[i] != ';' and

#                         line[i] != ',' and line[i] != '+' and

#                         line[i] != '-' and line[i] != '*' and

#                         line[i] != '/' and line[i] != '%' and

#                         line[i] != '&' and line[i] != '!' and

#                         line[i] != '|' and line[i] != '[' and

#                         line[i] != ']' and line[i] != '=' and

#                         line[i] != '*' and line[i] != '>' and

#                         line[i] != '<'):

                        i = i + 1

                    else:

                        break

                self.tokens.append(('name', line[s:i]))

        tok = self.tokens[0]

        self.tokens = self.tokens[1:]

        self.last = tok

        return tok

class CParser:

    """The C module parser"""

    def __init__(self, filename, idx = None):

        self.filename = filename

        if len(filename) > 2 and filename[-2:] == '.h':

            self.is_header = 1

        else:

            self.is_header = 0

        self.input = open(filename)

        self.lexer = CLexer(self.input)

        if idx == None:

            self.index = index()

        else:

            self.index = idx

        self.top_comment = ""

        self.last_comment = ""

        self.comment = None

        self.collect_ref = 0

        self.no_error = 0

        self.conditionals = []

        self.defines = []

    def collect_references(self):

        self.collect_ref = 1

    def stop_error(self):

        self.no_error = 1

    def start_error(self):

        self.no_error = 0

    def lineno(self):

        return self.lexer.getlineno()

    def index_add(self, name, module, static, type, info=None, extra = None):

        if self.is_header == 1:

            self.index.add(name, module, module, static, type, self.lineno(),

                           info, extra, self.conditionals)

        else:

            self.index.add(name, None, module, static, type, self.lineno(),

                           info, extra, self.conditionals)

    def index_add_ref(self, name, module, static, type, info=None,

                      extra = None):

        if self.is_header == 1:

            self.index.add_ref(name, module, module, static, type,

                               self.lineno(), info, extra, self.conditionals)

        else:

            self.index.add_ref(name, None, module, static, type, self.lineno(),

                               info, extra, self.conditionals)

    def warning(self, msg):

        if self.no_error:

            return

        print(msg)

    def error(self, msg, token=-1):

        if self.no_error:

            return

        print("Parse Error: " + msg)

        if token != -1:

            print("Got token ", token)

        self.lexer.debug()

        sys.exit(1)

    def debug(self, msg, token=-1):

        print("Debug: " + msg)

        if token != -1:

            print("Got token ", token)

        self.lexer.debug()

    def parseTopComment(self, comment):

        res = {}

        lines = comment.split("\n")

        item = None

        for line in lines:

            while line != "" and (line[0] == ' ' or line[0] == '\t'):

                line = line[1:]

            while line != "" and line[0] == '*':

                line = line[1:]

            while line != "" and (line[0] == ' ' or line[0] == '\t'):

                line = line[1:]

            try:

                (it, line) = line.split(":", 1)

                item = it

                while line != "" and (line[0] == ' ' or line[0] == '\t'):

                    line = line[1:]

                if item in res:

                    res[item] = res[item] + " " + line

                else:

                    res[item] = line

            except:

                if item != None:

                    if item in res:

                        res[item] = res[item] + " " + line

                    else:

                        res[item] = line

        self.index.info = res

    def parseComment(self, token):

        if self.top_comment == "":

            self.top_comment = token[1]

        if self.comment == None or token[1][0] == '*':

            self.comment = token[1];

        else:

            self.comment = self.comment + token[1]

        token = self.lexer.token()

        if self.comment.find("DOC_DISABLE") != -1:

            self.stop_error()

        if self.comment.find("DOC_ENABLE") != -1:

            self.start_error()

        return token

    #

    # Parse a comment block associate to a typedef

    #

    def parseTypeComment(self, name, quiet = 0):

        if name[0:2] == '__':

            quiet = 1

        args = []

        desc = ""

        if self.comment == None:

            if not quiet:

                self.warning("Missing comment for type %s" % (name))

            return((args, desc))

        if self.comment[0] != '*':

            if not quiet:

                self.warning("Missing * in type comment for %s" % (name))

            return((args, desc))

        lines = self.comment.split('\n')

        if lines[0] == '*':

            del lines[0]

        if lines[0] != "* %s:" % (name):

            if not quiet:

                self.warning("Misformatted type comment for %s" % (name))

                self.warning("  Expecting '* %s:' got '%s'" % (name, lines[0]))

            return((args, desc))

        del lines[0]

        while len(lines) > 0 and lines[0] == '*':

            del lines[0]

        desc = ""

        while len(lines) > 0:

            l = lines[0]

            while len(l) > 0 and l[0] == '*':

                l = l[1:]

            l = l.strip()

            desc = desc + " " + l

            del lines[0]

        desc = desc.strip()

        if quiet == 0:

            if desc == "":

                self.warning("Type comment for %s lack description of the macro" % (name))

        return(desc)

    #

    # Parse a comment block associate to a macro

    #

    def parseMacroComment(self, name, quiet = 0):

        if name[0:2] == '__':

            quiet = 1

        args = []

        desc = ""

        if self.comment == None:

            if not quiet:

                self.warning("Missing comment for macro %s" % (name))

            return((args, desc))

        if self.comment[0] != '*':

            if not quiet:

                self.warning("Missing * in macro comment for %s" % (name))

            return((args, desc))

        lines = self.comment.split('\n')

        if lines[0] == '*':

            del lines[0]

        if lines[0] != "* %s:" % (name):

            if not quiet:

                self.warning("Misformatted macro comment for %s" % (name))

                self.warning("  Expecting '* %s:' got '%s'" % (name, lines[0]))

            return((args, desc))

        del lines[0]

        while lines[0] == '*':

            del lines[0]

        while len(lines) > 0 and lines[0][0:3] == '* @':

            l = lines[0][3:]

            try:

                (arg, desc) = l.split(':', 1)

                desc=desc.strip()

                arg=arg.strip()

            except:

                if not quiet:

                    self.warning("Misformatted macro comment for %s" % (name))

                    self.warning("  problem with '%s'" % (lines[0]))

                del lines[0]

                continue

            del lines[0]

            l = lines[0].strip()

            while len(l) > 2 and l[0:3] != '* @':

                while l[0] == '*':

                    l = l[1:]

                desc = desc + ' ' + l.strip()

                del lines[0]

                if len(lines) == 0:

                    break

                l = lines[0]

            args.append((arg, desc))

        while len(lines) > 0 and lines[0] == '*':

            del lines[0]

        desc = ""

        while len(lines) > 0:

            l = lines[0]

            while len(l) > 0 and l[0] == '*':

                l = l[1:]

            l = l.strip()

            desc = desc + " " + l

            del lines[0]

        desc = desc.strip()

        if quiet == 0:

            if desc == "":

                self.warning("Macro comment for %s lack description of the macro" % (name))

        return((args, desc))

     #

     # Parse a comment block and merge the informations found in the

     # parameters descriptions, finally returns a block as complete

     # as possible

     #

    def mergeFunctionComment(self, name, description, quiet = 0):

        if name == 'main':

            quiet = 1

        if name[0:2] == '__':

            quiet = 1

        (ret, args) = description

        desc = ""

        retdesc = ""

        if self.comment == None:

            if not quiet:

                self.warning("Missing comment for function %s" % (name))

            return(((ret[0], retdesc), args, desc))

        if self.comment[0] != '*':

            if not quiet:

                self.warning("Missing * in function comment for %s" % (name))

            return(((ret[0], retdesc), args, desc))

        lines = self.comment.split('\n')

        if lines[0] == '*':

            del lines[0]

        if lines[0] != "* %s:" % (name):

            if not quiet:

                self.warning("Misformatted function comment for %s" % (name))

                self.warning("  Expecting '* %s:' got '%s'" % (name, lines[0]))

            return(((ret[0], retdesc), args, desc))

        del lines[0]

        while lines[0] == '*':

            del lines[0]

        nbargs = len(args)

        while len(lines) > 0 and lines[0][0:3] == '* @':

            l = lines[0][3:]

            try:

                (arg, desc) = l.split(':', 1)

                desc=desc.strip()

                arg=arg.strip()

            except:

                if not quiet:

                    self.warning("Misformatted function comment for %s" % (name))

                    self.warning("  problem with '%s'" % (lines[0]))

                del lines[0]

                continue

            del lines[0]

            l = lines[0].strip()

            while len(l) > 2 and l[0:3] != '* @':

                while l[0] == '*':

                    l = l[1:]

                desc = desc + ' ' + l.strip()

                del lines[0]

                if len(lines) == 0:

                    break

                l = lines[0]

            i = 0

            while i < nbargs:

                if args[i][1] == arg:

                    args[i] = (args[i][0], arg, desc)

                    break;

                i = i + 1

            if i >= nbargs:

                if not quiet:

                    self.warning("Unable to find arg %s from function comment for %s" % (

                       arg, name))

        while len(lines) > 0 and lines[0] == '*':

            del lines[0]

        desc = ""

        while len(lines) > 0: