Annotation of embedaddon/libxml2/doc/apibuild.py, revision 1.1
1.1 ! misho 1: #!/usr/bin/python -u
! 2: #
! 3: # This is the API builder, it parses the C sources and build the
! 4: # API formal description in XML.
! 5: #
! 6: # See Copyright for the status of this software.
! 7: #
! 8: # daniel@veillard.com
! 9: #
! 10: import os, sys
! 11: import string
! 12: import glob
! 13:
! 14: debug=0
! 15: #debugsym='ignorableWhitespaceSAXFunc'
! 16: debugsym=None
! 17:
! 18: #
! 19: # C parser analysis code
! 20: #
! 21: ignored_files = {
! 22: "trio": "too many non standard macros",
! 23: "trio.c": "too many non standard macros",
! 24: "trionan.c": "too many non standard macros",
! 25: "triostr.c": "too many non standard macros",
! 26: "acconfig.h": "generated portability layer",
! 27: "config.h": "generated portability layer",
! 28: "libxml.h": "internal only",
! 29: "testOOM.c": "out of memory tester",
! 30: "testOOMlib.h": "out of memory tester",
! 31: "testOOMlib.c": "out of memory tester",
! 32: "rngparser.c": "not yet integrated",
! 33: "rngparser.h": "not yet integrated",
! 34: "elfgcchack.h": "not a normal header",
! 35: "testHTML.c": "test tool",
! 36: "testReader.c": "test tool",
! 37: "testSchemas.c": "test tool",
! 38: "testXPath.c": "test tool",
! 39: "testAutomata.c": "test tool",
! 40: "testModule.c": "test tool",
! 41: "testRegexp.c": "test tool",
! 42: "testThreads.c": "test tool",
! 43: "testC14N.c": "test tool",
! 44: "testRelax.c": "test tool",
! 45: "testThreadsWin32.c": "test tool",
! 46: "testSAX.c": "test tool",
! 47: "testURI.c": "test tool",
! 48: "testapi.c": "generated regression tests",
! 49: "runtest.c": "regression tests program",
! 50: "runsuite.c": "regression tests program",
! 51: "tst.c": "not part of the library",
! 52: "test.c": "not part of the library",
! 53: "testdso.c": "test for dynamid shared libraries",
! 54: "testrecurse.c": "test for entities recursions",
! 55: }
! 56:
! 57: ignored_words = {
! 58: "WINAPI": (0, "Windows keyword"),
! 59: "LIBXML_DLL_IMPORT": (0, "Special macro to flag external keywords"),
! 60: "XMLPUBVAR": (0, "Special macro for extern vars for win32"),
! 61: "XSLTPUBVAR": (0, "Special macro for extern vars for win32"),
! 62: "EXSLTPUBVAR": (0, "Special macro for extern vars for win32"),
! 63: "XMLPUBFUN": (0, "Special macro for extern funcs for win32"),
! 64: "XSLTPUBFUN": (0, "Special macro for extern funcs for win32"),
! 65: "EXSLTPUBFUN": (0, "Special macro for extern funcs for win32"),
! 66: "XMLCALL": (0, "Special macro for win32 calls"),
! 67: "XSLTCALL": (0, "Special macro for win32 calls"),
! 68: "XMLCDECL": (0, "Special macro for win32 calls"),
! 69: "EXSLTCALL": (0, "Special macro for win32 calls"),
! 70: "__declspec": (3, "Windows keyword"),
! 71: "__stdcall": (0, "Windows keyword"),
! 72: "ATTRIBUTE_UNUSED": (0, "macro keyword"),
! 73: "LIBEXSLT_PUBLIC": (0, "macro keyword"),
! 74: "X_IN_Y": (5, "macro function builder"),
! 75: "ATTRIBUTE_ALLOC_SIZE": (3, "macro for gcc checking extension"),
! 76: "ATTRIBUTE_PRINTF": (5, "macro for gcc printf args checking extension"),
! 77: "LIBXML_ATTR_FORMAT": (5, "macro for gcc printf args checking extension"),
! 78: "LIBXML_ATTR_ALLOC_SIZE": (3, "macro for gcc checking extension"),
! 79: }
! 80:
! 81: def escape(raw):
! 82: raw = string.replace(raw, '&', '&')
! 83: raw = string.replace(raw, '<', '<')
! 84: raw = string.replace(raw, '>', '>')
! 85: raw = string.replace(raw, "'", ''')
! 86: raw = string.replace(raw, '"', '"')
! 87: return raw
! 88:
! 89: def uniq(items):
! 90: d = {}
! 91: for item in items:
! 92: d[item]=1
! 93: return d.keys()
! 94:
! 95: class identifier:
! 96: def __init__(self, name, header=None, module=None, type=None, lineno = 0,
! 97: info=None, extra=None, conditionals = None):
! 98: self.name = name
! 99: self.header = header
! 100: self.module = module
! 101: self.type = type
! 102: self.info = info
! 103: self.extra = extra
! 104: self.lineno = lineno
! 105: self.static = 0
! 106: if conditionals == None or len(conditionals) == 0:
! 107: self.conditionals = None
! 108: else:
! 109: self.conditionals = conditionals[:]
! 110: if self.name == debugsym:
! 111: print "=> define %s : %s" % (debugsym, (module, type, info,
! 112: extra, conditionals))
! 113:
! 114: def __repr__(self):
! 115: r = "%s %s:" % (self.type, self.name)
! 116: if self.static:
! 117: r = r + " static"
! 118: if self.module != None:
! 119: r = r + " from %s" % (self.module)
! 120: if self.info != None:
! 121: r = r + " " + `self.info`
! 122: if self.extra != None:
! 123: r = r + " " + `self.extra`
! 124: if self.conditionals != None:
! 125: r = r + " " + `self.conditionals`
! 126: return r
! 127:
! 128:
! 129: def set_header(self, header):
! 130: self.header = header
! 131: def set_module(self, module):
! 132: self.module = module
! 133: def set_type(self, type):
! 134: self.type = type
! 135: def set_info(self, info):
! 136: self.info = info
! 137: def set_extra(self, extra):
! 138: self.extra = extra
! 139: def set_lineno(self, lineno):
! 140: self.lineno = lineno
! 141: def set_static(self, static):
! 142: self.static = static
! 143: def set_conditionals(self, conditionals):
! 144: if conditionals == None or len(conditionals) == 0:
! 145: self.conditionals = None
! 146: else:
! 147: self.conditionals = conditionals[:]
! 148:
! 149: def get_name(self):
! 150: return self.name
! 151: def get_header(self):
! 152: return self.module
! 153: def get_module(self):
! 154: return self.module
! 155: def get_type(self):
! 156: return self.type
! 157: def get_info(self):
! 158: return self.info
! 159: def get_lineno(self):
! 160: return self.lineno
! 161: def get_extra(self):
! 162: return self.extra
! 163: def get_static(self):
! 164: return self.static
! 165: def get_conditionals(self):
! 166: return self.conditionals
! 167:
! 168: def update(self, header, module, type = None, info = None, extra=None,
! 169: conditionals=None):
! 170: if self.name == debugsym:
! 171: print "=> update %s : %s" % (debugsym, (module, type, info,
! 172: extra, conditionals))
! 173: if header != None and self.header == None:
! 174: self.set_header(module)
! 175: if module != None and (self.module == None or self.header == self.module):
! 176: self.set_module(module)
! 177: if type != None and self.type == None:
! 178: self.set_type(type)
! 179: if info != None:
! 180: self.set_info(info)
! 181: if extra != None:
! 182: self.set_extra(extra)
! 183: if conditionals != None:
! 184: self.set_conditionals(conditionals)
! 185:
! 186: class index:
! 187: def __init__(self, name = "noname"):
! 188: self.name = name
! 189: self.identifiers = {}
! 190: self.functions = {}
! 191: self.variables = {}
! 192: self.includes = {}
! 193: self.structs = {}
! 194: self.enums = {}
! 195: self.typedefs = {}
! 196: self.macros = {}
! 197: self.references = {}
! 198: self.info = {}
! 199:
! 200: def add_ref(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):
! 201: if name[0:2] == '__':
! 202: return None
! 203: d = None
! 204: try:
! 205: d = self.identifiers[name]
! 206: d.update(header, module, type, lineno, info, extra, conditionals)
! 207: except:
! 208: d = identifier(name, header, module, type, lineno, info, extra, conditionals)
! 209: self.identifiers[name] = d
! 210:
! 211: if d != None and static == 1:
! 212: d.set_static(1)
! 213:
! 214: if d != None and name != None and type != None:
! 215: self.references[name] = d
! 216:
! 217: if name == debugsym:
! 218: print "New ref: %s" % (d)
! 219:
! 220: return d
! 221:
! 222: def add(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):
! 223: if name[0:2] == '__':
! 224: return None
! 225: d = None
! 226: try:
! 227: d = self.identifiers[name]
! 228: d.update(header, module, type, lineno, info, extra, conditionals)
! 229: except:
! 230: d = identifier(name, header, module, type, lineno, info, extra, conditionals)
! 231: self.identifiers[name] = d
! 232:
! 233: if d != None and static == 1:
! 234: d.set_static(1)
! 235:
! 236: if d != None and name != None and type != None:
! 237: if type == "function":
! 238: self.functions[name] = d
! 239: elif type == "functype":
! 240: self.functions[name] = d
! 241: elif type == "variable":
! 242: self.variables[name] = d
! 243: elif type == "include":
! 244: self.includes[name] = d
! 245: elif type == "struct":
! 246: self.structs[name] = d
! 247: elif type == "enum":
! 248: self.enums[name] = d
! 249: elif type == "typedef":
! 250: self.typedefs[name] = d
! 251: elif type == "macro":
! 252: self.macros[name] = d
! 253: else:
! 254: print "Unable to register type ", type
! 255:
! 256: if name == debugsym:
! 257: print "New symbol: %s" % (d)
! 258:
! 259: return d
! 260:
! 261: def merge(self, idx):
! 262: for id in idx.functions.keys():
! 263: #
! 264: # macro might be used to override functions or variables
! 265: # definitions
! 266: #
! 267: if self.macros.has_key(id):
! 268: del self.macros[id]
! 269: if self.functions.has_key(id):
! 270: print "function %s from %s redeclared in %s" % (
! 271: id, self.functions[id].header, idx.functions[id].header)
! 272: else:
! 273: self.functions[id] = idx.functions[id]
! 274: self.identifiers[id] = idx.functions[id]
! 275: for id in idx.variables.keys():
! 276: #
! 277: # macro might be used to override functions or variables
! 278: # definitions
! 279: #
! 280: if self.macros.has_key(id):
! 281: del self.macros[id]
! 282: if self.variables.has_key(id):
! 283: print "variable %s from %s redeclared in %s" % (
! 284: id, self.variables[id].header, idx.variables[id].header)
! 285: else:
! 286: self.variables[id] = idx.variables[id]
! 287: self.identifiers[id] = idx.variables[id]
! 288: for id in idx.structs.keys():
! 289: if self.structs.has_key(id):
! 290: print "struct %s from %s redeclared in %s" % (
! 291: id, self.structs[id].header, idx.structs[id].header)
! 292: else:
! 293: self.structs[id] = idx.structs[id]
! 294: self.identifiers[id] = idx.structs[id]
! 295: for id in idx.typedefs.keys():
! 296: if self.typedefs.has_key(id):
! 297: print "typedef %s from %s redeclared in %s" % (
! 298: id, self.typedefs[id].header, idx.typedefs[id].header)
! 299: else:
! 300: self.typedefs[id] = idx.typedefs[id]
! 301: self.identifiers[id] = idx.typedefs[id]
! 302: for id in idx.macros.keys():
! 303: #
! 304: # macro might be used to override functions or variables
! 305: # definitions
! 306: #
! 307: if self.variables.has_key(id):
! 308: continue
! 309: if self.functions.has_key(id):
! 310: continue
! 311: if self.enums.has_key(id):
! 312: continue
! 313: if self.macros.has_key(id):
! 314: print "macro %s from %s redeclared in %s" % (
! 315: id, self.macros[id].header, idx.macros[id].header)
! 316: else:
! 317: self.macros[id] = idx.macros[id]
! 318: self.identifiers[id] = idx.macros[id]
! 319: for id in idx.enums.keys():
! 320: if self.enums.has_key(id):
! 321: print "enum %s from %s redeclared in %s" % (
! 322: id, self.enums[id].header, idx.enums[id].header)
! 323: else:
! 324: self.enums[id] = idx.enums[id]
! 325: self.identifiers[id] = idx.enums[id]
! 326:
! 327: def merge_public(self, idx):
! 328: for id in idx.functions.keys():
! 329: if self.functions.has_key(id):
! 330: # check that function condition agrees with header
! 331: if idx.functions[id].conditionals != \
! 332: self.functions[id].conditionals:
! 333: print "Header condition differs from Function for %s:" \
! 334: % id
! 335: print " H: %s" % self.functions[id].conditionals
! 336: print " C: %s" % idx.functions[id].conditionals
! 337: up = idx.functions[id]
! 338: self.functions[id].update(None, up.module, up.type, up.info, up.extra)
! 339: # else:
! 340: # print "Function %s from %s is not declared in headers" % (
! 341: # id, idx.functions[id].module)
! 342: # TODO: do the same for variables.
! 343:
! 344: def analyze_dict(self, type, dict):
! 345: count = 0
! 346: public = 0
! 347: for name in dict.keys():
! 348: id = dict[name]
! 349: count = count + 1
! 350: if id.static == 0:
! 351: public = public + 1
! 352: if count != public:
! 353: print " %d %s , %d public" % (count, type, public)
! 354: elif count != 0:
! 355: print " %d public %s" % (count, type)
! 356:
! 357:
! 358: def analyze(self):
! 359: self.analyze_dict("functions", self.functions)
! 360: self.analyze_dict("variables", self.variables)
! 361: self.analyze_dict("structs", self.structs)
! 362: self.analyze_dict("typedefs", self.typedefs)
! 363: self.analyze_dict("macros", self.macros)
! 364:
! 365: class CLexer:
! 366: """A lexer for the C language, tokenize the input by reading and
! 367: analyzing it line by line"""
! 368: def __init__(self, input):
! 369: self.input = input
! 370: self.tokens = []
! 371: self.line = ""
! 372: self.lineno = 0
! 373:
! 374: def getline(self):
! 375: line = ''
! 376: while line == '':
! 377: line = self.input.readline()
! 378: if not line:
! 379: return None
! 380: self.lineno = self.lineno + 1
! 381: line = string.lstrip(line)
! 382: line = string.rstrip(line)
! 383: if line == '':
! 384: continue
! 385: while line[-1] == '\\':
! 386: line = line[:-1]
! 387: n = self.input.readline()
! 388: self.lineno = self.lineno + 1
! 389: n = string.lstrip(n)
! 390: n = string.rstrip(n)
! 391: if not n:
! 392: break
! 393: else:
! 394: line = line + n
! 395: return line
! 396:
! 397: def getlineno(self):
! 398: return self.lineno
! 399:
! 400: def push(self, token):
! 401: self.tokens.insert(0, token);
! 402:
! 403: def debug(self):
! 404: print "Last token: ", self.last
! 405: print "Token queue: ", self.tokens
! 406: print "Line %d end: " % (self.lineno), self.line
! 407:
! 408: def token(self):
! 409: while self.tokens == []:
! 410: if self.line == "":
! 411: line = self.getline()
! 412: else:
! 413: line = self.line
! 414: self.line = ""
! 415: if line == None:
! 416: return None
! 417:
! 418: if line[0] == '#':
! 419: self.tokens = map((lambda x: ('preproc', x)),
! 420: string.split(line))
! 421: break;
! 422: l = len(line)
! 423: if line[0] == '"' or line[0] == "'":
! 424: end = line[0]
! 425: line = line[1:]
! 426: found = 0
! 427: tok = ""
! 428: while found == 0:
! 429: i = 0
! 430: l = len(line)
! 431: while i < l:
! 432: if line[i] == end:
! 433: self.line = line[i+1:]
! 434: line = line[:i]
! 435: l = i
! 436: found = 1
! 437: break
! 438: if line[i] == '\\':
! 439: i = i + 1
! 440: i = i + 1
! 441: tok = tok + line
! 442: if found == 0:
! 443: line = self.getline()
! 444: if line == None:
! 445: return None
! 446: self.last = ('string', tok)
! 447: return self.last
! 448:
! 449: if l >= 2 and line[0] == '/' and line[1] == '*':
! 450: line = line[2:]
! 451: found = 0
! 452: tok = ""
! 453: while found == 0:
! 454: i = 0
! 455: l = len(line)
! 456: while i < l:
! 457: if line[i] == '*' and i+1 < l and line[i+1] == '/':
! 458: self.line = line[i+2:]
! 459: line = line[:i-1]
! 460: l = i
! 461: found = 1
! 462: break
! 463: i = i + 1
! 464: if tok != "":
! 465: tok = tok + "\n"
! 466: tok = tok + line
! 467: if found == 0:
! 468: line = self.getline()
! 469: if line == None:
! 470: return None
! 471: self.last = ('comment', tok)
! 472: return self.last
! 473: if l >= 2 and line[0] == '/' and line[1] == '/':
! 474: line = line[2:]
! 475: self.last = ('comment', line)
! 476: return self.last
! 477: i = 0
! 478: while i < l:
! 479: if line[i] == '/' and i+1 < l and line[i+1] == '/':
! 480: self.line = line[i:]
! 481: line = line[:i]
! 482: break
! 483: if line[i] == '/' and i+1 < l and line[i+1] == '*':
! 484: self.line = line[i:]
! 485: line = line[:i]
! 486: break
! 487: if line[i] == '"' or line[i] == "'":
! 488: self.line = line[i:]
! 489: line = line[:i]
! 490: break
! 491: i = i + 1
! 492: l = len(line)
! 493: i = 0
! 494: while i < l:
! 495: if line[i] == ' ' or line[i] == '\t':
! 496: i = i + 1
! 497: continue
! 498: o = ord(line[i])
! 499: if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \
! 500: (o >= 48 and o <= 57):
! 501: s = i
! 502: while i < l:
! 503: o = ord(line[i])
! 504: if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \
! 505: (o >= 48 and o <= 57) or string.find(
! 506: " \t(){}:;,+-*/%&!|[]=><", line[i]) == -1:
! 507: i = i + 1
! 508: else:
! 509: break
! 510: self.tokens.append(('name', line[s:i]))
! 511: continue
! 512: if string.find("(){}:;,[]", line[i]) != -1:
! 513: # if line[i] == '(' or line[i] == ')' or line[i] == '{' or \
! 514: # line[i] == '}' or line[i] == ':' or line[i] == ';' or \
! 515: # line[i] == ',' or line[i] == '[' or line[i] == ']':
! 516: self.tokens.append(('sep', line[i]))
! 517: i = i + 1
! 518: continue
! 519: if string.find("+-*><=/%&!|.", line[i]) != -1:
! 520: # if line[i] == '+' or line[i] == '-' or line[i] == '*' or \
! 521: # line[i] == '>' or line[i] == '<' or line[i] == '=' or \
! 522: # line[i] == '/' or line[i] == '%' or line[i] == '&' or \
! 523: # line[i] == '!' or line[i] == '|' or line[i] == '.':
! 524: if line[i] == '.' and i + 2 < l and \
! 525: line[i+1] == '.' and line[i+2] == '.':
! 526: self.tokens.append(('name', '...'))
! 527: i = i + 3
! 528: continue
! 529:
! 530: j = i + 1
! 531: if j < l and (
! 532: string.find("+-*><=/%&!|", line[j]) != -1):
! 533: # line[j] == '+' or line[j] == '-' or line[j] == '*' or \
! 534: # line[j] == '>' or line[j] == '<' or line[j] == '=' or \
! 535: # line[j] == '/' or line[j] == '%' or line[j] == '&' or \
! 536: # line[j] == '!' or line[j] == '|'):
! 537: self.tokens.append(('op', line[i:j+1]))
! 538: i = j + 1
! 539: else:
! 540: self.tokens.append(('op', line[i]))
! 541: i = i + 1
! 542: continue
! 543: s = i
! 544: while i < l:
! 545: o = ord(line[i])
! 546: if (o >= 97 and o <= 122) or (o >= 65 and o <= 90) or \
! 547: (o >= 48 and o <= 57) or (
! 548: string.find(" \t(){}:;,+-*/%&!|[]=><", line[i]) == -1):
! 549: # line[i] != ' ' and line[i] != '\t' and
! 550: # line[i] != '(' and line[i] != ')' and
! 551: # line[i] != '{' and line[i] != '}' and
! 552: # line[i] != ':' and line[i] != ';' and
! 553: # line[i] != ',' and line[i] != '+' and
! 554: # line[i] != '-' and line[i] != '*' and
! 555: # line[i] != '/' and line[i] != '%' and
! 556: # line[i] != '&' and line[i] != '!' and
! 557: # line[i] != '|' and line[i] != '[' and
! 558: # line[i] != ']' and line[i] != '=' and
! 559: # line[i] != '*' and line[i] != '>' and
! 560: # line[i] != '<'):
! 561: i = i + 1
! 562: else:
! 563: break
! 564: self.tokens.append(('name', line[s:i]))
! 565:
! 566: tok = self.tokens[0]
! 567: self.tokens = self.tokens[1:]
! 568: self.last = tok
! 569: return tok
! 570:
! 571: class CParser:
! 572: """The C module parser"""
! 573: def __init__(self, filename, idx = None):
! 574: self.filename = filename
! 575: if len(filename) > 2 and filename[-2:] == '.h':
! 576: self.is_header = 1
! 577: else:
! 578: self.is_header = 0
! 579: self.input = open(filename)
! 580: self.lexer = CLexer(self.input)
! 581: if idx == None:
! 582: self.index = index()
! 583: else:
! 584: self.index = idx
! 585: self.top_comment = ""
! 586: self.last_comment = ""
! 587: self.comment = None
! 588: self.collect_ref = 0
! 589: self.no_error = 0
! 590: self.conditionals = []
! 591: self.defines = []
! 592:
! 593: def collect_references(self):
! 594: self.collect_ref = 1
! 595:
! 596: def stop_error(self):
! 597: self.no_error = 1
! 598:
! 599: def start_error(self):
! 600: self.no_error = 0
! 601:
! 602: def lineno(self):
! 603: return self.lexer.getlineno()
! 604:
! 605: def index_add(self, name, module, static, type, info=None, extra = None):
! 606: if self.is_header == 1:
! 607: self.index.add(name, module, module, static, type, self.lineno(),
! 608: info, extra, self.conditionals)
! 609: else:
! 610: self.index.add(name, None, module, static, type, self.lineno(),
! 611: info, extra, self.conditionals)
! 612:
! 613: def index_add_ref(self, name, module, static, type, info=None,
! 614: extra = None):
! 615: if self.is_header == 1:
! 616: self.index.add_ref(name, module, module, static, type,
! 617: self.lineno(), info, extra, self.conditionals)
! 618: else:
! 619: self.index.add_ref(name, None, module, static, type, self.lineno(),
! 620: info, extra, self.conditionals)
! 621:
! 622: def warning(self, msg):
! 623: if self.no_error:
! 624: return
! 625: print msg
! 626:
! 627: def error(self, msg, token=-1):
! 628: if self.no_error:
! 629: return
! 630:
! 631: print "Parse Error: " + msg
! 632: if token != -1:
! 633: print "Got token ", token
! 634: self.lexer.debug()
! 635: sys.exit(1)
! 636:
! 637: def debug(self, msg, token=-1):
! 638: print "Debug: " + msg
! 639: if token != -1:
! 640: print "Got token ", token
! 641: self.lexer.debug()
! 642:
! 643: def parseTopComment(self, comment):
! 644: res = {}
! 645: lines = string.split(comment, "\n")
! 646: item = None
! 647: for line in lines:
! 648: while line != "" and (line[0] == ' ' or line[0] == '\t'):
! 649: line = line[1:]
! 650: while line != "" and line[0] == '*':
! 651: line = line[1:]
! 652: while line != "" and (line[0] == ' ' or line[0] == '\t'):
! 653: line = line[1:]
! 654: try:
! 655: (it, line) = string.split(line, ":", 1)
! 656: item = it
! 657: while line != "" and (line[0] == ' ' or line[0] == '\t'):
! 658: line = line[1:]
! 659: if res.has_key(item):
! 660: res[item] = res[item] + " " + line
! 661: else:
! 662: res[item] = line
! 663: except:
! 664: if item != None:
! 665: if res.has_key(item):
! 666: res[item] = res[item] + " " + line
! 667: else:
! 668: res[item] = line
! 669: self.index.info = res
! 670:
! 671: def parseComment(self, token):
! 672: if self.top_comment == "":
! 673: self.top_comment = token[1]
! 674: if self.comment == None or token[1][0] == '*':
! 675: self.comment = token[1];
! 676: else:
! 677: self.comment = self.comment + token[1]
! 678: token = self.lexer.token()
! 679:
! 680: if string.find(self.comment, "DOC_DISABLE") != -1:
! 681: self.stop_error()
! 682:
! 683: if string.find(self.comment, "DOC_ENABLE") != -1:
! 684: self.start_error()
! 685:
! 686: return token
! 687:
! 688: #
! 689: # Parse a comment block associate to a typedef
! 690: #
! 691: def parseTypeComment(self, name, quiet = 0):
! 692: if name[0:2] == '__':
! 693: quiet = 1
! 694:
! 695: args = []
! 696: desc = ""
! 697:
! 698: if self.comment == None:
! 699: if not quiet:
! 700: self.warning("Missing comment for type %s" % (name))
! 701: return((args, desc))
! 702: if self.comment[0] != '*':
! 703: if not quiet:
! 704: self.warning("Missing * in type comment for %s" % (name))
! 705: return((args, desc))
! 706: lines = string.split(self.comment, '\n')
! 707: if lines[0] == '*':
! 708: del lines[0]
! 709: if lines[0] != "* %s:" % (name):
! 710: if not quiet:
! 711: self.warning("Misformatted type comment for %s" % (name))
! 712: self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
! 713: return((args, desc))
! 714: del lines[0]
! 715: while len(lines) > 0 and lines[0] == '*':
! 716: del lines[0]
! 717: desc = ""
! 718: while len(lines) > 0:
! 719: l = lines[0]
! 720: while len(l) > 0 and l[0] == '*':
! 721: l = l[1:]
! 722: l = string.strip(l)
! 723: desc = desc + " " + l
! 724: del lines[0]
! 725:
! 726: desc = string.strip(desc)
! 727:
! 728: if quiet == 0:
! 729: if desc == "":
! 730: self.warning("Type comment for %s lack description of the macro" % (name))
! 731:
! 732: return(desc)
! 733: #
! 734: # Parse a comment block associate to a macro
! 735: #
! 736: def parseMacroComment(self, name, quiet = 0):
! 737: if name[0:2] == '__':
! 738: quiet = 1
! 739:
! 740: args = []
! 741: desc = ""
! 742:
! 743: if self.comment == None:
! 744: if not quiet:
! 745: self.warning("Missing comment for macro %s" % (name))
! 746: return((args, desc))
! 747: if self.comment[0] != '*':
! 748: if not quiet:
! 749: self.warning("Missing * in macro comment for %s" % (name))
! 750: return((args, desc))
! 751: lines = string.split(self.comment, '\n')
! 752: if lines[0] == '*':
! 753: del lines[0]
! 754: if lines[0] != "* %s:" % (name):
! 755: if not quiet:
! 756: self.warning("Misformatted macro comment for %s" % (name))
! 757: self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
! 758: return((args, desc))
! 759: del lines[0]
! 760: while lines[0] == '*':
! 761: del lines[0]
! 762: while len(lines) > 0 and lines[0][0:3] == '* @':
! 763: l = lines[0][3:]
! 764: try:
! 765: (arg, desc) = string.split(l, ':', 1)
! 766: desc=string.strip(desc)
! 767: arg=string.strip(arg)
! 768: except:
! 769: if not quiet:
! 770: self.warning("Misformatted macro comment for %s" % (name))
! 771: self.warning(" problem with '%s'" % (lines[0]))
! 772: del lines[0]
! 773: continue
! 774: del lines[0]
! 775: l = string.strip(lines[0])
! 776: while len(l) > 2 and l[0:3] != '* @':
! 777: while l[0] == '*':
! 778: l = l[1:]
! 779: desc = desc + ' ' + string.strip(l)
! 780: del lines[0]
! 781: if len(lines) == 0:
! 782: break
! 783: l = lines[0]
! 784: args.append((arg, desc))
! 785: while len(lines) > 0 and lines[0] == '*':
! 786: del lines[0]
! 787: desc = ""
! 788: while len(lines) > 0:
! 789: l = lines[0]
! 790: while len(l) > 0 and l[0] == '*':
! 791: l = l[1:]
! 792: l = string.strip(l)
! 793: desc = desc + " " + l
! 794: del lines[0]
! 795:
! 796: desc = string.strip(desc)
! 797:
! 798: if quiet == 0:
! 799: if desc == "":
! 800: self.warning("Macro comment for %s lack description of the macro" % (name))
! 801:
! 802: return((args, desc))
! 803:
! 804: #
! 805: # Parse a comment block and merge the informations found in the
! 806: # parameters descriptions, finally returns a block as complete
! 807: # as possible
! 808: #
! 809: def mergeFunctionComment(self, name, description, quiet = 0):
! 810: if name == 'main':
! 811: quiet = 1
! 812: if name[0:2] == '__':
! 813: quiet = 1
! 814:
! 815: (ret, args) = description
! 816: desc = ""
! 817: retdesc = ""
! 818:
! 819: if self.comment == None:
! 820: if not quiet:
! 821: self.warning("Missing comment for function %s" % (name))
! 822: return(((ret[0], retdesc), args, desc))
! 823: if self.comment[0] != '*':
! 824: if not quiet:
! 825: self.warning("Missing * in function comment for %s" % (name))
! 826: return(((ret[0], retdesc), args, desc))
! 827: lines = string.split(self.comment, '\n')
! 828: if lines[0] == '*':
! 829: del lines[0]
! 830: if lines[0] != "* %s:" % (name):
! 831: if not quiet:
! 832: self.warning("Misformatted function comment for %s" % (name))
! 833: self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
! 834: return(((ret[0], retdesc), args, desc))
! 835: del lines[0]
! 836: while lines[0] == '*':
! 837: del lines[0]
! 838: nbargs = len(args)
! 839: while len(lines) > 0 and lines[0][0:3] == '* @':
! 840: l = lines[0][3:]
! 841: try:
! 842: (arg, desc) = string.split(l, ':', 1)
! 843: desc=string.strip(desc)
! 844: arg=string.strip(arg)
! 845: except:
! 846: if not quiet:
! 847: self.warning("Misformatted function comment for %s" % (name))
! 848: self.warning(" problem with '%s'" % (lines[0]))
! 849: del lines[0]
! 850: continue
! 851: del lines[0]
! 852: l = string.strip(lines[0])
! 853: while len(l) > 2 and l[0:3] != '* @':
! 854: while l[0] == '*':
! 855: l = l[1:]
! 856: desc = desc + ' ' + string.strip(l)
! 857: del lines[0]
! 858: if len(lines) == 0:
! 859: break
! 860: l = lines[0]
! 861: i = 0
! 862: while i < nbargs:
! 863: if args[i][1] == arg:
! 864: args[i] = (args[i][0], arg, desc)
! 865: break;
! 866: i = i + 1
! 867: if i >= nbargs:
! 868: if not quiet:
! 869: self.warning("Unable to find arg %s from function comment for %s" % (
! 870: arg, name))
! 871: while len(lines) > 0 and lines[0] == '*':
! 872: del lines[0]
! 873: desc = ""
! 874: while len(lines) > 0:
! 875: l = lines[0]
! 876: while len(l) > 0 and l[0] == '*':
! 877: l = l[1:]
! 878: l = string.strip(l)
! 879: if len(l) >= 6 and l[0:6] == "return" or l[0:6] == "Return":
! 880: try:
! 881: l = string.split(l, ' ', 1)[1]
! 882: except:
! 883: l = ""
! 884: retdesc = string.strip(l)
! 885: del lines[0]
! 886: while len(lines) > 0:
! 887: l = lines[0]
! 888: while len(l) > 0 and l[0] == '*':
! 889: l = l[1:]
! 890: l = string.strip(l)
! 891: retdesc = retdesc + " " + l
! 892: del lines[0]
! 893: else:
! 894: desc = desc + " " + l
! 895: del lines[0]
! 896:
! 897: retdesc = string.strip(retdesc)
! 898: desc = string.strip(desc)
! 899:
! 900: if quiet == 0:
! 901: #
! 902: # report missing comments
! 903: #
! 904: i = 0
! 905: while i < nbargs:
! 906: if args[i][2] == None and args[i][0] != "void" and \
! 907: ((args[i][1] != None) or (args[i][1] == '')):
! 908: self.warning("Function comment for %s lacks description of arg %s" % (name, args[i][1]))
! 909: i = i + 1
! 910: if retdesc == "" and ret[0] != "void":
! 911: self.warning("Function comment for %s lacks description of return value" % (name))
! 912: if desc == "":
! 913: self.warning("Function comment for %s lacks description of the function" % (name))
! 914:
! 915: return(((ret[0], retdesc), args, desc))
! 916:
! 917: def parsePreproc(self, token):
! 918: if debug:
! 919: print "=> preproc ", token, self.lexer.tokens
! 920: name = token[1]
! 921: if name == "#include":
! 922: token = self.lexer.token()
! 923: if token == None:
! 924: return None
! 925: if token[0] == 'preproc':
! 926: self.index_add(token[1], self.filename, not self.is_header,
! 927: "include")
! 928: return self.lexer.token()
! 929: return token
! 930: if name == "#define":
! 931: token = self.lexer.token()
! 932: if token == None:
! 933: return None
! 934: if token[0] == 'preproc':
! 935: # TODO macros with arguments
! 936: name = token[1]
! 937: lst = []
! 938: token = self.lexer.token()
! 939: while token != None and token[0] == 'preproc' and \
! 940: token[1][0] != '#':
! 941: lst.append(token[1])
! 942: token = self.lexer.token()
! 943: try:
! 944: name = string.split(name, '(') [0]
! 945: except:
! 946: pass
! 947: info = self.parseMacroComment(name, not self.is_header)
! 948: self.index_add(name, self.filename, not self.is_header,
! 949: "macro", info)
! 950: return token
! 951:
! 952: #
! 953: # Processing of conditionals modified by Bill 1/1/05
! 954: #
! 955: # We process conditionals (i.e. tokens from #ifdef, #ifndef,
! 956: # #if, #else and #endif) for headers and mainline code,
! 957: # store the ones from the header in libxml2-api.xml, and later
! 958: # (in the routine merge_public) verify that the two (header and
! 959: # mainline code) agree.
! 960: #
! 961: # There is a small problem with processing the headers. Some of
! 962: # the variables are not concerned with enabling / disabling of
! 963: # library functions (e.g. '__XML_PARSER_H__'), and we don't want
! 964: # them to be included in libxml2-api.xml, or involved in
! 965: # the check between the header and the mainline code. To
! 966: # accomplish this, we ignore any conditional which doesn't include
! 967: # the string 'ENABLED'
! 968: #
! 969: if name == "#ifdef":
! 970: apstr = self.lexer.tokens[0][1]
! 971: try:
! 972: self.defines.append(apstr)
! 973: if string.find(apstr, 'ENABLED') != -1:
! 974: self.conditionals.append("defined(%s)" % apstr)
! 975: except:
! 976: pass
! 977: elif name == "#ifndef":
! 978: apstr = self.lexer.tokens[0][1]
! 979: try:
! 980: self.defines.append(apstr)
! 981: if string.find(apstr, 'ENABLED') != -1:
! 982: self.conditionals.append("!defined(%s)" % apstr)
! 983: except:
! 984: pass
! 985: elif name == "#if":
! 986: apstr = ""
! 987: for tok in self.lexer.tokens:
! 988: if apstr != "":
! 989: apstr = apstr + " "
! 990: apstr = apstr + tok[1]
! 991: try:
! 992: self.defines.append(apstr)
! 993: if string.find(apstr, 'ENABLED') != -1:
! 994: self.conditionals.append(apstr)
! 995: except:
! 996: pass
! 997: elif name == "#else":
! 998: if self.conditionals != [] and \
! 999: string.find(self.defines[-1], 'ENABLED') != -1:
! 1000: self.conditionals[-1] = "!(%s)" % self.conditionals[-1]
! 1001: elif name == "#endif":
! 1002: if self.conditionals != [] and \
! 1003: string.find(self.defines[-1], 'ENABLED') != -1:
! 1004: self.conditionals = self.conditionals[:-1]
! 1005: self.defines = self.defines[:-1]
! 1006: token = self.lexer.token()
! 1007: while token != None and token[0] == 'preproc' and \
! 1008: token[1][0] != '#':
! 1009: token = self.lexer.token()
! 1010: return token
! 1011:
! 1012: #
! 1013: # token acquisition on top of the lexer, it handle internally
! 1014: # preprocessor and comments since they are logically not part of
! 1015: # the program structure.
! 1016: #
! 1017: def token(self):
! 1018: global ignored_words
! 1019:
! 1020: token = self.lexer.token()
! 1021: while token != None:
! 1022: if token[0] == 'comment':
! 1023: token = self.parseComment(token)
! 1024: continue
! 1025: elif token[0] == 'preproc':
! 1026: token = self.parsePreproc(token)
! 1027: continue
! 1028: elif token[0] == "name" and token[1] == "__const":
! 1029: token = ("name", "const")
! 1030: return token
! 1031: elif token[0] == "name" and token[1] == "__attribute":
! 1032: token = self.lexer.token()
! 1033: while token != None and token[1] != ";":
! 1034: token = self.lexer.token()
! 1035: return token
! 1036: elif token[0] == "name" and ignored_words.has_key(token[1]):
! 1037: (n, info) = ignored_words[token[1]]
! 1038: i = 0
! 1039: while i < n:
! 1040: token = self.lexer.token()
! 1041: i = i + 1
! 1042: token = self.lexer.token()
! 1043: continue
! 1044: else:
! 1045: if debug:
! 1046: print "=> ", token
! 1047: return token
! 1048: return None
! 1049:
! 1050: #
! 1051: # Parse a typedef, it records the type and its name.
! 1052: #
! 1053: def parseTypedef(self, token):
! 1054: if token == None:
! 1055: return None
! 1056: token = self.parseType(token)
! 1057: if token == None:
! 1058: self.error("parsing typedef")
! 1059: return None
! 1060: base_type = self.type
! 1061: type = base_type
! 1062: #self.debug("end typedef type", token)
! 1063: while token != None:
! 1064: if token[0] == "name":
! 1065: name = token[1]
! 1066: signature = self.signature
! 1067: if signature != None:
! 1068: type = string.split(type, '(')[0]
! 1069: d = self.mergeFunctionComment(name,
! 1070: ((type, None), signature), 1)
! 1071: self.index_add(name, self.filename, not self.is_header,
! 1072: "functype", d)
! 1073: else:
! 1074: if base_type == "struct":
! 1075: self.index_add(name, self.filename, not self.is_header,
! 1076: "struct", type)
! 1077: base_type = "struct " + name
! 1078: else:
! 1079: # TODO report missing or misformatted comments
! 1080: info = self.parseTypeComment(name, 1)
! 1081: self.index_add(name, self.filename, not self.is_header,
! 1082: "typedef", type, info)
! 1083: token = self.token()
! 1084: else:
! 1085: self.error("parsing typedef: expecting a name")
! 1086: return token
! 1087: #self.debug("end typedef", token)
! 1088: if token != None and token[0] == 'sep' and token[1] == ',':
! 1089: type = base_type
! 1090: token = self.token()
! 1091: while token != None and token[0] == "op":
! 1092: type = type + token[1]
! 1093: token = self.token()
! 1094: elif token != None and token[0] == 'sep' and token[1] == ';':
! 1095: break;
! 1096: elif token != None and token[0] == 'name':
! 1097: type = base_type
! 1098: continue;
! 1099: else:
! 1100: self.error("parsing typedef: expecting ';'", token)
! 1101: return token
! 1102: token = self.token()
! 1103: return token
! 1104:
! 1105: #
! 1106: # Parse a C code block, used for functions it parse till
! 1107: # the balancing } included
! 1108: #
! 1109: def parseBlock(self, token):
! 1110: while token != None:
! 1111: if token[0] == "sep" and token[1] == "{":
! 1112: token = self.token()
! 1113: token = self.parseBlock(token)
! 1114: elif token[0] == "sep" and token[1] == "}":
! 1115: self.comment = None
! 1116: token = self.token()
! 1117: return token
! 1118: else:
! 1119: if self.collect_ref == 1:
! 1120: oldtok = token
! 1121: token = self.token()
! 1122: if oldtok[0] == "name" and oldtok[1][0:3] == "xml":
! 1123: if token[0] == "sep" and token[1] == "(":
! 1124: self.index_add_ref(oldtok[1], self.filename,
! 1125: 0, "function")
! 1126: token = self.token()
! 1127: elif token[0] == "name":
! 1128: token = self.token()
! 1129: if token[0] == "sep" and (token[1] == ";" or
! 1130: token[1] == "," or token[1] == "="):
! 1131: self.index_add_ref(oldtok[1], self.filename,
! 1132: 0, "type")
! 1133: elif oldtok[0] == "name" and oldtok[1][0:4] == "XML_":
! 1134: self.index_add_ref(oldtok[1], self.filename,
! 1135: 0, "typedef")
! 1136: elif oldtok[0] == "name" and oldtok[1][0:7] == "LIBXML_":
! 1137: self.index_add_ref(oldtok[1], self.filename,
! 1138: 0, "typedef")
! 1139:
! 1140: else:
! 1141: token = self.token()
! 1142: return token
! 1143:
! 1144: #
! 1145: # Parse a C struct definition till the balancing }
! 1146: #
! 1147: def parseStruct(self, token):
! 1148: fields = []
! 1149: #self.debug("start parseStruct", token)
! 1150: while token != None:
! 1151: if token[0] == "sep" and token[1] == "{":
! 1152: token = self.token()
! 1153: token = self.parseTypeBlock(token)
! 1154: elif token[0] == "sep" and token[1] == "}":
! 1155: self.struct_fields = fields
! 1156: #self.debug("end parseStruct", token)
! 1157: #print fields
! 1158: token = self.token()
! 1159: return token
! 1160: else:
! 1161: base_type = self.type
! 1162: #self.debug("before parseType", token)
! 1163: token = self.parseType(token)
! 1164: #self.debug("after parseType", token)
! 1165: if token != None and token[0] == "name":
! 1166: fname = token[1]
! 1167: token = self.token()
! 1168: if token[0] == "sep" and token[1] == ";":
! 1169: self.comment = None
! 1170: token = self.token()
! 1171: fields.append((self.type, fname, self.comment))
! 1172: self.comment = None
! 1173: else:
! 1174: self.error("parseStruct: expecting ;", token)
! 1175: elif token != None and token[0] == "sep" and token[1] == "{":
! 1176: token = self.token()
! 1177: token = self.parseTypeBlock(token)
! 1178: if token != None and token[0] == "name":
! 1179: token = self.token()
! 1180: if token != None and token[0] == "sep" and token[1] == ";":
! 1181: token = self.token()
! 1182: else:
! 1183: self.error("parseStruct: expecting ;", token)
! 1184: else:
! 1185: self.error("parseStruct: name", token)
! 1186: token = self.token()
! 1187: self.type = base_type;
! 1188: self.struct_fields = fields
! 1189: #self.debug("end parseStruct", token)
! 1190: #print fields
! 1191: return token
! 1192:
! 1193: #
! 1194: # Parse a C enum block, parse till the balancing }
! 1195: #
! 1196: def parseEnumBlock(self, token):
! 1197: self.enums = []
! 1198: name = None
! 1199: self.comment = None
! 1200: comment = ""
! 1201: value = "0"
! 1202: while token != None:
! 1203: if token[0] == "sep" and token[1] == "{":
! 1204: token = self.token()
! 1205: token = self.parseTypeBlock(token)
! 1206: elif token[0] == "sep" and token[1] == "}":
! 1207: if name != None:
! 1208: if self.comment != None:
! 1209: comment = self.comment
! 1210: self.comment = None
! 1211: self.enums.append((name, value, comment))
! 1212: token = self.token()
! 1213: return token
! 1214: elif token[0] == "name":
! 1215: if name != None:
! 1216: if self.comment != None:
! 1217: comment = string.strip(self.comment)
! 1218: self.comment = None
! 1219: self.enums.append((name, value, comment))
! 1220: name = token[1]
! 1221: comment = ""
! 1222: token = self.token()
! 1223: if token[0] == "op" and token[1][0] == "=":
! 1224: value = ""
! 1225: if len(token[1]) > 1:
! 1226: value = token[1][1:]
! 1227: token = self.token()
! 1228: while token[0] != "sep" or (token[1] != ',' and
! 1229: token[1] != '}'):
! 1230: value = value + token[1]
! 1231: token = self.token()
! 1232: else:
! 1233: try:
! 1234: value = "%d" % (int(value) + 1)
! 1235: except:
! 1236: self.warning("Failed to compute value of enum %s" % (name))
! 1237: value=""
! 1238: if token[0] == "sep" and token[1] == ",":
! 1239: token = self.token()
! 1240: else:
! 1241: token = self.token()
! 1242: return token
! 1243:
! 1244: #
! 1245: # Parse a C definition block, used for structs it parse till
! 1246: # the balancing }
! 1247: #
! 1248: def parseTypeBlock(self, token):
! 1249: while token != None:
! 1250: if token[0] == "sep" and token[1] == "{":
! 1251: token = self.token()
! 1252: token = self.parseTypeBlock(token)
! 1253: elif token[0] == "sep" and token[1] == "}":
! 1254: token = self.token()
! 1255: return token
! 1256: else:
! 1257: token = self.token()
! 1258: return token
! 1259:
! 1260: #
! 1261: # Parse a type: the fact that the type name can either occur after
! 1262: # the definition or within the definition makes it a little harder
! 1263: # if inside, the name token is pushed back before returning
! 1264: #
! 1265: def parseType(self, token):
! 1266: self.type = ""
! 1267: self.struct_fields = []
! 1268: self.signature = None
! 1269: if token == None:
! 1270: return token
! 1271:
! 1272: while token[0] == "name" and (
! 1273: token[1] == "const" or \
! 1274: token[1] == "unsigned" or \
! 1275: token[1] == "signed"):
! 1276: if self.type == "":
! 1277: self.type = token[1]
! 1278: else:
! 1279: self.type = self.type + " " + token[1]
! 1280: token = self.token()
! 1281:
! 1282: if token[0] == "name" and (token[1] == "long" or token[1] == "short"):
! 1283: if self.type == "":
! 1284: self.type = token[1]
! 1285: else:
! 1286: self.type = self.type + " " + token[1]
! 1287: if token[0] == "name" and token[1] == "int":
! 1288: if self.type == "":
! 1289: self.type = tmp[1]
! 1290: else:
! 1291: self.type = self.type + " " + tmp[1]
! 1292:
! 1293: elif token[0] == "name" and token[1] == "struct":
! 1294: if self.type == "":
! 1295: self.type = token[1]
! 1296: else:
! 1297: self.type = self.type + " " + token[1]
! 1298: token = self.token()
! 1299: nametok = None
! 1300: if token[0] == "name":
! 1301: nametok = token
! 1302: token = self.token()
! 1303: if token != None and token[0] == "sep" and token[1] == "{":
! 1304: token = self.token()
! 1305: token = self.parseStruct(token)
! 1306: elif token != None and token[0] == "op" and token[1] == "*":
! 1307: self.type = self.type + " " + nametok[1] + " *"
! 1308: token = self.token()
! 1309: while token != None and token[0] == "op" and token[1] == "*":
! 1310: self.type = self.type + " *"
! 1311: token = self.token()
! 1312: if token[0] == "name":
! 1313: nametok = token
! 1314: token = self.token()
! 1315: else:
! 1316: self.error("struct : expecting name", token)
! 1317: return token
! 1318: elif token != None and token[0] == "name" and nametok != None:
! 1319: self.type = self.type + " " + nametok[1]
! 1320: return token
! 1321:
! 1322: if nametok != None:
! 1323: self.lexer.push(token)
! 1324: token = nametok
! 1325: return token
! 1326:
! 1327: elif token[0] == "name" and token[1] == "enum":
! 1328: if self.type == "":
! 1329: self.type = token[1]
! 1330: else:
! 1331: self.type = self.type + " " + token[1]
! 1332: self.enums = []
! 1333: token = self.token()
! 1334: if token != None and token[0] == "sep" and token[1] == "{":
! 1335: token = self.token()
! 1336: token = self.parseEnumBlock(token)
! 1337: else:
! 1338: self.error("parsing enum: expecting '{'", token)
! 1339: enum_type = None
! 1340: if token != None and token[0] != "name":
! 1341: self.lexer.push(token)
! 1342: token = ("name", "enum")
! 1343: else:
! 1344: enum_type = token[1]
! 1345: for enum in self.enums:
! 1346: self.index_add(enum[0], self.filename,
! 1347: not self.is_header, "enum",
! 1348: (enum[1], enum[2], enum_type))
! 1349: return token
! 1350:
! 1351: elif token[0] == "name":
! 1352: if self.type == "":
! 1353: self.type = token[1]
! 1354: else:
! 1355: self.type = self.type + " " + token[1]
! 1356: else:
! 1357: self.error("parsing type %s: expecting a name" % (self.type),
! 1358: token)
! 1359: return token
! 1360: token = self.token()
! 1361: while token != None and (token[0] == "op" or
! 1362: token[0] == "name" and token[1] == "const"):
! 1363: self.type = self.type + " " + token[1]
! 1364: token = self.token()
! 1365:
! 1366: #
! 1367: # if there is a parenthesis here, this means a function type
! 1368: #
! 1369: if token != None and token[0] == "sep" and token[1] == '(':
! 1370: self.type = self.type + token[1]
! 1371: token = self.token()
! 1372: while token != None and token[0] == "op" and token[1] == '*':
! 1373: self.type = self.type + token[1]
! 1374: token = self.token()
! 1375: if token == None or token[0] != "name" :
! 1376: self.error("parsing function type, name expected", token);
! 1377: return token
! 1378: self.type = self.type + token[1]
! 1379: nametok = token
! 1380: token = self.token()
! 1381: if token != None and token[0] == "sep" and token[1] == ')':
! 1382: self.type = self.type + token[1]
! 1383: token = self.token()
! 1384: if token != None and token[0] == "sep" and token[1] == '(':
! 1385: token = self.token()
! 1386: type = self.type;
! 1387: token = self.parseSignature(token);
! 1388: self.type = type;
! 1389: else:
! 1390: self.error("parsing function type, '(' expected", token);
! 1391: return token
! 1392: else:
! 1393: self.error("parsing function type, ')' expected", token);
! 1394: return token
! 1395: self.lexer.push(token)
! 1396: token = nametok
! 1397: return token
! 1398:
! 1399: #
! 1400: # do some lookahead for arrays
! 1401: #
! 1402: if token != None and token[0] == "name":
! 1403: nametok = token
! 1404: token = self.token()
! 1405: if token != None and token[0] == "sep" and token[1] == '[':
! 1406: self.type = self.type + nametok[1]
! 1407: while token != None and token[0] == "sep" and token[1] == '[':
! 1408: self.type = self.type + token[1]
! 1409: token = self.token()
! 1410: while token != None and token[0] != 'sep' and \
! 1411: token[1] != ']' and token[1] != ';':
! 1412: self.type = self.type + token[1]
! 1413: token = self.token()
! 1414: if token != None and token[0] == 'sep' and token[1] == ']':
! 1415: self.type = self.type + token[1]
! 1416: token = self.token()
! 1417: else:
! 1418: self.error("parsing array type, ']' expected", token);
! 1419: return token
! 1420: elif token != None and token[0] == "sep" and token[1] == ':':
! 1421: # remove :12 in case it's a limited int size
! 1422: token = self.token()
! 1423: token = self.token()
! 1424: self.lexer.push(token)
! 1425: token = nametok
! 1426:
! 1427: return token
! 1428:
! 1429: #
! 1430: # Parse a signature: '(' has been parsed and we scan the type definition
! 1431: # up to the ')' included
! 1432: def parseSignature(self, token):
! 1433: signature = []
! 1434: if token != None and token[0] == "sep" and token[1] == ')':
! 1435: self.signature = []
! 1436: token = self.token()
! 1437: return token
! 1438: while token != None:
! 1439: token = self.parseType(token)
! 1440: if token != None and token[0] == "name":
! 1441: signature.append((self.type, token[1], None))
! 1442: token = self.token()
! 1443: elif token != None and token[0] == "sep" and token[1] == ',':
! 1444: token = self.token()
! 1445: continue
! 1446: elif token != None and token[0] == "sep" and token[1] == ')':
! 1447: # only the type was provided
! 1448: if self.type == "...":
! 1449: signature.append((self.type, "...", None))
! 1450: else:
! 1451: signature.append((self.type, None, None))
! 1452: if token != None and token[0] == "sep":
! 1453: if token[1] == ',':
! 1454: token = self.token()
! 1455: continue
! 1456: elif token[1] == ')':
! 1457: token = self.token()
! 1458: break
! 1459: self.signature = signature
! 1460: return token
! 1461:
! 1462: #
! 1463: # Parse a global definition, be it a type, variable or function
! 1464: # the extern "C" blocks are a bit nasty and require it to recurse.
! 1465: #
! 1466: def parseGlobal(self, token):
! 1467: static = 0
! 1468: if token[1] == 'extern':
! 1469: token = self.token()
! 1470: if token == None:
! 1471: return token
! 1472: if token[0] == 'string':
! 1473: if token[1] == 'C':
! 1474: token = self.token()
! 1475: if token == None:
! 1476: return token
! 1477: if token[0] == 'sep' and token[1] == "{":
! 1478: token = self.token()
! 1479: # print 'Entering extern "C line ', self.lineno()
! 1480: while token != None and (token[0] != 'sep' or
! 1481: token[1] != "}"):
! 1482: if token[0] == 'name':
! 1483: token = self.parseGlobal(token)
! 1484: else:
! 1485: self.error(
! 1486: "token %s %s unexpected at the top level" % (
! 1487: token[0], token[1]))
! 1488: token = self.parseGlobal(token)
! 1489: # print 'Exiting extern "C" line', self.lineno()
! 1490: token = self.token()
! 1491: return token
! 1492: else:
! 1493: return token
! 1494: elif token[1] == 'static':
! 1495: static = 1
! 1496: token = self.token()
! 1497: if token == None or token[0] != 'name':
! 1498: return token
! 1499:
! 1500: if token[1] == 'typedef':
! 1501: token = self.token()
! 1502: return self.parseTypedef(token)
! 1503: else:
! 1504: token = self.parseType(token)
! 1505: type_orig = self.type
! 1506: if token == None or token[0] != "name":
! 1507: return token
! 1508: type = type_orig
! 1509: self.name = token[1]
! 1510: token = self.token()
! 1511: while token != None and (token[0] == "sep" or token[0] == "op"):
! 1512: if token[0] == "sep":
! 1513: if token[1] == "[":
! 1514: type = type + token[1]
! 1515: token = self.token()
! 1516: while token != None and (token[0] != "sep" or \
! 1517: token[1] != ";"):
! 1518: type = type + token[1]
! 1519: token = self.token()
! 1520:
! 1521: if token != None and token[0] == "op" and token[1] == "=":
! 1522: #
! 1523: # Skip the initialization of the variable
! 1524: #
! 1525: token = self.token()
! 1526: if token[0] == 'sep' and token[1] == '{':
! 1527: token = self.token()
! 1528: token = self.parseBlock(token)
! 1529: else:
! 1530: self.comment = None
! 1531: while token != None and (token[0] != "sep" or \
! 1532: (token[1] != ';' and token[1] != ',')):
! 1533: token = self.token()
! 1534: self.comment = None
! 1535: if token == None or token[0] != "sep" or (token[1] != ';' and
! 1536: token[1] != ','):
! 1537: self.error("missing ';' or ',' after value")
! 1538:
! 1539: if token != None and token[0] == "sep":
! 1540: if token[1] == ";":
! 1541: self.comment = None
! 1542: token = self.token()
! 1543: if type == "struct":
! 1544: self.index_add(self.name, self.filename,
! 1545: not self.is_header, "struct", self.struct_fields)
! 1546: else:
! 1547: self.index_add(self.name, self.filename,
! 1548: not self.is_header, "variable", type)
! 1549: break
! 1550: elif token[1] == "(":
! 1551: token = self.token()
! 1552: token = self.parseSignature(token)
! 1553: if token == None:
! 1554: return None
! 1555: if token[0] == "sep" and token[1] == ";":
! 1556: d = self.mergeFunctionComment(self.name,
! 1557: ((type, None), self.signature), 1)
! 1558: self.index_add(self.name, self.filename, static,
! 1559: "function", d)
! 1560: token = self.token()
! 1561: elif token[0] == "sep" and token[1] == "{":
! 1562: d = self.mergeFunctionComment(self.name,
! 1563: ((type, None), self.signature), static)
! 1564: self.index_add(self.name, self.filename, static,
! 1565: "function", d)
! 1566: token = self.token()
! 1567: token = self.parseBlock(token);
! 1568: elif token[1] == ',':
! 1569: self.comment = None
! 1570: self.index_add(self.name, self.filename, static,
! 1571: "variable", type)
! 1572: type = type_orig
! 1573: token = self.token()
! 1574: while token != None and token[0] == "sep":
! 1575: type = type + token[1]
! 1576: token = self.token()
! 1577: if token != None and token[0] == "name":
! 1578: self.name = token[1]
! 1579: token = self.token()
! 1580: else:
! 1581: break
! 1582:
! 1583: return token
! 1584:
! 1585: def parse(self):
! 1586: self.warning("Parsing %s" % (self.filename))
! 1587: token = self.token()
! 1588: while token != None:
! 1589: if token[0] == 'name':
! 1590: token = self.parseGlobal(token)
! 1591: else:
! 1592: self.error("token %s %s unexpected at the top level" % (
! 1593: token[0], token[1]))
! 1594: token = self.parseGlobal(token)
! 1595: return
! 1596: self.parseTopComment(self.top_comment)
! 1597: return self.index
! 1598:
! 1599:
! 1600: class docBuilder:
! 1601: """A documentation builder"""
! 1602: def __init__(self, name, directories=['.'], excludes=[]):
! 1603: self.name = name
! 1604: self.directories = directories
! 1605: self.excludes = excludes + ignored_files.keys()
! 1606: self.modules = {}
! 1607: self.headers = {}
! 1608: self.idx = index()
! 1609: self.xref = {}
! 1610: self.index = {}
! 1611: if name == 'libxml2':
! 1612: self.basename = 'libxml'
! 1613: else:
! 1614: self.basename = name
! 1615:
! 1616: def indexString(self, id, str):
! 1617: if str == None:
! 1618: return
! 1619: str = string.replace(str, "'", ' ')
! 1620: str = string.replace(str, '"', ' ')
! 1621: str = string.replace(str, "/", ' ')
! 1622: str = string.replace(str, '*', ' ')
! 1623: str = string.replace(str, "[", ' ')
! 1624: str = string.replace(str, "]", ' ')
! 1625: str = string.replace(str, "(", ' ')
! 1626: str = string.replace(str, ")", ' ')
! 1627: str = string.replace(str, "<", ' ')
! 1628: str = string.replace(str, '>', ' ')
! 1629: str = string.replace(str, "&", ' ')
! 1630: str = string.replace(str, '#', ' ')
! 1631: str = string.replace(str, ",", ' ')
! 1632: str = string.replace(str, '.', ' ')
! 1633: str = string.replace(str, ';', ' ')
! 1634: tokens = string.split(str)
! 1635: for token in tokens:
! 1636: try:
! 1637: c = token[0]
! 1638: if string.find(string.letters, c) < 0:
! 1639: pass
! 1640: elif len(token) < 3:
! 1641: pass
! 1642: else:
! 1643: lower = string.lower(token)
! 1644: # TODO: generalize this a bit
! 1645: if lower == 'and' or lower == 'the':
! 1646: pass
! 1647: elif self.xref.has_key(token):
! 1648: self.xref[token].append(id)
! 1649: else:
! 1650: self.xref[token] = [id]
! 1651: except:
! 1652: pass
! 1653:
! 1654: def analyze(self):
! 1655: print "Project %s : %d headers, %d modules" % (self.name, len(self.headers.keys()), len(self.modules.keys()))
! 1656: self.idx.analyze()
! 1657:
! 1658: def scanHeaders(self):
! 1659: for header in self.headers.keys():
! 1660: parser = CParser(header)
! 1661: idx = parser.parse()
! 1662: self.headers[header] = idx;
! 1663: self.idx.merge(idx)
! 1664:
! 1665: def scanModules(self):
! 1666: for module in self.modules.keys():
! 1667: parser = CParser(module)
! 1668: idx = parser.parse()
! 1669: # idx.analyze()
! 1670: self.modules[module] = idx
! 1671: self.idx.merge_public(idx)
! 1672:
! 1673: def scan(self):
! 1674: for directory in self.directories:
! 1675: files = glob.glob(directory + "/*.c")
! 1676: for file in files:
! 1677: skip = 0
! 1678: for excl in self.excludes:
! 1679: if string.find(file, excl) != -1:
! 1680: skip = 1;
! 1681: break
! 1682: if skip == 0:
! 1683: self.modules[file] = None;
! 1684: files = glob.glob(directory + "/*.h")
! 1685: for file in files:
! 1686: skip = 0
! 1687: for excl in self.excludes:
! 1688: if string.find(file, excl) != -1:
! 1689: skip = 1;
! 1690: break
! 1691: if skip == 0:
! 1692: self.headers[file] = None;
! 1693: self.scanHeaders()
! 1694: self.scanModules()
! 1695:
! 1696: def modulename_file(self, file):
! 1697: module = os.path.basename(file)
! 1698: if module[-2:] == '.h':
! 1699: module = module[:-2]
! 1700: elif module[-2:] == '.c':
! 1701: module = module[:-2]
! 1702: return module
! 1703:
! 1704: def serialize_enum(self, output, name):
! 1705: id = self.idx.enums[name]
! 1706: output.write(" <enum name='%s' file='%s'" % (name,
! 1707: self.modulename_file(id.header)))
! 1708: if id.info != None:
! 1709: info = id.info
! 1710: if info[0] != None and info[0] != '':
! 1711: try:
! 1712: val = eval(info[0])
! 1713: except:
! 1714: val = info[0]
! 1715: output.write(" value='%s'" % (val));
! 1716: if info[2] != None and info[2] != '':
! 1717: output.write(" type='%s'" % info[2]);
! 1718: if info[1] != None and info[1] != '':
! 1719: output.write(" info='%s'" % escape(info[1]));
! 1720: output.write("/>\n")
! 1721:
! 1722: def serialize_macro(self, output, name):
! 1723: id = self.idx.macros[name]
! 1724: output.write(" <macro name='%s' file='%s'>\n" % (name,
! 1725: self.modulename_file(id.header)))
! 1726: if id.info != None:
! 1727: try:
! 1728: (args, desc) = id.info
! 1729: if desc != None and desc != "":
! 1730: output.write(" <info>%s</info>\n" % (escape(desc)))
! 1731: self.indexString(name, desc)
! 1732: for arg in args:
! 1733: (name, desc) = arg
! 1734: if desc != None and desc != "":
! 1735: output.write(" <arg name='%s' info='%s'/>\n" % (
! 1736: name, escape(desc)))
! 1737: self.indexString(name, desc)
! 1738: else:
! 1739: output.write(" <arg name='%s'/>\n" % (name))
! 1740: except:
! 1741: pass
! 1742: output.write(" </macro>\n")
! 1743:
! 1744: def serialize_typedef(self, output, name):
! 1745: id = self.idx.typedefs[name]
! 1746: if id.info[0:7] == 'struct ':
! 1747: output.write(" <struct name='%s' file='%s' type='%s'" % (
! 1748: name, self.modulename_file(id.header), id.info))
! 1749: name = id.info[7:]
! 1750: if self.idx.structs.has_key(name) and ( \
! 1751: type(self.idx.structs[name].info) == type(()) or
! 1752: type(self.idx.structs[name].info) == type([])):
! 1753: output.write(">\n");
! 1754: try:
! 1755: for field in self.idx.structs[name].info:
! 1756: desc = field[2]
! 1757: self.indexString(name, desc)
! 1758: if desc == None:
! 1759: desc = ''
! 1760: else:
! 1761: desc = escape(desc)
! 1762: output.write(" <field name='%s' type='%s' info='%s'/>\n" % (field[1] , field[0], desc))
! 1763: except:
! 1764: print "Failed to serialize struct %s" % (name)
! 1765: output.write(" </struct>\n")
! 1766: else:
! 1767: output.write("/>\n");
! 1768: else :
! 1769: output.write(" <typedef name='%s' file='%s' type='%s'" % (
! 1770: name, self.modulename_file(id.header), id.info))
! 1771: try:
! 1772: desc = id.extra
! 1773: if desc != None and desc != "":
! 1774: output.write(">\n <info>%s</info>\n" % (escape(desc)))
! 1775: output.write(" </typedef>\n")
! 1776: else:
! 1777: output.write("/>\n")
! 1778: except:
! 1779: output.write("/>\n")
! 1780:
! 1781: def serialize_variable(self, output, name):
! 1782: id = self.idx.variables[name]
! 1783: if id.info != None:
! 1784: output.write(" <variable name='%s' file='%s' type='%s'/>\n" % (
! 1785: name, self.modulename_file(id.header), id.info))
! 1786: else:
! 1787: output.write(" <variable name='%s' file='%s'/>\n" % (
! 1788: name, self.modulename_file(id.header)))
! 1789:
! 1790: def serialize_function(self, output, name):
! 1791: id = self.idx.functions[name]
! 1792: if name == debugsym:
! 1793: print "=>", id
! 1794:
! 1795: output.write(" <%s name='%s' file='%s' module='%s'>\n" % (id.type,
! 1796: name, self.modulename_file(id.header),
! 1797: self.modulename_file(id.module)))
! 1798: #
! 1799: # Processing of conditionals modified by Bill 1/1/05
! 1800: #
! 1801: if id.conditionals != None:
! 1802: apstr = ""
! 1803: for cond in id.conditionals:
! 1804: if apstr != "":
! 1805: apstr = apstr + " && "
! 1806: apstr = apstr + cond
! 1807: output.write(" <cond>%s</cond>\n"% (apstr));
! 1808: try:
! 1809: (ret, params, desc) = id.info
! 1810: if (desc == None or desc == '') and \
! 1811: name[0:9] != "xmlThrDef" and name != "xmlDllMain":
! 1812: print "%s %s from %s has no description" % (id.type, name,
! 1813: self.modulename_file(id.module))
! 1814:
! 1815: output.write(" <info>%s</info>\n" % (escape(desc)))
! 1816: self.indexString(name, desc)
! 1817: if ret[0] != None:
! 1818: if ret[0] == "void":
! 1819: output.write(" <return type='void'/>\n")
! 1820: else:
! 1821: output.write(" <return type='%s' info='%s'/>\n" % (
! 1822: ret[0], escape(ret[1])))
! 1823: self.indexString(name, ret[1])
! 1824: for param in params:
! 1825: if param[0] == 'void':
! 1826: continue
! 1827: if param[2] == None:
! 1828: output.write(" <arg name='%s' type='%s' info=''/>\n" % (param[1], param[0]))
! 1829: else:
! 1830: output.write(" <arg name='%s' type='%s' info='%s'/>\n" % (param[1], param[0], escape(param[2])))
! 1831: self.indexString(name, param[2])
! 1832: except:
! 1833: print "Failed to save function %s info: " % name, `id.info`
! 1834: output.write(" </%s>\n" % (id.type))
! 1835:
! 1836: def serialize_exports(self, output, file):
! 1837: module = self.modulename_file(file)
! 1838: output.write(" <file name='%s'>\n" % (module))
! 1839: dict = self.headers[file]
! 1840: if dict.info != None:
! 1841: for data in ('Summary', 'Description', 'Author'):
! 1842: try:
! 1843: output.write(" <%s>%s</%s>\n" % (
! 1844: string.lower(data),
! 1845: escape(dict.info[data]),
! 1846: string.lower(data)))
! 1847: except:
! 1848: print "Header %s lacks a %s description" % (module, data)
! 1849: if dict.info.has_key('Description'):
! 1850: desc = dict.info['Description']
! 1851: if string.find(desc, "DEPRECATED") != -1:
! 1852: output.write(" <deprecated/>\n")
! 1853:
! 1854: ids = dict.macros.keys()
! 1855: ids.sort()
! 1856: for id in uniq(ids):
! 1857: # Macros are sometime used to masquerade other types.
! 1858: if dict.functions.has_key(id):
! 1859: continue
! 1860: if dict.variables.has_key(id):
! 1861: continue
! 1862: if dict.typedefs.has_key(id):
! 1863: continue
! 1864: if dict.structs.has_key(id):
! 1865: continue
! 1866: if dict.enums.has_key(id):
! 1867: continue
! 1868: output.write(" <exports symbol='%s' type='macro'/>\n" % (id))
! 1869: ids = dict.enums.keys()
! 1870: ids.sort()
! 1871: for id in uniq(ids):
! 1872: output.write(" <exports symbol='%s' type='enum'/>\n" % (id))
! 1873: ids = dict.typedefs.keys()
! 1874: ids.sort()
! 1875: for id in uniq(ids):
! 1876: output.write(" <exports symbol='%s' type='typedef'/>\n" % (id))
! 1877: ids = dict.structs.keys()
! 1878: ids.sort()
! 1879: for id in uniq(ids):
! 1880: output.write(" <exports symbol='%s' type='struct'/>\n" % (id))
! 1881: ids = dict.variables.keys()
! 1882: ids.sort()
! 1883: for id in uniq(ids):
! 1884: output.write(" <exports symbol='%s' type='variable'/>\n" % (id))
! 1885: ids = dict.functions.keys()
! 1886: ids.sort()
! 1887: for id in uniq(ids):
! 1888: output.write(" <exports symbol='%s' type='function'/>\n" % (id))
! 1889: output.write(" </file>\n")
! 1890:
! 1891: def serialize_xrefs_files(self, output):
! 1892: headers = self.headers.keys()
! 1893: headers.sort()
! 1894: for file in headers:
! 1895: module = self.modulename_file(file)
! 1896: output.write(" <file name='%s'>\n" % (module))
! 1897: dict = self.headers[file]
! 1898: ids = uniq(dict.functions.keys() + dict.variables.keys() + \
! 1899: dict.macros.keys() + dict.typedefs.keys() + \
! 1900: dict.structs.keys() + dict.enums.keys())
! 1901: ids.sort()
! 1902: for id in ids:
! 1903: output.write(" <ref name='%s'/>\n" % (id))
! 1904: output.write(" </file>\n")
! 1905: pass
! 1906:
! 1907: def serialize_xrefs_functions(self, output):
! 1908: funcs = {}
! 1909: for name in self.idx.functions.keys():
! 1910: id = self.idx.functions[name]
! 1911: try:
! 1912: (ret, params, desc) = id.info
! 1913: for param in params:
! 1914: if param[0] == 'void':
! 1915: continue
! 1916: if funcs.has_key(param[0]):
! 1917: funcs[param[0]].append(name)
! 1918: else:
! 1919: funcs[param[0]] = [name]
! 1920: except:
! 1921: pass
! 1922: typ = funcs.keys()
! 1923: typ.sort()
! 1924: for type in typ:
! 1925: if type == '' or type == 'void' or type == "int" or \
! 1926: type == "char *" or type == "const char *" :
! 1927: continue
! 1928: output.write(" <type name='%s'>\n" % (type))
! 1929: ids = funcs[type]
! 1930: ids.sort()
! 1931: pid = '' # not sure why we have dups, but get rid of them!
! 1932: for id in ids:
! 1933: if id != pid:
! 1934: output.write(" <ref name='%s'/>\n" % (id))
! 1935: pid = id
! 1936: output.write(" </type>\n")
! 1937:
! 1938: def serialize_xrefs_constructors(self, output):
! 1939: funcs = {}
! 1940: for name in self.idx.functions.keys():
! 1941: id = self.idx.functions[name]
! 1942: try:
! 1943: (ret, params, desc) = id.info
! 1944: if ret[0] == "void":
! 1945: continue
! 1946: if funcs.has_key(ret[0]):
! 1947: funcs[ret[0]].append(name)
! 1948: else:
! 1949: funcs[ret[0]] = [name]
! 1950: except:
! 1951: pass
! 1952: typ = funcs.keys()
! 1953: typ.sort()
! 1954: for type in typ:
! 1955: if type == '' or type == 'void' or type == "int" or \
! 1956: type == "char *" or type == "const char *" :
! 1957: continue
! 1958: output.write(" <type name='%s'>\n" % (type))
! 1959: ids = funcs[type]
! 1960: ids.sort()
! 1961: for id in ids:
! 1962: output.write(" <ref name='%s'/>\n" % (id))
! 1963: output.write(" </type>\n")
! 1964:
! 1965: def serialize_xrefs_alpha(self, output):
! 1966: letter = None
! 1967: ids = self.idx.identifiers.keys()
! 1968: ids.sort()
! 1969: for id in ids:
! 1970: if id[0] != letter:
! 1971: if letter != None:
! 1972: output.write(" </letter>\n")
! 1973: letter = id[0]
! 1974: output.write(" <letter name='%s'>\n" % (letter))
! 1975: output.write(" <ref name='%s'/>\n" % (id))
! 1976: if letter != None:
! 1977: output.write(" </letter>\n")
! 1978:
! 1979: def serialize_xrefs_references(self, output):
! 1980: typ = self.idx.identifiers.keys()
! 1981: typ.sort()
! 1982: for id in typ:
! 1983: idf = self.idx.identifiers[id]
! 1984: module = idf.header
! 1985: output.write(" <reference name='%s' href='%s'/>\n" % (id,
! 1986: 'html/' + self.basename + '-' +
! 1987: self.modulename_file(module) + '.html#' +
! 1988: id))
! 1989:
! 1990: def serialize_xrefs_index(self, output):
! 1991: index = self.xref
! 1992: typ = index.keys()
! 1993: typ.sort()
! 1994: letter = None
! 1995: count = 0
! 1996: chunk = 0
! 1997: chunks = []
! 1998: for id in typ:
! 1999: if len(index[id]) > 30:
! 2000: continue
! 2001: if id[0] != letter:
! 2002: if letter == None or count > 200:
! 2003: if letter != None:
! 2004: output.write(" </letter>\n")
! 2005: output.write(" </chunk>\n")
! 2006: count = 0
! 2007: chunks.append(["chunk%s" % (chunk -1), first_letter, letter])
! 2008: output.write(" <chunk name='chunk%s'>\n" % (chunk))
! 2009: first_letter = id[0]
! 2010: chunk = chunk + 1
! 2011: elif letter != None:
! 2012: output.write(" </letter>\n")
! 2013: letter = id[0]
! 2014: output.write(" <letter name='%s'>\n" % (letter))
! 2015: output.write(" <word name='%s'>\n" % (id))
! 2016: tokens = index[id];
! 2017: tokens.sort()
! 2018: tok = None
! 2019: for token in tokens:
! 2020: if tok == token:
! 2021: continue
! 2022: tok = token
! 2023: output.write(" <ref name='%s'/>\n" % (token))
! 2024: count = count + 1
! 2025: output.write(" </word>\n")
! 2026: if letter != None:
! 2027: output.write(" </letter>\n")
! 2028: output.write(" </chunk>\n")
! 2029: if count != 0:
! 2030: chunks.append(["chunk%s" % (chunk -1), first_letter, letter])
! 2031: output.write(" <chunks>\n")
! 2032: for ch in chunks:
! 2033: output.write(" <chunk name='%s' start='%s' end='%s'/>\n" % (
! 2034: ch[0], ch[1], ch[2]))
! 2035: output.write(" </chunks>\n")
! 2036:
! 2037: def serialize_xrefs(self, output):
! 2038: output.write(" <references>\n")
! 2039: self.serialize_xrefs_references(output)
! 2040: output.write(" </references>\n")
! 2041: output.write(" <alpha>\n")
! 2042: self.serialize_xrefs_alpha(output)
! 2043: output.write(" </alpha>\n")
! 2044: output.write(" <constructors>\n")
! 2045: self.serialize_xrefs_constructors(output)
! 2046: output.write(" </constructors>\n")
! 2047: output.write(" <functions>\n")
! 2048: self.serialize_xrefs_functions(output)
! 2049: output.write(" </functions>\n")
! 2050: output.write(" <files>\n")
! 2051: self.serialize_xrefs_files(output)
! 2052: output.write(" </files>\n")
! 2053: output.write(" <index>\n")
! 2054: self.serialize_xrefs_index(output)
! 2055: output.write(" </index>\n")
! 2056:
! 2057: def serialize(self):
! 2058: filename = "%s-api.xml" % self.name
! 2059: print "Saving XML description %s" % (filename)
! 2060: output = open(filename, "w")
! 2061: output.write('<?xml version="1.0" encoding="ISO-8859-1"?>\n')
! 2062: output.write("<api name='%s'>\n" % self.name)
! 2063: output.write(" <files>\n")
! 2064: headers = self.headers.keys()
! 2065: headers.sort()
! 2066: for file in headers:
! 2067: self.serialize_exports(output, file)
! 2068: output.write(" </files>\n")
! 2069: output.write(" <symbols>\n")
! 2070: macros = self.idx.macros.keys()
! 2071: macros.sort()
! 2072: for macro in macros:
! 2073: self.serialize_macro(output, macro)
! 2074: enums = self.idx.enums.keys()
! 2075: enums.sort()
! 2076: for enum in enums:
! 2077: self.serialize_enum(output, enum)
! 2078: typedefs = self.idx.typedefs.keys()
! 2079: typedefs.sort()
! 2080: for typedef in typedefs:
! 2081: self.serialize_typedef(output, typedef)
! 2082: variables = self.idx.variables.keys()
! 2083: variables.sort()
! 2084: for variable in variables:
! 2085: self.serialize_variable(output, variable)
! 2086: functions = self.idx.functions.keys()
! 2087: functions.sort()
! 2088: for function in functions:
! 2089: self.serialize_function(output, function)
! 2090: output.write(" </symbols>\n")
! 2091: output.write("</api>\n")
! 2092: output.close()
! 2093:
! 2094: filename = "%s-refs.xml" % self.name
! 2095: print "Saving XML Cross References %s" % (filename)
! 2096: output = open(filename, "w")
! 2097: output.write('<?xml version="1.0" encoding="ISO-8859-1"?>\n')
! 2098: output.write("<apirefs name='%s'>\n" % self.name)
! 2099: self.serialize_xrefs(output)
! 2100: output.write("</apirefs>\n")
! 2101: output.close()
! 2102:
! 2103:
! 2104: def rebuild():
! 2105: builder = None
! 2106: if glob.glob("parser.c") != [] :
! 2107: print "Rebuilding API description for libxml2"
! 2108: builder = docBuilder("libxml2", [".", "."],
! 2109: ["xmlwin32version.h", "tst.c"])
! 2110: elif glob.glob("../parser.c") != [] :
! 2111: print "Rebuilding API description for libxml2"
! 2112: builder = docBuilder("libxml2", ["..", "../include/libxml"],
! 2113: ["xmlwin32version.h", "tst.c"])
! 2114: elif glob.glob("../libxslt/transform.c") != [] :
! 2115: print "Rebuilding API description for libxslt"
! 2116: builder = docBuilder("libxslt", ["../libxslt"],
! 2117: ["win32config.h", "libxslt.h", "tst.c"])
! 2118: else:
! 2119: print "rebuild() failed, unable to guess the module"
! 2120: return None
! 2121: builder.scan()
! 2122: builder.analyze()
! 2123: builder.serialize()
! 2124: if glob.glob("../libexslt/exslt.c") != [] :
! 2125: extra = docBuilder("libexslt", ["../libexslt"], ["libexslt.h"])
! 2126: extra.scan()
! 2127: extra.analyze()
! 2128: extra.serialize()
! 2129: return builder
! 2130:
! 2131: #
! 2132: # for debugging the parser
! 2133: #
! 2134: def parse(filename):
! 2135: parser = CParser(filename)
! 2136: idx = parser.parse()
! 2137: return idx
! 2138:
! 2139: if __name__ == "__main__":
! 2140: if len(sys.argv) > 1:
! 2141: debug = 1
! 2142: parse(sys.argv[1])
! 2143: else:
! 2144: rebuild()
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to apibuild.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / doc