[libvirt] [PATCH] maint: Expand tabs in python code

Also cfg.mk is tweaked to force this for all future changes to *.py files. --- cfg.mk | 4 +- docs/apibuild.py | 3194 ++++++++++++++++++++++++------------------------ docs/index.py | 834 +++++++------- python/generator.py | 578 +++++----- python/tests/create.py | 8 +- 5 files changed, 2309 insertions(+), 2309 deletions(-) diff --git a/cfg.mk b/cfg.mk index 4bbeb96..f870723 100644 --- a/cfg.mk +++ b/cfg.mk @@ -327,8 +327,8 @@ sc_prohibit_ctype_h: # files in gnulib, since they're imported. sc_TAB_in_indentation: @prohibit='^ * ' \ - in_vc_files='(\.(rng|[ch](\.in)?|html.in)|(daemon|tools)/.*\.in)$$' \ - halt='use leading spaces, not TAB, in C, sh, html, and RNG schemas' \ + in_vc_files='(\.(rng|[ch](\.in)?|html.in|py)|(daemon|tools)/.*\.in)$$' \ + halt='use leading spaces, not TAB, in C, sh, html, py, and RNG schemas' \ $(_sc_search_regexp) ctype_re = isalnum|isalpha|isascii|isblank|iscntrl|isdigit|isgraph|islower\ diff --git a/docs/apibuild.py b/docs/apibuild.py index 895a313..506932d 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -72,34 +72,34 @@ 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)) + 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 + " " + `self.info` - if self.extra != None: - r = r + " " + `self.extra` - if self.conditionals != None: - r = r + " " + `self.conditionals` - return r + if self.static: + r = r + " static" + if self.module != None: + r = r + " from %s" % (self.module) + if self.info != None: + r = r + " " + `self.info` + if self.extra != None: + r = r + " " + `self.extra` + if self.conditionals != None: + r = r + " " + `self.conditionals` + return r def set_header(self, header): @@ -117,10 +117,10 @@ class identifier: 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[:] + if conditionals == None or len(conditionals) == 0: + self.conditionals = None + else: + self.conditionals = conditionals[:] def get_name(self): return self.name @@ -143,96 +143,96 @@ class identifier: 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 self.name == debugsym: + print "=> update %s : %s" % (debugsym, (module, type, info, + extra, conditionals)) if header != None and self.header == None: - self.set_header(module) + self.set_header(module) if module != None and (self.module == None or self.header == self.module): - self.set_module(module) + self.set_module(module) if type != None and self.type == None: - self.set_type(type) + self.set_type(type) if info != None: - self.set_info(info) + self.set_info(info) if extra != None: - self.set_extra(extra) + self.set_extra(extra) if conditionals != None: - self.set_conditionals(conditionals) + 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 = {} + 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 + 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 + 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 static == 1: + d.set_static(1) - if d != None and name != None and type != None: - self.references[name] = d + if d != None and name != None and type != None: + self.references[name] = d - if name == debugsym: - print "New ref: %s" % (d) + if name == debugsym: + print "New ref: %s" % (d) - return d + return d def add(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None): if name[0:2] == '__': - return None + 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 + 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 idx.functions.keys(): @@ -240,41 +240,41 @@ class index: # macro might be used to override functions or variables # definitions # - if self.macros.has_key(id): - del self.macros[id] - if self.functions.has_key(id): - 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] + if self.macros.has_key(id): + del self.macros[id] + if self.functions.has_key(id): + 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 idx.variables.keys(): # # macro might be used to override functions or variables # definitions # - if self.macros.has_key(id): - del self.macros[id] - if self.variables.has_key(id): - 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] + if self.macros.has_key(id): + del self.macros[id] + if self.variables.has_key(id): + 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 idx.structs.keys(): - if self.structs.has_key(id): - 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] + if self.structs.has_key(id): + 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 idx.typedefs.keys(): - if self.typedefs.has_key(id): - 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] + if self.typedefs.has_key(id): + 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 idx.macros.keys(): # # macro might be used to override functions or variables @@ -286,88 +286,88 @@ class index: continue if self.enums.has_key(id): continue - if self.macros.has_key(id): - 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] + if self.macros.has_key(id): + 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 idx.enums.keys(): - if self.enums.has_key(id): - 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] + if self.enums.has_key(id): + 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 idx.functions.keys(): - if self.functions.has_key(id): - # 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. + if self.functions.has_key(id): + # 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 + public = 0 for name in dict.keys(): - id = dict[name] - count = count + 1 - if id.static == 0: - public = public + 1 + 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) + 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) + 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 + 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 = string.lstrip(line) - line = string.rstrip(line) - if line == '': - continue - while line[-1] == '\\': - line = line[:-1] - n = self.input.readline() - self.lineno = self.lineno + 1 - n = string.lstrip(n) - n = string.rstrip(n) - if not n: - break - else: - line = line + n + while line == '': + line = self.input.readline() + if not line: + return None + self.lineno = self.lineno + 1 + line = string.lstrip(line) + line = string.rstrip(line) + if line == '': + continue + while line[-1] == '\\': + line = line[:-1] + n = self.input.readline() + self.lineno = self.lineno + 1 + n = string.lstrip(n) + n = string.rstrip(n) + if not n: + break + else: + line = line + n return line def getlineno(self): @@ -378,193 +378,193 @@ class CLexer: def debug(self): print "Last token: ", self.last - print "Token queue: ", self.tokens - print "Line %d end: " % (self.lineno), self.line + 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 = map((lambda x: ('preproc', x)), - string.split(line)) - 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 string.find( - " \t(){}:;,+-*/%&!|[]=><", line[i]) == -1: - i = i + 1 - else: - break - self.tokens.append(('name', line[s:i])) - continue - if string.find("(){}:;,[]", line[i]) != -1: + if self.line == "": + line = self.getline() + else: + line = self.line + self.line = "" + if line == None: + return None + + if line[0] == '#': + self.tokens = map((lambda x: ('preproc', x)), + string.split(line)) + 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 string.find( + " \t(){}:;,+-*/%&!|[]=><", line[i]) == -1: + i = i + 1 + else: + break + self.tokens.append(('name', line[s:i])) + continue + if string.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 string.find("+-*><=/%&!|.", line[i]) != -1: +# 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 string.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 ( - string.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 ( - string.find(" \t(){}:;,+-*/%&!|[]=><", 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 +# 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 ( + string.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 ( + string.find(" \t(){}:;,+-*/%&!|[]=><", 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 + 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 = [] + 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 @@ -579,203 +579,203 @@ class CParser: 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) + 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) + 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 + return + print msg def error(self, msg, token=-1): if self.no_error: - return + return print "Parse Error: " + msg - if token != -1: - print "Got token ", token - self.lexer.debug() - sys.exit(1) + 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() + if token != -1: + print "Got token ", token + self.lexer.debug() def parseTopComment(self, comment): - res = {} - lines = string.split(comment, "\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) = string.split(line, ":", 1) - item = it - while line != "" and (line[0] == ' ' or line[0] == '\t'): - line = line[1:] - if res.has_key(item): - res[item] = res[item] + " " + line - else: - res[item] = line - except: - if item != None: - if res.has_key(item): - res[item] = res[item] + " " + line - else: - res[item] = line - self.index.info = res + res = {} + lines = string.split(comment, "\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) = string.split(line, ":", 1) + item = it + while line != "" and (line[0] == ' ' or line[0] == '\t'): + line = line[1:] + if res.has_key(item): + res[item] = res[item] + " " + line + else: + res[item] = line + except: + if item != None: + if res.has_key(item): + 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() + 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 string.find(self.comment, "DOC_DISABLE") != -1: - self.stop_error() + self.stop_error() if string.find(self.comment, "DOC_ENABLE") != -1: - self.start_error() + self.start_error() - return token + return token # # Parse a comment block associate to a typedef # def parseTypeComment(self, name, quiet = 0): if name[0:2] == '__': - quiet = 1 + quiet = 1 args = [] - desc = "" + desc = "" if self.comment == None: - if not quiet: - self.warning("Missing comment for type %s" % (name)) - return((args, desc)) + 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 = string.split(self.comment, '\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 = string.strip(l) - desc = desc + " " + l - del lines[0] - - desc = string.strip(desc) - - if quiet == 0: - if desc == "": - self.warning("Type comment for %s lack description of the macro" % (name)) - - return(desc) + if not quiet: + self.warning("Missing * in type comment for %s" % (name)) + return((args, desc)) + lines = string.split(self.comment, '\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 = string.strip(l) + desc = desc + " " + l + del lines[0] + + desc = string.strip(desc) + + 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 + quiet = 1 args = [] - desc = "" + desc = "" if self.comment == None: - if not quiet: - self.warning("Missing comment for macro %s" % (name)) - return((args, desc)) + 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 = string.split(self.comment, '\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) = string.split(l, ':', 1) - desc=string.strip(desc) - arg=string.strip(arg) + if not quiet: + self.warning("Missing * in macro comment for %s" % (name)) + return((args, desc)) + lines = string.split(self.comment, '\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) = string.split(l, ':', 1) + desc=string.strip(desc) + arg=string.strip(arg) 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 = string.strip(lines[0]) - while len(l) > 2 and l[0:3] != '* @': - while l[0] == '*': - l = l[1:] - desc = desc + ' ' + string.strip(l) - del lines[0] - if len(lines) == 0: - break - l = lines[0] + 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 = string.strip(lines[0]) + while len(l) > 2 and l[0:3] != '* @': + while l[0] == '*': + l = l[1:] + desc = desc + ' ' + string.strip(l) + 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 = string.strip(l) - desc = desc + " " + l - 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 = string.strip(l) + desc = desc + " " + l + del lines[0] - desc = string.strip(desc) + desc = string.strip(desc) - if quiet == 0: - if desc == "": - self.warning("Macro comment for %s lack description of the macro" % (name)) + if quiet == 0: + if desc == "": + self.warning("Macro comment for %s lack description of the macro" % (name)) - return((args, desc)) + return((args, desc)) # # Parse a comment block and merge the information found in the @@ -786,219 +786,219 @@ class CParser: global ignored_functions if name == 'main': - quiet = 1 + quiet = 1 if name[0:2] == '__': - quiet = 1 + quiet = 1 if ignored_functions.has_key(name): quiet = 1 - (ret, args) = description - desc = "" - retdesc = "" + (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 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 = string.split(self.comment, '\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) = string.split(l, ':', 1) - desc=string.strip(desc) - arg=string.strip(arg) + if not quiet: + self.warning("Missing * in function comment for %s" % (name)) + return(((ret[0], retdesc), args, desc)) + lines = string.split(self.comment, '\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) = string.split(l, ':', 1) + desc=string.strip(desc) + arg=string.strip(arg) 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 = string.strip(lines[0]) - while len(l) > 2 and l[0:3] != '* @': - while l[0] == '*': - l = l[1:] - desc = desc + ' ' + string.strip(l) - 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 = None - while len(lines) > 0: - l = lines[0] - i = 0 - # Remove all leading '*', followed by at most one ' ' character - # since we need to preserve correct identation of code examples - while i < len(l) and l[i] == '*': - i = i + 1 - if i > 0: - if i < len(l) and l[i] == ' ': - i = i + 1 - l = l[i:] - if len(l) >= 6 and l[0:7] == "returns" or l[0:7] == "Returns": - try: - l = string.split(l, ' ', 1)[1] - except: - l = "" - retdesc = string.strip(l) - del lines[0] - while len(lines) > 0: - l = lines[0] - while len(l) > 0 and l[0] == '*': - l = l[1:] - l = string.strip(l) - retdesc = retdesc + " " + l - del lines[0] - else: - if desc is not None: - desc = desc + "\n" + l - else: - desc = l - del lines[0] - - if desc is None: - desc = "" - retdesc = string.strip(retdesc) - desc = string.strip(desc) - - if quiet == 0: - # - # report missing comments - # - i = 0 - while i < nbargs: - if args[i][2] == None and args[i][0] != "void" and args[i][1] != None: - self.warning("Function comment for %s lacks description of arg %s" % (name, args[i][1])) - i = i + 1 - if retdesc == "" and ret[0] != "void": - self.warning("Function comment for %s lacks description of return value" % (name)) - if desc == "": - self.warning("Function comment for %s lacks description of the function" % (name)) - - - return(((ret[0], retdesc), args, desc)) + 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 = string.strip(lines[0]) + while len(l) > 2 and l[0:3] != '* @': + while l[0] == '*': + l = l[1:] + desc = desc + ' ' + string.strip(l) + 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 = None + while len(lines) > 0: + l = lines[0] + i = 0 + # Remove all leading '*', followed by at most one ' ' character + # since we need to preserve correct identation of code examples + while i < len(l) and l[i] == '*': + i = i + 1 + if i > 0: + if i < len(l) and l[i] == ' ': + i = i + 1 + l = l[i:] + if len(l) >= 6 and l[0:7] == "returns" or l[0:7] == "Returns": + try: + l = string.split(l, ' ', 1)[1] + except: + l = "" + retdesc = string.strip(l) + del lines[0] + while len(lines) > 0: + l = lines[0] + while len(l) > 0 and l[0] == '*': + l = l[1:] + l = string.strip(l) + retdesc = retdesc + " " + l + del lines[0] + else: + if desc is not None: + desc = desc + "\n" + l + else: + desc = l + del lines[0] + + if desc is None: + desc = "" + retdesc = string.strip(retdesc) + desc = string.strip(desc) + + if quiet == 0: + # + # report missing comments + # + i = 0 + while i < nbargs: + if args[i][2] == None and args[i][0] != "void" and args[i][1] != None: + self.warning("Function comment for %s lacks description of arg %s" % (name, args[i][1])) + i = i + 1 + if retdesc == "" and ret[0] != "void": + self.warning("Function comment for %s lacks description of return value" % (name)) + if desc == "": + self.warning("Function comment for %s lacks description of the function" % (name)) + + + return(((ret[0], retdesc), args, desc)) def parsePreproc(self, token): - if debug: - print "=> preproc ", token, self.lexer.tokens + if debug: + print "=> preproc ", token, self.lexer.tokens name = token[1] - if name == "#include": - token = self.lexer.token() - if token == None: - return None - if token[0] == 'preproc': - self.index_add(token[1], self.filename, not self.is_header, - "include") - return self.lexer.token() - return token - if name == "#define": - token = self.lexer.token() - if token == None: - return None - if token[0] == 'preproc': - # TODO macros with arguments - name = token[1] - lst = [] - token = self.lexer.token() - while token != None and token[0] == 'preproc' and \ - token[1][0] != '#': - lst.append(token[1]) - token = self.lexer.token() + if name == "#include": + token = self.lexer.token() + if token == None: + return None + if token[0] == 'preproc': + self.index_add(token[1], self.filename, not self.is_header, + "include") + return self.lexer.token() + return token + if name == "#define": + token = self.lexer.token() + if token == None: + return None + if token[0] == 'preproc': + # TODO macros with arguments + name = token[1] + lst = [] + token = self.lexer.token() + while token != None and token[0] == 'preproc' and \ + token[1][0] != '#': + lst.append(token[1]) + token = self.lexer.token() try: - name = string.split(name, '(') [0] + name = string.split(name, '(') [0] except: pass info = self.parseMacroComment(name, not self.is_header) - self.index_add(name, self.filename, not self.is_header, - "macro", info) - return token - - # - # Processing of conditionals modified by Bill 1/1/05 - # - # We process conditionals (i.e. tokens from #ifdef, #ifndef, - # #if, #else and #endif) for headers and mainline code, - # store the ones from the header in libxml2-api.xml, and later - # (in the routine merge_public) verify that the two (header and - # mainline code) agree. - # - # There is a small problem with processing the headers. Some of - # the variables are not concerned with enabling / disabling of - # library functions (e.g. '__XML_PARSER_H__'), and we don't want - # them to be included in libxml2-api.xml, or involved in - # the check between the header and the mainline code. To - # accomplish this, we ignore any conditional which doesn't include - # the string 'ENABLED' - # - if name == "#ifdef": - apstr = self.lexer.tokens[0][1] - try: - self.defines.append(apstr) - if string.find(apstr, 'ENABLED') != -1: - self.conditionals.append("defined(%s)" % apstr) - except: - pass - elif name == "#ifndef": - apstr = self.lexer.tokens[0][1] - try: - self.defines.append(apstr) - if string.find(apstr, 'ENABLED') != -1: - self.conditionals.append("!defined(%s)" % apstr) - except: - pass - elif name == "#if": - apstr = "" - for tok in self.lexer.tokens: - if apstr != "": - apstr = apstr + " " - apstr = apstr + tok[1] - try: - self.defines.append(apstr) - if string.find(apstr, 'ENABLED') != -1: - self.conditionals.append(apstr) - except: - pass - elif name == "#else": - if self.conditionals != [] and \ - string.find(self.defines[-1], 'ENABLED') != -1: - self.conditionals[-1] = "!(%s)" % self.conditionals[-1] - elif name == "#endif": - if self.conditionals != [] and \ - string.find(self.defines[-1], 'ENABLED') != -1: - self.conditionals = self.conditionals[:-1] - self.defines = self.defines[:-1] - token = self.lexer.token() - while token != None and token[0] == 'preproc' and \ - token[1][0] != '#': - token = self.lexer.token() - return token + self.index_add(name, self.filename, not self.is_header, + "macro", info) + return token + + # + # Processing of conditionals modified by Bill 1/1/05 + # + # We process conditionals (i.e. tokens from #ifdef, #ifndef, + # #if, #else and #endif) for headers and mainline code, + # store the ones from the header in libxml2-api.xml, and later + # (in the routine merge_public) verify that the two (header and + # mainline code) agree. + # + # There is a small problem with processing the headers. Some of + # the variables are not concerned with enabling / disabling of + # library functions (e.g. '__XML_PARSER_H__'), and we don't want + # them to be included in libxml2-api.xml, or involved in + # the check between the header and the mainline code. To + # accomplish this, we ignore any conditional which doesn't include + # the string 'ENABLED' + # + if name == "#ifdef": + apstr = self.lexer.tokens[0][1] + try: + self.defines.append(apstr) + if string.find(apstr, 'ENABLED') != -1: + self.conditionals.append("defined(%s)" % apstr) + except: + pass + elif name == "#ifndef": + apstr = self.lexer.tokens[0][1] + try: + self.defines.append(apstr) + if string.find(apstr, 'ENABLED') != -1: + self.conditionals.append("!defined(%s)" % apstr) + except: + pass + elif name == "#if": + apstr = "" + for tok in self.lexer.tokens: + if apstr != "": + apstr = apstr + " " + apstr = apstr + tok[1] + try: + self.defines.append(apstr) + if string.find(apstr, 'ENABLED') != -1: + self.conditionals.append(apstr) + except: + pass + elif name == "#else": + if self.conditionals != [] and \ + string.find(self.defines[-1], 'ENABLED') != -1: + self.conditionals[-1] = "!(%s)" % self.conditionals[-1] + elif name == "#endif": + if self.conditionals != [] and \ + string.find(self.defines[-1], 'ENABLED') != -1: + self.conditionals = self.conditionals[:-1] + self.defines = self.defines[:-1] + token = self.lexer.token() + while token != None and token[0] == 'preproc' and \ + token[1][0] != '#': + token = self.lexer.token() + return token # # token acquisition on top of the lexer, it handle internally @@ -1012,89 +1012,89 @@ class CParser: global ignored_words token = self.lexer.token() - while token != None: - if token[0] == 'comment': - token = self.parseComment(token) - continue - elif token[0] == 'preproc': - token = self.parsePreproc(token) - continue - elif token[0] == "name" and token[1] == "__const": - token = ("name", "const") - return token - elif token[0] == "name" and token[1] == "__attribute": - token = self.lexer.token() - while token != None and token[1] != ";": - token = self.lexer.token() - return token - elif token[0] == "name" and ignored_words.has_key(token[1]): - (n, info) = ignored_words[token[1]] - i = 0 - while i < n: - token = self.lexer.token() - i = i + 1 - token = self.lexer.token() - continue - else: - if debug: - print "=> ", token - return token - return None + while token != None: + if token[0] == 'comment': + token = self.parseComment(token) + continue + elif token[0] == 'preproc': + token = self.parsePreproc(token) + continue + elif token[0] == "name" and token[1] == "__const": + token = ("name", "const") + return token + elif token[0] == "name" and token[1] == "__attribute": + token = self.lexer.token() + while token != None and token[1] != ";": + token = self.lexer.token() + return token + elif token[0] == "name" and ignored_words.has_key(token[1]): + (n, info) = ignored_words[token[1]] + i = 0 + while i < n: + token = self.lexer.token() + i = i + 1 + token = self.lexer.token() + continue + else: + if debug: + print "=> ", token + return token + return None # # Parse a typedef, it records the type and its name. # def parseTypedef(self, token): if token == None: - return None - token = self.parseType(token) - if token == None: - self.error("parsing typedef") - return None - base_type = self.type - type = base_type - #self.debug("end typedef type", token) - while token != None: - if token[0] == "name": - name = token[1] - signature = self.signature - if signature != None: - type = string.split(type, '(')[0] - d = self.mergeFunctionComment(name, - ((type, None), signature), 1) - self.index_add(name, self.filename, not self.is_header, - "functype", d) - else: - if base_type == "struct": - self.index_add(name, self.filename, not self.is_header, - "struct", type) - base_type = "struct " + name - else: - # TODO report missing or misformatted comments - info = self.parseTypeComment(name, 1) - self.index_add(name, self.filename, not self.is_header, - "typedef", type, info) - token = self.token() - else: - self.error("parsing typedef: expecting a name") - return token - #self.debug("end typedef", token) - if token != None and token[0] == 'sep' and token[1] == ',': - type = base_type - token = self.token() - while token != None and token[0] == "op": - type = type + token[1] - token = self.token() - elif token != None and token[0] == 'sep' and token[1] == ';': - break; - elif token != None and token[0] == 'name': - type = base_type - continue; - else: - self.error("parsing typedef: expecting ';'", token) - return token - token = self.token() - return token + return None + token = self.parseType(token) + if token == None: + self.error("parsing typedef") + return None + base_type = self.type + type = base_type + #self.debug("end typedef type", token) + while token != None: + if token[0] == "name": + name = token[1] + signature = self.signature + if signature != None: + type = string.split(type, '(')[0] + d = self.mergeFunctionComment(name, + ((type, None), signature), 1) + self.index_add(name, self.filename, not self.is_header, + "functype", d) + else: + if base_type == "struct": + self.index_add(name, self.filename, not self.is_header, + "struct", type) + base_type = "struct " + name + else: + # TODO report missing or misformatted comments + info = self.parseTypeComment(name, 1) + self.index_add(name, self.filename, not self.is_header, + "typedef", type, info) + token = self.token() + else: + self.error("parsing typedef: expecting a name") + return token + #self.debug("end typedef", token) + if token != None and token[0] == 'sep' and token[1] == ',': + type = base_type + token = self.token() + while token != None and token[0] == "op": + type = type + token[1] + token = self.token() + elif token != None and token[0] == 'sep' and token[1] == ';': + break; + elif token != None and token[0] == 'name': + type = base_type + continue; + else: + self.error("parsing typedef: expecting ';'", token) + return token + token = self.token() + return token # # Parse a C code block, used for functions it parse till @@ -1102,138 +1102,138 @@ class CParser: # def parseBlock(self, token): while token != None: - if token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseBlock(token) - elif token[0] == "sep" and token[1] == "}": - self.comment = None - token = self.token() - return token - else: - if self.collect_ref == 1: - oldtok = token - token = self.token() - if oldtok[0] == "name" and oldtok[1][0:3] == "vir": - if token[0] == "sep" and token[1] == "(": - self.index_add_ref(oldtok[1], self.filename, - 0, "function") - token = self.token() - elif token[0] == "name": - token = self.token() - if token[0] == "sep" and (token[1] == ";" or - token[1] == "," or token[1] == "="): - self.index_add_ref(oldtok[1], self.filename, - 0, "type") - elif oldtok[0] == "name" and oldtok[1][0:4] == "XEN_": - self.index_add_ref(oldtok[1], self.filename, - 0, "typedef") - elif oldtok[0] == "name" and oldtok[1][0:7] == "LIBXEN_": - self.index_add_ref(oldtok[1], self.filename, - 0, "typedef") - - else: - token = self.token() - return token + if token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseBlock(token) + elif token[0] == "sep" and token[1] == "}": + self.comment = None + token = self.token() + return token + else: + if self.collect_ref == 1: + oldtok = token + token = self.token() + if oldtok[0] == "name" and oldtok[1][0:3] == "vir": + if token[0] == "sep" and token[1] == "(": + self.index_add_ref(oldtok[1], self.filename, + 0, "function") + token = self.token() + elif token[0] == "name": + token = self.token() + if token[0] == "sep" and (token[1] == ";" or + token[1] == "," or token[1] == "="): + self.index_add_ref(oldtok[1], self.filename, + 0, "type") + elif oldtok[0] == "name" and oldtok[1][0:4] == "XEN_": + self.index_add_ref(oldtok[1], self.filename, + 0, "typedef") + elif oldtok[0] == "name" and oldtok[1][0:7] == "LIBXEN_": + self.index_add_ref(oldtok[1], self.filename, + 0, "typedef") + + else: + token = self.token() + return token # # Parse a C struct definition till the balancing } # def parseStruct(self, token): fields = [] - #self.debug("start parseStruct", token) + #self.debug("start parseStruct", token) while token != None: - if token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseTypeBlock(token) - elif token[0] == "sep" and token[1] == "}": - self.struct_fields = fields - #self.debug("end parseStruct", token) - #print fields - token = self.token() - return token - else: - base_type = self.type - #self.debug("before parseType", token) - token = self.parseType(token) - #self.debug("after parseType", token) - if token != None and token[0] == "name": - fname = token[1] - token = self.token() - if token[0] == "sep" and token[1] == ";": - self.comment = None - token = self.token() - fields.append((self.type, fname, self.comment)) - self.comment = None - else: - self.error("parseStruct: expecting ;", token) - elif token != None and token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseTypeBlock(token) - if token != None and token[0] == "name": - token = self.token() - if token != None and token[0] == "sep" and token[1] == ";": - token = self.token() - else: - self.error("parseStruct: expecting ;", token) - else: - self.error("parseStruct: name", token) - token = self.token() - self.type = base_type; + if token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseTypeBlock(token) + elif token[0] == "sep" and token[1] == "}": + self.struct_fields = fields + #self.debug("end parseStruct", token) + #print fields + token = self.token() + return token + else: + base_type = self.type + #self.debug("before parseType", token) + token = self.parseType(token) + #self.debug("after parseType", token) + if token != None and token[0] == "name": + fname = token[1] + token = self.token() + if token[0] == "sep" and token[1] == ";": + self.comment = None + token = self.token() + fields.append((self.type, fname, self.comment)) + self.comment = None + else: + self.error("parseStruct: expecting ;", token) + elif token != None and token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseTypeBlock(token) + if token != None and token[0] == "name": + token = self.token() + if token != None and token[0] == "sep" and token[1] == ";": + token = self.token() + else: + self.error("parseStruct: expecting ;", token) + else: + self.error("parseStruct: name", token) + token = self.token() + self.type = base_type; self.struct_fields = fields - #self.debug("end parseStruct", token) - #print fields - return token + #self.debug("end parseStruct", token) + #print fields + return token # # Parse a C enum block, parse till the balancing } # def parseEnumBlock(self, token): self.enums = [] - name = None - self.comment = None - comment = "" - value = "0" + name = None + self.comment = None + comment = "" + value = "0" while token != None: - if token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseTypeBlock(token) - elif token[0] == "sep" and token[1] == "}": - if name != None: - if self.comment != None: - comment = self.comment - self.comment = None - self.enums.append((name, value, comment)) - token = self.token() - return token - elif token[0] == "name": - if name != None: - if self.comment != None: - comment = string.strip(self.comment) - self.comment = None - self.enums.append((name, value, comment)) - name = token[1] - comment = "" - token = self.token() - if token[0] == "op" and token[1][0] == "=": - value = "" - if len(token[1]) > 1: - value = token[1][1:] - token = self.token() - while token[0] != "sep" or (token[1] != ',' and - token[1] != '}'): - value = value + token[1] - token = self.token() - else: - try: - value = "%d" % (int(value) + 1) - except: - self.warning("Failed to compute value of enum %s" % (name)) - value="" - if token[0] == "sep" and token[1] == ",": - token = self.token() - else: - token = self.token() - return token + if token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseTypeBlock(token) + elif token[0] == "sep" and token[1] == "}": + if name != None: + if self.comment != None: + comment = self.comment + self.comment = None + self.enums.append((name, value, comment)) + token = self.token() + return token + elif token[0] == "name": + if name != None: + if self.comment != None: + comment = string.strip(self.comment) + self.comment = None + self.enums.append((name, value, comment)) + name = token[1] + comment = "" + token = self.token() + if token[0] == "op" and token[1][0] == "=": + value = "" + if len(token[1]) > 1: + value = token[1][1:] + token = self.token() + while token[0] != "sep" or (token[1] != ',' and + token[1] != '}'): + value = value + token[1] + token = self.token() + else: + try: + value = "%d" % (int(value) + 1) + except: + self.warning("Failed to compute value of enum %s" % (name)) + value="" + if token[0] == "sep" and token[1] == ",": + token = self.token() + else: + token = self.token() + return token # # Parse a C definition block, used for structs it parse till @@ -1241,15 +1241,15 @@ class CParser: # def parseTypeBlock(self, token): while token != None: - if token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseTypeBlock(token) - elif token[0] == "sep" and token[1] == "}": - token = self.token() - return token - else: - token = self.token() - return token + if token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseTypeBlock(token) + elif token[0] == "sep" and token[1] == "}": + token = self.token() + return token + else: + token = self.token() + return token # # Parse a type: the fact that the type name can either occur after @@ -1258,221 +1258,221 @@ class CParser: # def parseType(self, token): self.type = "" - self.struct_fields = [] + self.struct_fields = [] self.signature = None - if token == None: - return token - - while token[0] == "name" and ( - token[1] == "const" or \ - token[1] == "unsigned" or \ - token[1] == "signed"): - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - token = self.token() + if token == None: + return token + + while token[0] == "name" and ( + token[1] == "const" or \ + token[1] == "unsigned" or \ + token[1] == "signed"): + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + token = self.token() if token[0] == "name" and token[1] == "long": - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - - # some read ahead for long long - oldtmp = token - token = self.token() - if token[0] == "name" and token[1] == "long": - self.type = self.type + " " + token[1] - else: - self.push(token) - token = oldtmp - - if token[0] == "name" and token[1] == "int": - if self.type == "": - self.type = tmp[1] - else: - self.type = self.type + " " + tmp[1] + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + + # some read ahead for long long + oldtmp = token + token = self.token() + if token[0] == "name" and token[1] == "long": + self.type = self.type + " " + token[1] + else: + self.push(token) + token = oldtmp + + if token[0] == "name" and token[1] == "int": + if self.type == "": + self.type = tmp[1] + else: + self.type = self.type + " " + tmp[1] elif token[0] == "name" and token[1] == "short": - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - if token[0] == "name" and token[1] == "int": - if self.type == "": - self.type = tmp[1] - else: - self.type = self.type + " " + tmp[1] + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + if token[0] == "name" and token[1] == "int": + if self.type == "": + self.type = tmp[1] + else: + self.type = self.type + " " + tmp[1] elif token[0] == "name" and token[1] == "struct": - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - token = self.token() - nametok = None - if token[0] == "name": - nametok = token - token = self.token() - if token != None and token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseStruct(token) - elif token != None and token[0] == "op" and token[1] == "*": - self.type = self.type + " " + nametok[1] + " *" - token = self.token() - while token != None and token[0] == "op" and token[1] == "*": - self.type = self.type + " *" - token = self.token() - if token[0] == "name": - nametok = token - token = self.token() - else: - self.error("struct : expecting name", token) - return token - elif token != None and token[0] == "name" and nametok != None: - self.type = self.type + " " + nametok[1] - return token - - if nametok != None: - self.lexer.push(token) - token = nametok - return token + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + token = self.token() + nametok = None + if token[0] == "name": + nametok = token + token = self.token() + if token != None and token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseStruct(token) + elif token != None and token[0] == "op" and token[1] == "*": + self.type = self.type + " " + nametok[1] + " *" + token = self.token() + while token != None and token[0] == "op" and token[1] == "*": + self.type = self.type + " *" + token = self.token() + if token[0] == "name": + nametok = token + token = self.token() + else: + self.error("struct : expecting name", token) + return token + elif token != None and token[0] == "name" and nametok != None: + self.type = self.type + " " + nametok[1] + return token + + if nametok != None: + self.lexer.push(token) + token = nametok + return token elif token[0] == "name" and token[1] == "enum": - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - self.enums = [] - token = self.token() - if token != None and token[0] == "sep" and token[1] == "{": - token = self.token() - token = self.parseEnumBlock(token) - else: - self.error("parsing enum: expecting '{'", token) - enum_type = None - if token != None and token[0] != "name": - self.lexer.push(token) - token = ("name", "enum") - else: - enum_type = token[1] - for enum in self.enums: - self.index_add(enum[0], self.filename, - not self.is_header, "enum", - (enum[1], enum[2], enum_type)) - return token - - elif token[0] == "name": - if self.type == "": - self.type = token[1] - else: - self.type = self.type + " " + token[1] - else: - self.error("parsing type %s: expecting a name" % (self.type), - token) - return token - token = self.token() + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + self.enums = [] + token = self.token() + if token != None and token[0] == "sep" and token[1] == "{": + token = self.token() + token = self.parseEnumBlock(token) + else: + self.error("parsing enum: expecting '{'", token) + enum_type = None + if token != None and token[0] != "name": + self.lexer.push(token) + token = ("name", "enum") + else: + enum_type = token[1] + for enum in self.enums: + self.index_add(enum[0], self.filename, + not self.is_header, "enum", + (enum[1], enum[2], enum_type)) + return token + + elif token[0] == "name": + if self.type == "": + self.type = token[1] + else: + self.type = self.type + " " + token[1] + else: + self.error("parsing type %s: expecting a name" % (self.type), + token) + return token + token = self.token() while token != None and (token[0] == "op" or - token[0] == "name" and token[1] == "const"): - self.type = self.type + " " + token[1] - token = self.token() - - # - # if there is a parenthesis here, this means a function type - # - if token != None and token[0] == "sep" and token[1] == '(': - self.type = self.type + token[1] - token = self.token() - while token != None and token[0] == "op" and token[1] == '*': - self.type = self.type + token[1] - token = self.token() - if token == None or token[0] != "name" : - self.error("parsing function type, name expected", token); - return token - self.type = self.type + token[1] - nametok = token - token = self.token() - if token != None and token[0] == "sep" and token[1] == ')': - self.type = self.type + token[1] - token = self.token() - if token != None and token[0] == "sep" and token[1] == '(': - token = self.token() - type = self.type; - token = self.parseSignature(token); - self.type = type; - else: - self.error("parsing function type, '(' expected", token); - return token - else: - self.error("parsing function type, ')' expected", token); - return token - self.lexer.push(token) - token = nametok - return token + token[0] == "name" and token[1] == "const"): + self.type = self.type + " " + token[1] + token = self.token() # - # do some lookahead for arrays - # - if token != None and token[0] == "name": - nametok = token - token = self.token() - if token != None and token[0] == "sep" and token[1] == '[': - self.type = self.type + nametok[1] - while token != None and token[0] == "sep" and token[1] == '[': - self.type = self.type + token[1] - token = self.token() - while token != None and token[0] != 'sep' and \ - token[1] != ']' and token[1] != ';': - self.type = self.type + token[1] - token = self.token() - if token != None and token[0] == 'sep' and token[1] == ']': - self.type = self.type + token[1] - token = self.token() - else: - self.error("parsing array type, ']' expected", token); - return token - elif token != None and token[0] == "sep" and token[1] == ':': - # remove :12 in case it's a limited int size - token = self.token() - token = self.token() - self.lexer.push(token) - token = nametok - - return token + # if there is a parenthesis here, this means a function type + # + if token != None and token[0] == "sep" and token[1] == '(': + self.type = self.type + token[1] + token = self.token() + while token != None and token[0] == "op" and token[1] == '*': + self.type = self.type + token[1] + token = self.token() + if token == None or token[0] != "name" : + self.error("parsing function type, name expected", token); + return token + self.type = self.type + token[1] + nametok = token + token = self.token() + if token != None and token[0] == "sep" and token[1] == ')': + self.type = self.type + token[1] + token = self.token() + if token != None and token[0] == "sep" and token[1] == '(': + token = self.token() + type = self.type; + token = self.parseSignature(token); + self.type = type; + else: + self.error("parsing function type, '(' expected", token); + return token + else: + self.error("parsing function type, ')' expected", token); + return token + self.lexer.push(token) + token = nametok + return token + + # + # do some lookahead for arrays + # + if token != None and token[0] == "name": + nametok = token + token = self.token() + if token != None and token[0] == "sep" and token[1] == '[': + self.type = self.type + nametok[1] + while token != None and token[0] == "sep" and token[1] == '[': + self.type = self.type + token[1] + token = self.token() + while token != None and token[0] != 'sep' and \ + token[1] != ']' and token[1] != ';': + self.type = self.type + token[1] + token = self.token() + if token != None and token[0] == 'sep' and token[1] == ']': + self.type = self.type + token[1] + token = self.token() + else: + self.error("parsing array type, ']' expected", token); + return token + elif token != None and token[0] == "sep" and token[1] == ':': + # remove :12 in case it's a limited int size + token = self.token() + token = self.token() + self.lexer.push(token) + token = nametok + + return token # # Parse a signature: '(' has been parsed and we scan the type definition # up to the ')' included def parseSignature(self, token): signature = [] - if token != None and token[0] == "sep" and token[1] == ')': - self.signature = [] - token = self.token() - return token - while token != None: - token = self.parseType(token) - if token != None and token[0] == "name": - signature.append((self.type, token[1], None)) - token = self.token() - elif token != None and token[0] == "sep" and token[1] == ',': - token = self.token() - continue - elif token != None and token[0] == "sep" and token[1] == ')': - # only the type was provided - if self.type == "...": - signature.append((self.type, "...", None)) - else: - signature.append((self.type, None, None)) - if token != None and token[0] == "sep": - if token[1] == ',': - token = self.token() - continue - elif token[1] == ')': - token = self.token() - break - self.signature = signature - return token + if token != None and token[0] == "sep" and token[1] == ')': + self.signature = [] + token = self.token() + return token + while token != None: + token = self.parseType(token) + if token != None and token[0] == "name": + signature.append((self.type, token[1], None)) + token = self.token() + elif token != None and token[0] == "sep" and token[1] == ',': + token = self.token() + continue + elif token != None and token[0] == "sep" and token[1] == ')': + # only the type was provided + if self.type == "...": + signature.append((self.type, "...", None)) + else: + signature.append((self.type, None, None)) + if token != None and token[0] == "sep": + if token[1] == ',': + token = self.token() + continue + elif token[1] == ')': + token = self.token() + break + self.signature = signature + return token # # Parse a global definition, be it a type, variable or function @@ -1481,134 +1481,134 @@ class CParser: def parseGlobal(self, token): static = 0 if token[1] == 'extern': - token = self.token() - if token == None: - return token - if token[0] == 'string': - if token[1] == 'C': - token = self.token() - if token == None: - return token - if token[0] == 'sep' and token[1] == "{": - token = self.token() -# print 'Entering extern "C line ', self.lineno() - while token != None and (token[0] != 'sep' or - token[1] != "}"): - if token[0] == 'name': - token = self.parseGlobal(token) - else: - self.error( - "token %s %s unexpected at the top level" % ( - token[0], token[1])) - token = self.parseGlobal(token) -# print 'Exiting extern "C" line', self.lineno() - token = self.token() - return token - else: - return token - elif token[1] == 'static': - static = 1 - token = self.token() - if token == None or token[0] != 'name': - return token - - if token[1] == 'typedef': - token = self.token() - return self.parseTypedef(token) - else: - token = self.parseType(token) - type_orig = self.type - if token == None or token[0] != "name": - return token - type = type_orig - self.name = token[1] - token = self.token() - while token != None and (token[0] == "sep" or token[0] == "op"): - if token[0] == "sep": - if token[1] == "[": - type = type + token[1] - token = self.token() - while token != None and (token[0] != "sep" or \ - token[1] != ";"): - type = type + token[1] - token = self.token() - - if token != None and token[0] == "op" and token[1] == "=": - # - # Skip the initialization of the variable - # - token = self.token() - if token[0] == 'sep' and token[1] == '{': - token = self.token() - token = self.parseBlock(token) - else: - self.comment = None - while token != None and (token[0] != "sep" or \ - (token[1] != ';' and token[1] != ',')): - token = self.token() - self.comment = None - if token == None or token[0] != "sep" or (token[1] != ';' and - token[1] != ','): - self.error("missing ';' or ',' after value") - - if token != None and token[0] == "sep": - if token[1] == ";": - self.comment = None - token = self.token() - if type == "struct": - self.index_add(self.name, self.filename, - not self.is_header, "struct", self.struct_fields) - else: - self.index_add(self.name, self.filename, - not self.is_header, "variable", type) - break - elif token[1] == "(": - token = self.token() - token = self.parseSignature(token) - if token == None: - return None - if token[0] == "sep" and token[1] == ";": - d = self.mergeFunctionComment(self.name, - ((type, None), self.signature), 1) - self.index_add(self.name, self.filename, static, - "function", d) - token = self.token() - elif token[0] == "sep" and token[1] == "{": - d = self.mergeFunctionComment(self.name, - ((type, None), self.signature), static) - self.index_add(self.name, self.filename, static, - "function", d) - token = self.token() - token = self.parseBlock(token); - elif token[1] == ',': - self.comment = None - self.index_add(self.name, self.filename, static, - "variable", type) - type = type_orig - token = self.token() - while token != None and token[0] == "sep": - type = type + token[1] - token = self.token() - if token != None and token[0] == "name": - self.name = token[1] - token = self.token() - else: - break - - return token + token = self.token() + if token == None: + return token + if token[0] == 'string': + if token[1] == 'C': + token = self.token() + if token == None: + return token + if token[0] == 'sep' and token[1] == "{": + token = self.token() +# print 'Entering extern "C line ', self.lineno() + while token != None and (token[0] != 'sep' or + token[1] != "}"): + if token[0] == 'name': + token = self.parseGlobal(token) + else: + self.error( + "token %s %s unexpected at the top level" % ( + token[0], token[1])) + token = self.parseGlobal(token) +# print 'Exiting extern "C" line', self.lineno() + token = self.token() + return token + else: + return token + elif token[1] == 'static': + static = 1 + token = self.token() + if token == None or token[0] != 'name': + return token + + if token[1] == 'typedef': + token = self.token() + return self.parseTypedef(token) + else: + token = self.parseType(token) + type_orig = self.type + if token == None or token[0] != "name": + return token + type = type_orig + self.name = token[1] + token = self.token() + while token != None and (token[0] == "sep" or token[0] == "op"): + if token[0] == "sep": + if token[1] == "[": + type = type + token[1] + token = self.token() + while token != None and (token[0] != "sep" or \ + token[1] != ";"): + type = type + token[1] + token = self.token() + + if token != None and token[0] == "op" and token[1] == "=": + # + # Skip the initialization of the variable + # + token = self.token() + if token[0] == 'sep' and token[1] == '{': + token = self.token() + token = self.parseBlock(token) + else: + self.comment = None + while token != None and (token[0] != "sep" or \ + (token[1] != ';' and token[1] != ',')): + token = self.token() + self.comment = None + if token == None or token[0] != "sep" or (token[1] != ';' and + token[1] != ','): + self.error("missing ';' or ',' after value") + + if token != None and token[0] == "sep": + if token[1] == ";": + self.comment = None + token = self.token() + if type == "struct": + self.index_add(self.name, self.filename, + not self.is_header, "struct", self.struct_fields) + else: + self.index_add(self.name, self.filename, + not self.is_header, "variable", type) + break + elif token[1] == "(": + token = self.token() + token = self.parseSignature(token) + if token == None: + return None + if token[0] == "sep" and token[1] == ";": + d = self.mergeFunctionComment(self.name, + ((type, None), self.signature), 1) + self.index_add(self.name, self.filename, static, + "function", d) + token = self.token() + elif token[0] == "sep" and token[1] == "{": + d = self.mergeFunctionComment(self.name, + ((type, None), self.signature), static) + self.index_add(self.name, self.filename, static, + "function", d) + token = self.token() + token = self.parseBlock(token); + elif token[1] == ',': + self.comment = None + self.index_add(self.name, self.filename, static, + "variable", type) + type = type_orig + token = self.token() + while token != None and token[0] == "sep": + type = type + token[1] + token = self.token() + if token != None and token[0] == "name": + self.name = token[1] + token = self.token() + else: + break + + return token def parse(self): self.warning("Parsing %s" % (self.filename)) token = self.token() - while token != None: + while token != None: if token[0] == 'name': - token = self.parseGlobal(token) + token = self.parseGlobal(token) else: - self.error("token %s %s unexpected at the top level" % ( - token[0], token[1])) - token = self.parseGlobal(token) - return - self.parseTopComment(self.top_comment) + self.error("token %s %s unexpected at the top level" % ( + token[0], token[1])) + token = self.parseGlobal(token) + return + self.parseTopComment(self.top_comment) return self.index @@ -1618,449 +1618,449 @@ class docBuilder: self.name = name self.path = path self.directories = directories - self.includes = includes + included_files.keys() - self.modules = {} - self.headers = {} - self.idx = index() + self.includes = includes + included_files.keys() + self.modules = {} + self.headers = {} + self.idx = index() self.xref = {} - self.index = {} - self.basename = name + self.index = {} + self.basename = name def indexString(self, id, str): - if str == None: - return - str = string.replace(str, "'", ' ') - str = string.replace(str, '"', ' ') - str = string.replace(str, "/", ' ') - str = string.replace(str, '*', ' ') - str = string.replace(str, "[", ' ') - str = string.replace(str, "]", ' ') - str = string.replace(str, "(", ' ') - str = string.replace(str, ")", ' ') - str = string.replace(str, "<", ' ') - str = string.replace(str, '>', ' ') - str = string.replace(str, "&", ' ') - str = string.replace(str, '#', ' ') - str = string.replace(str, ",", ' ') - str = string.replace(str, '.', ' ') - str = string.replace(str, ';', ' ') - tokens = string.split(str) - for token in tokens: - try: - c = token[0] - if string.find(string.letters, c) < 0: - pass - elif len(token) < 3: - pass - else: - lower = string.lower(token) - # TODO: generalize this a bit - if lower == 'and' or lower == 'the': - pass - elif self.xref.has_key(token): - self.xref[token].append(id) - else: - self.xref[token] = [id] - except: - pass + if str == None: + return + str = string.replace(str, "'", ' ') + str = string.replace(str, '"', ' ') + str = string.replace(str, "/", ' ') + str = string.replace(str, '*', ' ') + str = string.replace(str, "[", ' ') + str = string.replace(str, "]", ' ') + str = string.replace(str, "(", ' ') + str = string.replace(str, ")", ' ') + str = string.replace(str, "<", ' ') + str = string.replace(str, '>', ' ') + str = string.replace(str, "&", ' ') + str = string.replace(str, '#', ' ') + str = string.replace(str, ",", ' ') + str = string.replace(str, '.', ' ') + str = string.replace(str, ';', ' ') + tokens = string.split(str) + for token in tokens: + try: + c = token[0] + if string.find(string.letters, c) < 0: + pass + elif len(token) < 3: + pass + else: + lower = string.lower(token) + # TODO: generalize this a bit + if lower == 'and' or lower == 'the': + pass + elif self.xref.has_key(token): + self.xref[token].append(id) + else: + self.xref[token] = [id] + except: + pass def analyze(self): print "Project %s : %d headers, %d modules" % (self.name, len(self.headers.keys()), len(self.modules.keys())) - self.idx.analyze() + self.idx.analyze() def scanHeaders(self): - for header in self.headers.keys(): - parser = CParser(header) - idx = parser.parse() - self.headers[header] = idx; - self.idx.merge(idx) + for header in self.headers.keys(): + parser = CParser(header) + idx = parser.parse() + self.headers[header] = idx; + self.idx.merge(idx) def scanModules(self): - for module in self.modules.keys(): - parser = CParser(module) - idx = parser.parse() - # idx.analyze() - self.modules[module] = idx - self.idx.merge_public(idx) + for module in self.modules.keys(): + parser = CParser(module) + idx = parser.parse() + # idx.analyze() + self.modules[module] = idx + self.idx.merge_public(idx) def scan(self): for directory in self.directories: - files = glob.glob(directory + "/*.c") - for file in files: - skip = 1 - for incl in self.includes: - if string.find(file, incl) != -1: - skip = 0; - break - if skip == 0: - self.modules[file] = None; - files = glob.glob(directory + "/*.h") - for file in files: - skip = 1 - for incl in self.includes: - if string.find(file, incl) != -1: - skip = 0; - break - if skip == 0: - self.headers[file] = None; - self.scanHeaders() - self.scanModules() + files = glob.glob(directory + "/*.c") + for file in files: + skip = 1 + for incl in self.includes: + if string.find(file, incl) != -1: + skip = 0; + break + if skip == 0: + self.modules[file] = None; + files = glob.glob(directory + "/*.h") + for file in files: + skip = 1 + for incl in self.includes: + if string.find(file, incl) != -1: + skip = 0; + break + if skip == 0: + self.headers[file] = None; + self.scanHeaders() + self.scanModules() def modulename_file(self, file): module = os.path.basename(file) - if module[-2:] == '.h': - module = module[:-2] - elif module[-2:] == '.c': - module = module[:-2] - return module + if module[-2:] == '.h': + module = module[:-2] + elif module[-2:] == '.c': + module = module[:-2] + return module def serialize_enum(self, output, name): id = self.idx.enums[name] output.write(" <enum name='%s' file='%s'" % (name, - self.modulename_file(id.header))) - if id.info != None: - info = id.info - if info[0] != None and info[0] != '': - try: - val = eval(info[0]) - except: - val = info[0] - output.write(" value='%s'" % (val)); - if info[2] != None and info[2] != '': - output.write(" type='%s'" % info[2]); - if info[1] != None and info[1] != '': - output.write(" info='%s'" % escape(info[1])); + self.modulename_file(id.header))) + if id.info != None: + info = id.info + if info[0] != None and info[0] != '': + try: + val = eval(info[0]) + except: + val = info[0] + output.write(" value='%s'" % (val)); + if info[2] != None and info[2] != '': + output.write(" type='%s'" % info[2]); + if info[1] != None and info[1] != '': + output.write(" info='%s'" % escape(info[1])); output.write("/>\n") def serialize_macro(self, output, name): id = self.idx.macros[name] output.write(" <macro name='%s' file='%s'>\n" % (name, - self.modulename_file(id.header))) - if id.info != None: + self.modulename_file(id.header))) + if id.info != None: try: - (args, desc) = id.info - if desc != None and desc != "": - output.write(" <info><![CDATA[%s]]></info>\n" % (desc)) - self.indexString(name, desc) - for arg in args: - (name, desc) = arg - if desc != None and desc != "": - output.write(" <arg name='%s' info='%s'/>\n" % ( - name, escape(desc))) - self.indexString(name, desc) - else: - output.write(" <arg name='%s'/>\n" % (name)) + (args, desc) = id.info + if desc != None and desc != "": + output.write(" <info><![CDATA[%s]]></info>\n" % (desc)) + self.indexString(name, desc) + for arg in args: + (name, desc) = arg + if desc != None and desc != "": + output.write(" <arg name='%s' info='%s'/>\n" % ( + name, escape(desc))) + self.indexString(name, desc) + else: + output.write(" <arg name='%s'/>\n" % (name)) except: pass output.write(" </macro>\n") def serialize_typedef(self, output, name): id = self.idx.typedefs[name] - if id.info[0:7] == 'struct ': - output.write(" <struct name='%s' file='%s' type='%s'" % ( - name, self.modulename_file(id.header), id.info)) - name = id.info[7:] - if self.idx.structs.has_key(name) and ( \ - type(self.idx.structs[name].info) == type(()) or - type(self.idx.structs[name].info) == type([])): - output.write(">\n"); - try: - for field in self.idx.structs[name].info: - desc = field[2] - self.indexString(name, desc) - if desc == None: - desc = '' - else: - desc = escape(desc) - output.write(" <field name='%s' type='%s' info='%s'/>\n" % (field[1] , field[0], desc)) - except: - print "Failed to serialize struct %s" % (name) - output.write(" </struct>\n") - else: - output.write("/>\n"); - else : - output.write(" <typedef name='%s' file='%s' type='%s'" % ( - name, self.modulename_file(id.header), id.info)) + if id.info[0:7] == 'struct ': + output.write(" <struct name='%s' file='%s' type='%s'" % ( + name, self.modulename_file(id.header), id.info)) + name = id.info[7:] + if self.idx.structs.has_key(name) and ( \ + type(self.idx.structs[name].info) == type(()) or + type(self.idx.structs[name].info) == type([])): + output.write(">\n"); + try: + for field in self.idx.structs[name].info: + desc = field[2] + self.indexString(name, desc) + if desc == None: + desc = '' + else: + desc = escape(desc) + output.write(" <field name='%s' type='%s' info='%s'/>\n" % (field[1] , field[0], desc)) + except: + print "Failed to serialize struct %s" % (name) + output.write(" </struct>\n") + else: + output.write("/>\n"); + else : + output.write(" <typedef name='%s' file='%s' type='%s'" % ( + name, self.modulename_file(id.header), id.info)) try: - desc = id.extra - if desc != None and desc != "": - output.write(">\n <info><![CDATA[%s]]></info>\n" % (desc)) - output.write(" </typedef>\n") - else: - output.write("/>\n") - except: - output.write("/>\n") + desc = id.extra + if desc != None and desc != "": + output.write(">\n <info><![CDATA[%s]]></info>\n" % (desc)) + output.write(" </typedef>\n") + else: + output.write("/>\n") + except: + output.write("/>\n") def serialize_variable(self, output, name): id = self.idx.variables[name] - if id.info != None: - output.write(" <variable name='%s' file='%s' type='%s'/>\n" % ( - name, self.modulename_file(id.header), id.info)) - else: - output.write(" <variable name='%s' file='%s'/>\n" % ( - name, self.modulename_file(id.header))) + if id.info != None: + output.write(" <variable name='%s' file='%s' type='%s'/>\n" % ( + name, self.modulename_file(id.header), id.info)) + else: + output.write(" <variable name='%s' file='%s'/>\n" % ( + name, self.modulename_file(id.header))) def serialize_function(self, output, name): id = self.idx.functions[name] - if name == debugsym: - print "=>", id + if name == debugsym: + print "=>", id output.write(" <%s name='%s' file='%s' module='%s'>\n" % (id.type, - name, self.modulename_file(id.header), - self.modulename_file(id.module))) - # - # Processing of conditionals modified by Bill 1/1/05 - # - if id.conditionals != None: - apstr = "" - for cond in id.conditionals: - if apstr != "": - apstr = apstr + " &amp;&amp; " - apstr = apstr + cond - output.write(" <cond>%s</cond>\n"% (apstr)); - try: - (ret, params, desc) = id.info - output.write(" <info><![CDATA[%s]]></info>\n" % (desc)) - self.indexString(name, desc) - if ret[0] != None: - if ret[0] == "void": - output.write(" <return type='void'/>\n") - else: - output.write(" <return type='%s' info='%s'/>\n" % ( - ret[0], escape(ret[1]))) - self.indexString(name, ret[1]) - for param in params: - if param[0] == 'void': - continue - if param[2] == None: - output.write(" <arg name='%s' type='%s' info=''/>\n" % (param[1], param[0])) - else: - output.write(" <arg name='%s' type='%s' info='%s'/>\n" % (param[1], param[0], escape(param[2]))) - self.indexString(name, param[2]) - except: - print "Failed to save function %s info: " % name, `id.info` + name, self.modulename_file(id.header), + self.modulename_file(id.module))) + # + # Processing of conditionals modified by Bill 1/1/05 + # + if id.conditionals != None: + apstr = "" + for cond in id.conditionals: + if apstr != "": + apstr = apstr + " &amp;&amp; " + apstr = apstr + cond + output.write(" <cond>%s</cond>\n"% (apstr)); + try: + (ret, params, desc) = id.info + output.write(" <info><![CDATA[%s]]></info>\n" % (desc)) + self.indexString(name, desc) + if ret[0] != None: + if ret[0] == "void": + output.write(" <return type='void'/>\n") + else: + output.write(" <return type='%s' info='%s'/>\n" % ( + ret[0], escape(ret[1]))) + self.indexString(name, ret[1]) + for param in params: + if param[0] == 'void': + continue + if param[2] == None: + output.write(" <arg name='%s' type='%s' info=''/>\n" % (param[1], param[0])) + else: + output.write(" <arg name='%s' type='%s' info='%s'/>\n" % (param[1], param[0], escape(param[2]))) + self.indexString(name, param[2]) + except: + print "Failed to save function %s info: " % name, `id.info` output.write(" </%s>\n" % (id.type)) def serialize_exports(self, output, file): module = self.modulename_file(file) - output.write(" <file name='%s'>\n" % (module)) - dict = self.headers[file] - if dict.info != None: - for data in ('Summary', 'Description', 'Author'): - try: - output.write(" <%s>%s</%s>\n" % ( - string.lower(data), - escape(dict.info[data]), - string.lower(data))) - except: - print "Header %s lacks a %s description" % (module, data) - if dict.info.has_key('Description'): - desc = dict.info['Description'] - if string.find(desc, "DEPRECATED") != -1: - output.write(" <deprecated/>\n") + output.write(" <file name='%s'>\n" % (module)) + dict = self.headers[file] + if dict.info != None: + for data in ('Summary', 'Description', 'Author'): + try: + output.write(" <%s>%s</%s>\n" % ( + string.lower(data), + escape(dict.info[data]), + string.lower(data))) + except: + print "Header %s lacks a %s description" % (module, data) + if dict.info.has_key('Description'): + desc = dict.info['Description'] + if string.find(desc, "DEPRECATED") != -1: + output.write(" <deprecated/>\n") ids = dict.macros.keys() - ids.sort() - for id in uniq(ids): - # Macros are sometime used to masquerade other types. - if dict.functions.has_key(id): - continue - if dict.variables.has_key(id): - continue - if dict.typedefs.has_key(id): - continue - if dict.structs.has_key(id): - continue - if dict.enums.has_key(id): - continue - output.write(" <exports symbol='%s' type='macro'/>\n" % (id)) + ids.sort() + for id in uniq(ids): + # Macros are sometime used to masquerade other types. + if dict.functions.has_key(id): + continue + if dict.variables.has_key(id): + continue + if dict.typedefs.has_key(id): + continue + if dict.structs.has_key(id): + continue + if dict.enums.has_key(id): + continue + output.write(" <exports symbol='%s' type='macro'/>\n" % (id)) ids = dict.enums.keys() - ids.sort() - for id in uniq(ids): - output.write(" <exports symbol='%s' type='enum'/>\n" % (id)) + ids.sort() + for id in uniq(ids): + output.write(" <exports symbol='%s' type='enum'/>\n" % (id)) ids = dict.typedefs.keys() - ids.sort() - for id in uniq(ids): - output.write(" <exports symbol='%s' type='typedef'/>\n" % (id)) + ids.sort() + for id in uniq(ids): + output.write(" <exports symbol='%s' type='typedef'/>\n" % (id)) ids = dict.structs.keys() - ids.sort() - for id in uniq(ids): - output.write(" <exports symbol='%s' type='struct'/>\n" % (id)) + ids.sort() + for id in uniq(ids): + output.write(" <exports symbol='%s' type='struct'/>\n" % (id)) ids = dict.variables.keys() - ids.sort() - for id in uniq(ids): - output.write(" <exports symbol='%s' type='variable'/>\n" % (id)) + ids.sort() + for id in uniq(ids): + output.write(" <exports symbol='%s' type='variable'/>\n" % (id)) ids = dict.functions.keys() - ids.sort() - for id in uniq(ids): - output.write(" <exports symbol='%s' type='function'/>\n" % (id)) - output.write(" </file>\n") + ids.sort() + for id in uniq(ids): + output.write(" <exports symbol='%s' type='function'/>\n" % (id)) + output.write(" </file>\n") def serialize_xrefs_files(self, output): headers = self.headers.keys() headers.sort() for file in headers: - module = self.modulename_file(file) - output.write(" <file name='%s'>\n" % (module)) - dict = self.headers[file] - ids = uniq(dict.functions.keys() + dict.variables.keys() + \ - dict.macros.keys() + dict.typedefs.keys() + \ - dict.structs.keys() + dict.enums.keys()) - ids.sort() - for id in ids: - output.write(" <ref name='%s'/>\n" % (id)) - output.write(" </file>\n") + module = self.modulename_file(file) + output.write(" <file name='%s'>\n" % (module)) + dict = self.headers[file] + ids = uniq(dict.functions.keys() + dict.variables.keys() + \ + dict.macros.keys() + dict.typedefs.keys() + \ + dict.structs.keys() + dict.enums.keys()) + ids.sort() + for id in ids: + output.write(" <ref name='%s'/>\n" % (id)) + output.write(" </file>\n") pass def serialize_xrefs_functions(self, output): funcs = {} - for name in self.idx.functions.keys(): - id = self.idx.functions[name] - try: - (ret, params, desc) = id.info - for param in params: - if param[0] == 'void': - continue - if funcs.has_key(param[0]): - funcs[param[0]].append(name) - else: - funcs[param[0]] = [name] - except: - pass - typ = funcs.keys() - typ.sort() - for type in typ: - if type == '' or type == 'void' or type == "int" or \ - type == "char *" or type == "const char *" : - continue - output.write(" <type name='%s'>\n" % (type)) - ids = funcs[type] - ids.sort() - pid = '' # not sure why we have dups, but get rid of them! - for id in ids: - if id != pid: - output.write(" <ref name='%s'/>\n" % (id)) - pid = id - output.write(" </type>\n") + for name in self.idx.functions.keys(): + id = self.idx.functions[name] + try: + (ret, params, desc) = id.info + for param in params: + if param[0] == 'void': + continue + if funcs.has_key(param[0]): + funcs[param[0]].append(name) + else: + funcs[param[0]] = [name] + except: + pass + typ = funcs.keys() + typ.sort() + for type in typ: + if type == '' or type == 'void' or type == "int" or \ + type == "char *" or type == "const char *" : + continue + output.write(" <type name='%s'>\n" % (type)) + ids = funcs[type] + ids.sort() + pid = '' # not sure why we have dups, but get rid of them! + for id in ids: + if id != pid: + output.write(" <ref name='%s'/>\n" % (id)) + pid = id + output.write(" </type>\n") def serialize_xrefs_constructors(self, output): funcs = {} - for name in self.idx.functions.keys(): - id = self.idx.functions[name] - try: - (ret, params, desc) = id.info - if ret[0] == "void": - continue - if funcs.has_key(ret[0]): - funcs[ret[0]].append(name) - else: - funcs[ret[0]] = [name] - except: - pass - typ = funcs.keys() - typ.sort() - for type in typ: - if type == '' or type == 'void' or type == "int" or \ - type == "char *" or type == "const char *" : - continue - output.write(" <type name='%s'>\n" % (type)) - ids = funcs[type] - ids.sort() - for id in ids: - output.write(" <ref name='%s'/>\n" % (id)) - output.write(" </type>\n") + for name in self.idx.functions.keys(): + id = self.idx.functions[name] + try: + (ret, params, desc) = id.info + if ret[0] == "void": + continue + if funcs.has_key(ret[0]): + funcs[ret[0]].append(name) + else: + funcs[ret[0]] = [name] + except: + pass + typ = funcs.keys() + typ.sort() + for type in typ: + if type == '' or type == 'void' or type == "int" or \ + type == "char *" or type == "const char *" : + continue + output.write(" <type name='%s'>\n" % (type)) + ids = funcs[type] + ids.sort() + for id in ids: + output.write(" <ref name='%s'/>\n" % (id)) + output.write(" </type>\n") def serialize_xrefs_alpha(self, output): - letter = None - ids = self.idx.identifiers.keys() - ids.sort() - for id in ids: - if id[0] != letter: - if letter != None: - output.write(" </letter>\n") - letter = id[0] - output.write(" <letter name='%s'>\n" % (letter)) - output.write(" <ref name='%s'/>\n" % (id)) - if letter != None: - output.write(" </letter>\n") + letter = None + ids = self.idx.identifiers.keys() + ids.sort() + for id in ids: + if id[0] != letter: + if letter != None: + output.write(" </letter>\n") + letter = id[0] + output.write(" <letter name='%s'>\n" % (letter)) + output.write(" <ref name='%s'/>\n" % (id)) + if letter != None: + output.write(" </letter>\n") def serialize_xrefs_references(self, output): typ = self.idx.identifiers.keys() - typ.sort() - for id in typ: - idf = self.idx.identifiers[id] - module = idf.header - output.write(" <reference name='%s' href='%s'/>\n" % (id, - 'html/' + self.basename + '-' + - self.modulename_file(module) + '.html#' + - id)) + typ.sort() + for id in typ: + idf = self.idx.identifiers[id] + module = idf.header + output.write(" <reference name='%s' href='%s'/>\n" % (id, + 'html/' + self.basename + '-' + + self.modulename_file(module) + '.html#' + + id)) def serialize_xrefs_index(self, output): index = self.xref - typ = index.keys() - typ.sort() - letter = None - count = 0 - chunk = 0 - chunks = [] - for id in typ: - if len(index[id]) > 30: - continue - if id[0] != letter: - if letter == None or count > 200: - if letter != None: - output.write(" </letter>\n") - output.write(" </chunk>\n") - count = 0 - chunks.append(["chunk%s" % (chunk -1), first_letter, letter]) - output.write(" <chunk name='chunk%s'>\n" % (chunk)) - first_letter = id[0] - chunk = chunk + 1 - elif letter != None: - output.write(" </letter>\n") - letter = id[0] - output.write(" <letter name='%s'>\n" % (letter)) - output.write(" <word name='%s'>\n" % (id)) - tokens = index[id]; - tokens.sort() - tok = None - for token in tokens: - if tok == token: - continue - tok = token - output.write(" <ref name='%s'/>\n" % (token)) - count = count + 1 - output.write(" </word>\n") - if letter != None: - output.write(" </letter>\n") - output.write(" </chunk>\n") - if count != 0: - chunks.append(["chunk%s" % (chunk -1), first_letter, letter]) - output.write(" <chunks>\n") - for ch in chunks: - output.write(" <chunk name='%s' start='%s' end='%s'/>\n" % ( - ch[0], ch[1], ch[2])) - output.write(" </chunks>\n") + typ = index.keys() + typ.sort() + letter = None + count = 0 + chunk = 0 + chunks = [] + for id in typ: + if len(index[id]) > 30: + continue + if id[0] != letter: + if letter == None or count > 200: + if letter != None: + output.write(" </letter>\n") + output.write(" </chunk>\n") + count = 0 + chunks.append(["chunk%s" % (chunk -1), first_letter, letter]) + output.write(" <chunk name='chunk%s'>\n" % (chunk)) + first_letter = id[0] + chunk = chunk + 1 + elif letter != None: + output.write(" </letter>\n") + letter = id[0] + output.write(" <letter name='%s'>\n" % (letter)) + output.write(" <word name='%s'>\n" % (id)) + tokens = index[id]; + tokens.sort() + tok = None + for token in tokens: + if tok == token: + continue + tok = token + output.write(" <ref name='%s'/>\n" % (token)) + count = count + 1 + output.write(" </word>\n") + if letter != None: + output.write(" </letter>\n") + output.write(" </chunk>\n") + if count != 0: + chunks.append(["chunk%s" % (chunk -1), first_letter, letter]) + output.write(" <chunks>\n") + for ch in chunks: + output.write(" <chunk name='%s' start='%s' end='%s'/>\n" % ( + ch[0], ch[1], ch[2])) + output.write(" </chunks>\n") def serialize_xrefs(self, output): - output.write(" <references>\n") - self.serialize_xrefs_references(output) - output.write(" </references>\n") - output.write(" <alpha>\n") - self.serialize_xrefs_alpha(output) - output.write(" </alpha>\n") - output.write(" <constructors>\n") - self.serialize_xrefs_constructors(output) - output.write(" </constructors>\n") - output.write(" <functions>\n") - self.serialize_xrefs_functions(output) - output.write(" </functions>\n") - output.write(" <files>\n") - self.serialize_xrefs_files(output) - output.write(" </files>\n") - output.write(" <index>\n") - self.serialize_xrefs_index(output) - output.write(" </index>\n") + output.write(" <references>\n") + self.serialize_xrefs_references(output) + output.write(" </references>\n") + output.write(" <alpha>\n") + self.serialize_xrefs_alpha(output) + output.write(" </alpha>\n") + output.write(" <constructors>\n") + self.serialize_xrefs_constructors(output) + output.write(" </constructors>\n") + output.write(" <functions>\n") + self.serialize_xrefs_functions(output) + output.write(" </functions>\n") + output.write(" <files>\n") + self.serialize_xrefs_files(output) + output.write(" </files>\n") + output.write(" <index>\n") + self.serialize_xrefs_index(output) + output.write(" </index>\n") def serialize(self): filename = "%s/%s-api.xml" % (self.path, self.name) @@ -2124,10 +2124,10 @@ def rebuild(): print "Rebuilding API description for libvirt" builder = docBuilder("libvirt", srcdir, ["src", "src/util", "include/libvirt"], - []) + []) else: print "rebuild() failed, unable to guess the module" - return None + return None builder.scan() builder.analyze() builder.serialize() @@ -2146,4 +2146,4 @@ if __name__ == "__main__": debug = 1 parse(sys.argv[1]) else: - rebuild() + rebuild() diff --git a/docs/index.py b/docs/index.py index 17683c5..df6bd81 100755 --- a/docs/index.py +++ b/docs/index.py @@ -61,56 +61,56 @@ libxml2.registerErrorHandler(callback, None) TABLES={ "symbols" : """CREATE TABLE symbols ( name varchar(255) BINARY NOT NULL, - module varchar(255) BINARY NOT NULL, + module varchar(255) BINARY NOT NULL, type varchar(25) NOT NULL, - descr varchar(255), - UNIQUE KEY name (name), - KEY module (module))""", + descr varchar(255), + UNIQUE KEY name (name), + KEY module (module))""", "words" : """CREATE TABLE words ( name varchar(50) BINARY NOT NULL, - symbol varchar(255) BINARY NOT NULL, + symbol varchar(255) BINARY NOT NULL, relevance int, - KEY name (name), - KEY symbol (symbol), - UNIQUE KEY ID (name, symbol))""", + KEY name (name), + KEY symbol (symbol), + UNIQUE KEY ID (name, symbol))""", "wordsHTML" : """CREATE TABLE wordsHTML ( name varchar(50) BINARY NOT NULL, - resource varchar(255) BINARY NOT NULL, - section varchar(255), - id varchar(50), + resource varchar(255) BINARY NOT NULL, + section varchar(255), + id varchar(50), relevance int, - KEY name (name), - KEY resource (resource), - UNIQUE KEY ref (name, resource))""", + KEY name (name), + KEY resource (resource), + UNIQUE KEY ref (name, resource))""", "wordsArchive" : """CREATE TABLE wordsArchive ( name varchar(50) BINARY NOT NULL, - ID int(11) NOT NULL, + ID int(11) NOT NULL, relevance int, - KEY name (name), - UNIQUE KEY ref (name, ID))""", + KEY name (name), + UNIQUE KEY ref (name, ID))""", "pages" : """CREATE TABLE pages ( resource varchar(255) BINARY NOT NULL, - title varchar(255) BINARY NOT NULL, - UNIQUE KEY name (resource))""", + title varchar(255) BINARY NOT NULL, + UNIQUE KEY name (resource))""", "archives" : """CREATE TABLE archives ( ID int(11) NOT NULL auto_increment, resource varchar(255) BINARY NOT NULL, - title varchar(255) BINARY NOT NULL, - UNIQUE KEY id (ID,resource(255)), - INDEX (ID), - INDEX (resource))""", + title varchar(255) BINARY NOT NULL, + UNIQUE KEY id (ID,resource(255)), + INDEX (ID), + INDEX (resource))""", "Queries" : """CREATE TABLE Queries ( ID int(11) NOT NULL auto_increment, - Value varchar(50) NOT NULL, - Count int(11) NOT NULL, - UNIQUE KEY id (ID,Value(35)), - INDEX (ID))""", + Value varchar(50) NOT NULL, + Count int(11) NOT NULL, + UNIQUE KEY id (ID,Value(35)), + INDEX (ID))""", "AllQueries" : """CREATE TABLE AllQueries ( ID int(11) NOT NULL auto_increment, - Value varchar(50) NOT NULL, - Count int(11) NOT NULL, - UNIQUE KEY id (ID,Value(35)), - INDEX (ID))""", + Value varchar(50) NOT NULL, + Count int(11) NOT NULL, + UNIQUE KEY id (ID,Value(35)), + INDEX (ID))""", } # @@ -120,9 +120,9 @@ API="libvirt-api.xml" DB=None ######################################################################### -# # -# MySQL database interfaces # -# # +# # +# MySQL database interfaces # +# # ######################################################################### def createTable(db, name): global TABLES @@ -141,7 +141,7 @@ def createTable(db, name): ret = c.execute(TABLES[name]) except: print "Failed to create table %s" % (name) - return -1 + return -1 return ret def checkTables(db, verbose = 1): @@ -152,38 +152,38 @@ def checkTables(db, verbose = 1): c = db.cursor() nbtables = c.execute("show tables") if verbose: - print "Found %d tables" % (nbtables) + print "Found %d tables" % (nbtables) tables = {} i = 0 while i < nbtables: l = c.fetchone() - name = l[0] - tables[name] = {} + name = l[0] + tables[name] = {} i = i + 1 for table in TABLES.keys(): if not tables.has_key(table): - print "table %s missing" % (table) - createTable(db, table) - try: - ret = c.execute("SELECT count(*) from %s" % table); - row = c.fetchone() - if verbose: - print "Table %s contains %d records" % (table, row[0]) - except: - print "Troubles with table %s : repairing" % (table) - ret = c.execute("repair table %s" % table); - print "repairing returned %d" % (ret) - ret = c.execute("SELECT count(*) from %s" % table); - row = c.fetchone() - print "Table %s contains %d records" % (table, row[0]) + print "table %s missing" % (table) + createTable(db, table) + try: + ret = c.execute("SELECT count(*) from %s" % table); + row = c.fetchone() + if verbose: + print "Table %s contains %d records" % (table, row[0]) + except: + print "Troubles with table %s : repairing" % (table) + ret = c.execute("repair table %s" % table); + print "repairing returned %d" % (ret) + ret = c.execute("SELECT count(*) from %s" % table); + row = c.fetchone() + print "Table %s contains %d records" % (table, row[0]) if verbose: - print "checkTables finished" + print "checkTables finished" # make sure apache can access the tables read-only try: - ret = c.execute("GRANT SELECT ON libvir.* TO nobody@localhost") - ret = c.execute("GRANT INSERT,SELECT,UPDATE ON libvir.Queries TO nobody@localhost") + ret = c.execute("GRANT SELECT ON libvir.* TO nobody@localhost") + ret = c.execute("GRANT INSERT,SELECT,UPDATE ON libvir.Queries TO nobody@localhost") except: pass return 0 @@ -193,10 +193,10 @@ def openMySQL(db="libvir", passwd=None, verbose = 1): if passwd == None: try: - passwd = os.environ["MySQL_PASS"] - except: - print "No password available, set environment MySQL_PASS" - sys.exit(1) + passwd = os.environ["MySQL_PASS"] + except: + print "No password available, set environment MySQL_PASS" + sys.exit(1) DB = MySQLdb.connect(passwd=passwd, db=db) if DB == None: @@ -218,19 +218,19 @@ def updateWord(name, symbol, relevance): c = DB.cursor() try: - ret = c.execute( + ret = c.execute( """INSERT INTO words (name, symbol, relevance) VALUES ('%s','%s', %d)""" % - (name, symbol, relevance)) + (name, symbol, relevance)) except: try: - ret = c.execute( + ret = c.execute( """UPDATE words SET relevance = %d where name = '%s' and symbol = '%s'""" % - (relevance, name, symbol)) - except: - print "Update word (%s, %s, %s) failed command" % (name, symbol, relevance) - print "UPDATE words SET relevance = %d where name = '%s' and symbol = '%s'" % (relevance, name, symbol) - print sys.exc_type, sys.exc_value - return -1 + (relevance, name, symbol)) + except: + print "Update word (%s, %s, %s) failed command" % (name, symbol, relevance) + print "UPDATE words SET relevance = %d where name = '%s' and symbol = '%s'" % (relevance, name, symbol) + print sys.exc_type, sys.exc_value + return -1 return ret @@ -250,28 +250,28 @@ def updateSymbol(name, module, type, desc): return -1 try: - desc = string.replace(desc, "'", " ") - l = string.split(desc, ".") - desc = l[0] - desc = desc[0:99] + desc = string.replace(desc, "'", " ") + l = string.split(desc, ".") + desc = l[0] + desc = desc[0:99] except: desc = "" c = DB.cursor() try: - ret = c.execute( + ret = c.execute( """INSERT INTO symbols (name, module, type, descr) VALUES ('%s','%s', '%s', '%s')""" % (name, module, type, desc)) except: try: - ret = c.execute( + ret = c.execute( """UPDATE symbols SET module='%s', type='%s', descr='%s' where name='%s'""" % (module, type, desc, name)) except: - print "Update symbol (%s, %s, %s) failed command" % (name, module, type) - print """UPDATE symbols SET module='%s', type='%s', descr='%s' where name='%s'""" % (module, type, desc, name) - print sys.exc_type, sys.exc_value - return -1 + print "Update symbol (%s, %s, %s) failed command" % (name, module, type) + print """UPDATE symbols SET module='%s', type='%s', descr='%s' where name='%s'""" % (module, type, desc, name) + print sys.exc_type, sys.exc_value + return -1 return ret @@ -308,19 +308,19 @@ def addPage(resource, title): c = DB.cursor() try: - ret = c.execute( - """INSERT INTO pages (resource, title) VALUES ('%s','%s')""" % + ret = c.execute( + """INSERT INTO pages (resource, title) VALUES ('%s','%s')""" % (resource, title)) except: try: - ret = c.execute( - """UPDATE pages SET title='%s' WHERE resource='%s'""" % + ret = c.execute( + """UPDATE pages SET title='%s' WHERE resource='%s'""" % (title, resource)) except: - print "Update symbol (%s, %s, %s) failed command" % (name, module, type) - print """UPDATE pages SET title='%s' WHERE resource='%s'""" % (title, resource) - print sys.exc_type, sys.exc_value - return -1 + print "Update symbol (%s, %s, %s) failed command" % (name, module, type) + print """UPDATE pages SET title='%s' WHERE resource='%s'""" % (title, resource) + print sys.exc_type, sys.exc_value + return -1 return ret @@ -340,27 +340,27 @@ def updateWordHTML(name, resource, desc, id, relevance): if desc == None: desc = "" else: - try: - desc = string.replace(desc, "'", " ") - desc = desc[0:99] - except: - desc = "" + try: + desc = string.replace(desc, "'", " ") + desc = desc[0:99] + except: + desc = "" c = DB.cursor() try: - ret = c.execute( + ret = c.execute( """INSERT INTO wordsHTML (name, resource, section, id, relevance) VALUES ('%s','%s', '%s', '%s', '%d')""" % (name, resource, desc, id, relevance)) except: try: - ret = c.execute( + ret = c.execute( """UPDATE wordsHTML SET section='%s', id='%s', relevance='%d' where name='%s' and resource='%s'""" % (desc, id, relevance, name, resource)) except: - print "Update symbol (%s, %s, %d) failed command" % (name, resource, relevance) - print """UPDATE wordsHTML SET section='%s', id='%s', relevance='%d' where name='%s' and resource='%s'""" % (desc, id, relevance, name, resource) - print sys.exc_type, sys.exc_value - return -1 + print "Update symbol (%s, %s, %d) failed command" % (name, resource, relevance) + print """UPDATE wordsHTML SET section='%s', id='%s', relevance='%d' where name='%s' and resource='%s'""" % (desc, id, relevance, name, resource) + print sys.exc_type, sys.exc_value + return -1 return ret @@ -376,13 +376,13 @@ def checkXMLMsgArchive(url): c = DB.cursor() try: - ret = c.execute( - """SELECT ID FROM archives WHERE resource='%s'""" % (url)) - row = c.fetchone() - if row == None: - return -1 + ret = c.execute( + """SELECT ID FROM archives WHERE resource='%s'""" % (url)) + row = c.fetchone() + if row == None: + return -1 except: - return -1 + return -1 return row[0] @@ -398,22 +398,22 @@ def addXMLMsgArchive(url, title): if title == None: title = "" else: - title = string.replace(title, "'", " ") - title = title[0:99] + title = string.replace(title, "'", " ") + title = title[0:99] c = DB.cursor() try: cmd = """INSERT INTO archives (resource, title) VALUES ('%s','%s')""" % (url, title) ret = c.execute(cmd) - cmd = """SELECT ID FROM archives WHERE resource='%s'""" % (url) + cmd = """SELECT ID FROM archives WHERE resource='%s'""" % (url) ret = c.execute(cmd) - row = c.fetchone() - if row == None: - print "addXMLMsgArchive failed to get the ID: %s" % (url) - return -1 + row = c.fetchone() + if row == None: + print "addXMLMsgArchive failed to get the ID: %s" % (url) + return -1 except: print "addXMLMsgArchive failed command: %s" % (cmd) - return -1 + return -1 return((int)(row[0])) @@ -431,26 +431,26 @@ def updateWordArchive(name, id, relevance): c = DB.cursor() try: - ret = c.execute( + ret = c.execute( """INSERT INTO wordsArchive (name, id, relevance) VALUES ('%s', '%d', '%d')""" % (name, id, relevance)) except: try: - ret = c.execute( + ret = c.execute( """UPDATE wordsArchive SET relevance='%d' where name='%s' and ID='%d'""" % (relevance, name, id)) except: - print "Update word archive (%s, %d, %d) failed command" % (name, id, relevance) - print """UPDATE wordsArchive SET relevance='%d' where name='%s' and ID='%d'""" % (relevance, name, id) - print sys.exc_type, sys.exc_value - return -1 + print "Update word archive (%s, %d, %d) failed command" % (name, id, relevance) + print """UPDATE wordsArchive SET relevance='%d' where name='%s' and ID='%d'""" % (relevance, name, id) + print sys.exc_type, sys.exc_value + return -1 return ret ######################################################################### -# # -# Word dictionary and analysis routines # -# # +# # +# Word dictionary and analysis routines # +# # ######################################################################### # @@ -516,18 +516,18 @@ def splitIdentifier(str): ret = [] while str != "": cur = string.lower(str[0]) - str = str[1:] - if ((cur < 'a') or (cur > 'z')): - continue - while (str != "") and (str[0] >= 'A') and (str[0] <= 'Z'): - cur = cur + string.lower(str[0]) - str = str[1:] - while (str != "") and (str[0] >= 'a') and (str[0] <= 'z'): - cur = cur + str[0] - str = str[1:] - while (str != "") and (str[0] >= '0') and (str[0] <= '9'): - str = str[1:] - ret.append(cur) + str = str[1:] + if ((cur < 'a') or (cur > 'z')): + continue + while (str != "") and (str[0] >= 'A') and (str[0] <= 'Z'): + cur = cur + string.lower(str[0]) + str = str[1:] + while (str != "") and (str[0] >= 'a') and (str[0] <= 'z'): + cur = cur + str[0] + str = str[1:] + while (str != "") and (str[0] >= '0') and (str[0] <= '9'): + str = str[1:] + ret.append(cur) return ret def addWord(word, module, symbol, relevance): @@ -544,15 +544,15 @@ def addWord(word, module, symbol, relevance): if wordsDict.has_key(word): d = wordsDict[word] - if d == None: - return 0 - if len(d) > 500: - wordsDict[word] = None - return 0 - try: - relevance = relevance + d[(module, symbol)] - except: - pass + if d == None: + return 0 + if len(d) > 500: + wordsDict[word] = None + return 0 + try: + relevance = relevance + d[(module, symbol)] + except: + pass else: wordsDict[word] = {} wordsDict[word][(module, symbol)] = relevance @@ -565,8 +565,8 @@ def addString(str, module, symbol, relevance): str = cleanupWordsString(str) l = string.split(str) for word in l: - if len(word) > 2: - ret = ret + addWord(word, module, symbol, 5) + if len(word) > 2: + ret = ret + addWord(word, module, symbol, 5) return ret @@ -586,18 +586,18 @@ def addWordHTML(word, resource, id, section, relevance): if wordsDictHTML.has_key(word): d = wordsDictHTML[word] - if d == None: - print "skipped %s" % (word) - return 0 - try: - (r,i,s) = d[resource] - if i != None: - id = i - if s != None: - section = s - relevance = relevance + r - except: - pass + if d == None: + print "skipped %s" % (word) + return 0 + try: + (r,i,s) = d[resource] + if i != None: + id = i + if s != None: + section = s + relevance = relevance + r + except: + pass else: wordsDictHTML[word] = {} d = wordsDictHTML[word]; @@ -611,15 +611,15 @@ def addStringHTML(str, resource, id, section, relevance): str = cleanupWordsString(str) l = string.split(str) for word in l: - if len(word) > 2: - try: - r = addWordHTML(word, resource, id, section, relevance) - if r < 0: - print "addWordHTML failed: %s %s" % (word, resource) - ret = ret + r - except: - print "addWordHTML failed: %s %s %d" % (word, resource, relevance) - print sys.exc_type, sys.exc_value + if len(word) > 2: + try: + r = addWordHTML(word, resource, id, section, relevance) + if r < 0: + print "addWordHTML failed: %s %s" % (word, resource) + ret = ret + r + except: + print "addWordHTML failed: %s %s %d" % (word, resource, relevance) + print sys.exc_type, sys.exc_value return ret @@ -637,14 +637,14 @@ def addWordArchive(word, id, relevance): if wordsDictArchive.has_key(word): d = wordsDictArchive[word] - if d == None: - print "skipped %s" % (word) - return 0 - try: - r = d[id] - relevance = relevance + r - except: - pass + if d == None: + print "skipped %s" % (word) + return 0 + try: + r = d[id] + relevance = relevance + r + except: + pass else: wordsDictArchive[word] = {} d = wordsDictArchive[word]; @@ -659,22 +659,22 @@ def addStringArchive(str, id, relevance): l = string.split(str) for word in l: i = len(word) - if i > 2: - try: - r = addWordArchive(word, id, relevance) - if r < 0: - print "addWordArchive failed: %s %s" % (word, id) - else: - ret = ret + r - except: - print "addWordArchive failed: %s %s %d" % (word, id, relevance) - print sys.exc_type, sys.exc_value + if i > 2: + try: + r = addWordArchive(word, id, relevance) + if r < 0: + print "addWordArchive failed: %s %s" % (word, id) + else: + ret = ret + r + except: + print "addWordArchive failed: %s %s %d" % (word, id, relevance) + print sys.exc_type, sys.exc_value return ret ######################################################################### -# # -# XML API description analysis # -# # +# # +# XML API description analysis # +# # ######################################################################### def loadAPI(filename): @@ -690,7 +690,7 @@ def foundExport(file, symbol): addFunction(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 def analyzeAPIFile(top): @@ -699,12 +699,12 @@ def analyzeAPIFile(top): cur = top.children while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "exports": - count = count + foundExport(name, cur.prop("symbol")) - else: - print "unexpected element %s in API doc <file name='%s'>" % (name) + cur = cur.next + continue + if cur.name == "exports": + count = count + foundExport(name, cur.prop("symbol")) + else: + print "unexpected element %s in API doc <file name='%s'>" % (name) cur = cur.next return count @@ -714,12 +714,12 @@ def analyzeAPIFiles(top): while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "file": - count = count + analyzeAPIFile(cur) - else: - print "unexpected element %s in API doc <files>" % (cur.name) + cur = cur.next + continue + if cur.name == "file": + count = count + analyzeAPIFile(cur) + else: + print "unexpected element %s in API doc <files>" % (cur.name) cur = cur.next return count @@ -734,7 +734,7 @@ def analyzeAPIEnum(top): addEnum(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 @@ -749,7 +749,7 @@ def analyzeAPIConst(top): addConst(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 @@ -764,7 +764,7 @@ def analyzeAPIType(top): addType(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 def analyzeAPIFunctype(top): @@ -778,7 +778,7 @@ def analyzeAPIFunctype(top): addFunctype(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 def analyzeAPIStruct(top): @@ -792,16 +792,16 @@ def analyzeAPIStruct(top): addStruct(symbol, file) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) info = top.prop("info") if info != None: - info = string.replace(info, "'", " ") - info = string.strip(info) - l = string.split(info) - for word in l: - if len(word) > 2: - addWord(word, file, symbol, 5) + info = string.replace(info, "'", " ") + info = string.strip(info) + l = string.split(info) + for word in l: + if len(word) > 2: + addWord(word, file, symbol, 5) return 1 def analyzeAPIMacro(top): @@ -818,19 +818,19 @@ def analyzeAPIMacro(top): cur = top.children while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "info": - info = cur.content - break + cur = cur.next + continue + if cur.name == "info": + info = cur.content + break cur = cur.next l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) if info == None: - addMacro(symbol, file) + addMacro(symbol, file) print "Macro %s description has no <info>" % (symbol) return 0 @@ -839,8 +839,8 @@ def analyzeAPIMacro(top): addMacro(symbol, file, info) l = string.split(info) for word in l: - if len(word) > 2: - addWord(word, file, symbol, 5) + if len(word) > 2: + addWord(word, file, symbol, 5) return 1 def analyzeAPIFunction(top): @@ -857,40 +857,40 @@ def analyzeAPIFunction(top): cur = top.children while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "info": - info = cur.content - elif cur.name == "return": - rinfo = cur.prop("info") - if rinfo != None: - rinfo = string.replace(rinfo, "'", " ") - rinfo = string.strip(rinfo) - addString(rinfo, file, symbol, 7) - elif cur.name == "arg": - ainfo = cur.prop("info") - if ainfo != None: - ainfo = string.replace(ainfo, "'", " ") - ainfo = string.strip(ainfo) - addString(ainfo, file, symbol, 5) - name = cur.prop("name") - if name != None: - name = string.replace(name, "'", " ") - name = string.strip(name) - addWord(name, file, symbol, 7) + cur = cur.next + continue + if cur.name == "info": + info = cur.content + elif cur.name == "return": + rinfo = cur.prop("info") + if rinfo != None: + rinfo = string.replace(rinfo, "'", " ") + rinfo = string.strip(rinfo) + addString(rinfo, file, symbol, 7) + elif cur.name == "arg": + ainfo = cur.prop("info") + if ainfo != None: + ainfo = string.replace(ainfo, "'", " ") + ainfo = string.strip(ainfo) + addString(ainfo, file, symbol, 5) + name = cur.prop("name") + if name != None: + name = string.replace(name, "'", " ") + name = string.strip(name) + addWord(name, file, symbol, 7) cur = cur.next if info == None: print "Function %s description has no <info>" % (symbol) - addFunction(symbol, file, "") + addFunction(symbol, file, "") else: info = string.replace(info, "'", " ") - info = string.strip(info) - addFunction(symbol, file, info) + info = string.strip(info) + addFunction(symbol, file, info) addString(info, file, symbol, 5) l = splitIdentifier(symbol) for word in l: - addWord(word, file, symbol, 10) + addWord(word, file, symbol, 10) return 1 @@ -900,24 +900,24 @@ def analyzeAPISymbols(top): while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "macro": - count = count + analyzeAPIMacro(cur) - elif cur.name == "function": - count = count + analyzeAPIFunction(cur) - elif cur.name == "const": - count = count + analyzeAPIConst(cur) - elif cur.name == "typedef": - count = count + analyzeAPIType(cur) - elif cur.name == "struct": - count = count + analyzeAPIStruct(cur) - elif cur.name == "enum": - count = count + analyzeAPIEnum(cur) - elif cur.name == "functype": - count = count + analyzeAPIFunctype(cur) - else: - print "unexpected element %s in API doc <files>" % (cur.name) + cur = cur.next + continue + if cur.name == "macro": + count = count + analyzeAPIMacro(cur) + elif cur.name == "function": + count = count + analyzeAPIFunction(cur) + elif cur.name == "const": + count = count + analyzeAPIConst(cur) + elif cur.name == "typedef": + count = count + analyzeAPIType(cur) + elif cur.name == "struct": + count = count + analyzeAPIStruct(cur) + elif cur.name == "enum": + count = count + analyzeAPIEnum(cur) + elif cur.name == "functype": + count = count + analyzeAPIFunctype(cur) + else: + print "unexpected element %s in API doc <files>" % (cur.name) cur = cur.next return count @@ -932,22 +932,22 @@ def analyzeAPI(doc): cur = root.children while cur != None: if cur.type == 'text': - cur = cur.next - continue - if cur.name == "files": - pass -# count = count + analyzeAPIFiles(cur) - elif cur.name == "symbols": - count = count + analyzeAPISymbols(cur) - else: - print "unexpected element %s in API doc" % (cur.name) + cur = cur.next + continue + if cur.name == "files": + pass +# count = count + analyzeAPIFiles(cur) + elif cur.name == "symbols": + count = count + analyzeAPISymbols(cur) + else: + print "unexpected element %s in API doc" % (cur.name) cur = cur.next return count ######################################################################### -# # -# Web pages parsing and analysis # -# # +# # +# Web pages parsing and analysis # +# # ######################################################################### import glob @@ -955,8 +955,8 @@ import glob def analyzeHTMLText(doc, resource, p, section, id): words = 0 try: - content = p.content - words = words + addStringHTML(content, resource, id, section, 5) + content = p.content + words = words + addStringHTML(content, resource, id, section, 5) except: return -1 return words @@ -964,8 +964,8 @@ def analyzeHTMLText(doc, resource, p, section, id): def analyzeHTMLPara(doc, resource, p, section, id): words = 0 try: - content = p.content - words = words + addStringHTML(content, resource, id, section, 5) + content = p.content + words = words + addStringHTML(content, resource, id, section, 5) except: return -1 return words @@ -973,8 +973,8 @@ def analyzeHTMLPara(doc, resource, p, section, id): def analyzeHTMLPre(doc, resource, p, section, id): words = 0 try: - content = p.content - words = words + addStringHTML(content, resource, id, section, 5) + content = p.content + words = words + addStringHTML(content, resource, id, section, 5) except: return -1 return words @@ -982,8 +982,8 @@ def analyzeHTMLPre(doc, resource, p, section, id): def analyzeHTML(doc, resource, p, section, id): words = 0 try: - content = p.content - words = words + addStringHTML(content, resource, id, section, 5) + content = p.content + words = words + addStringHTML(content, resource, id, section, 5) except: return -1 return words @@ -992,36 +992,36 @@ def analyzeHTML(doc, resource): para = 0; ctxt = doc.xpathNewContext() try: - res = ctxt.xpathEval("//head/title") - title = res[0].content + res = ctxt.xpathEval("//head/title") + title = res[0].content except: title = "Page %s" % (resource) addPage(resource, title) try: - items = ctxt.xpathEval("//h1 | //h2 | //h3 | //text()") - section = title - id = "" - for item in items: - if item.name == 'h1' or item.name == 'h2' or item.name == 'h3': - section = item.content - if item.prop("id"): - id = item.prop("id") - elif item.prop("name"): - id = item.prop("name") - elif item.type == 'text': - analyzeHTMLText(doc, resource, item, section, id) - para = para + 1 - elif item.name == 'p': - analyzeHTMLPara(doc, resource, item, section, id) - para = para + 1 - elif item.name == 'pre': - analyzeHTMLPre(doc, resource, item, section, id) - para = para + 1 - else: - print "Page %s, unexpected %s element" % (resource, item.name) + items = ctxt.xpathEval("//h1 | //h2 | //h3 | //text()") + section = title + id = "" + for item in items: + if item.name == 'h1' or item.name == 'h2' or item.name == 'h3': + section = item.content + if item.prop("id"): + id = item.prop("id") + elif item.prop("name"): + id = item.prop("name") + elif item.type == 'text': + analyzeHTMLText(doc, resource, item, section, id) + para = para + 1 + elif item.name == 'p': + analyzeHTMLPara(doc, resource, item, section, id) + para = para + 1 + elif item.name == 'pre': + analyzeHTMLPre(doc, resource, item, section, id) + para = para + 1 + else: + print "Page %s, unexpected %s element" % (resource, item.name) except: print "Page %s: problem analyzing" % (resource) - print sys.exc_type, sys.exc_value + print sys.exc_type, sys.exc_value return para @@ -1029,35 +1029,35 @@ def analyzeHTMLPages(): ret = 0 HTMLfiles = glob.glob("*.html") + glob.glob("tutorial/*.html") + \ glob.glob("CIM/*.html") + glob.glob("ocaml/*.html") + \ - glob.glob("ruby/*.html") + glob.glob("ruby/*.html") for html in HTMLfiles: - if html[0:3] == "API": - continue - if html == "xml.html": - continue - try: - doc = libxml2.parseFile(html) - except: - doc = libxml2.htmlParseFile(html, None) - try: - res = analyzeHTML(doc, html) - print "Parsed %s : %d paragraphs" % (html, res) - ret = ret + 1 - except: - print "could not parse %s" % (html) + if html[0:3] == "API": + continue + if html == "xml.html": + continue + try: + doc = libxml2.parseFile(html) + except: + doc = libxml2.htmlParseFile(html, None) + try: + res = analyzeHTML(doc, html) + print "Parsed %s : %d paragraphs" % (html, res) + ret = ret + 1 + except: + print "could not parse %s" % (html) return ret ######################################################################### -# # -# Mail archives parsing and analysis # -# # +# # +# Mail archives parsing and analysis # +# # ######################################################################### import time def getXMLDateArchive(t = None): if t == None: - t = time.time() + t = time.time() T = time.gmtime(t) month = time.strftime("%B", T) year = T[0] @@ -1073,9 +1073,9 @@ def scanXMLMsgArchive(url, title, force = 0): return 0 if ID == -1: - ID = addXMLMsgArchive(url, title) - if ID == -1: - return 0 + ID = addXMLMsgArchive(url, title) + if ID == -1: + return 0 try: print "Loading %s" % (url) @@ -1084,7 +1084,7 @@ def scanXMLMsgArchive(url, title, force = 0): doc = None if doc == None: print "Failed to parse %s" % (url) - return 0 + return 0 addStringArchive(title, ID, 20) ctxt = doc.xpathNewContext() @@ -1102,41 +1102,41 @@ def scanXMLDateArchive(t = None, force = 0): url = getXMLDateArchive(t) print "loading %s" % (url) try: - doc = libxml2.htmlParseFile(url, None); + doc = libxml2.htmlParseFile(url, None); except: doc = None if doc == None: print "Failed to parse %s" % (url) - return -1 + return -1 ctxt = doc.xpathNewContext() anchors = ctxt.xpathEval("//a[@href]") links = 0 newmsg = 0 for anchor in anchors: - href = anchor.prop("href") - if href == None or href[0:3] != "msg": - continue + href = anchor.prop("href") + if href == None or href[0:3] != "msg": + continue try: - links = links + 1 + links = links + 1 - msg = libxml2.buildURI(href, url) - title = anchor.content - if title != None and title[0:4] == 'Re: ': - title = title[4:] - if title != None and title[0:6] == '[xml] ': - title = title[6:] - newmsg = newmsg + scanXMLMsgArchive(msg, title, force) + msg = libxml2.buildURI(href, url) + title = anchor.content + if title != None and title[0:4] == 'Re: ': + title = title[4:] + if title != None and title[0:6] == '[xml] ': + title = title[6:] + newmsg = newmsg + scanXMLMsgArchive(msg, title, force) - except: - pass + except: + pass return newmsg ######################################################################### -# # -# Main code: open the DB, the API XML and analyze it # -# # +# # +# Main code: open the DB, the API XML and analyze it # +# # ######################################################################### def analyzeArchives(t = None, force = 0): global wordsDictArchive @@ -1147,14 +1147,14 @@ def analyzeArchives(t = None, force = 0): i = 0 skipped = 0 for word in wordsDictArchive.keys(): - refs = wordsDictArchive[word] - if refs == None: - skipped = skipped + 1 - continue; - for id in refs.keys(): - relevance = refs[id] - updateWordArchive(word, id, relevance) - i = i + 1 + refs = wordsDictArchive[word] + if refs == None: + skipped = skipped + 1 + continue; + for id in refs.keys(): + relevance = refs[id] + updateWordArchive(word, id, relevance) + i = i + 1 print "Found %d associations in HTML pages" % (i) @@ -1167,14 +1167,14 @@ def analyzeHTMLTop(): i = 0 skipped = 0 for word in wordsDictHTML.keys(): - refs = wordsDictHTML[word] - if refs == None: - skipped = skipped + 1 - continue; - for resource in refs.keys(): - (relevance, id, section) = refs[resource] - updateWordHTML(word, resource, section, id, relevance) - i = i + 1 + refs = wordsDictHTML[word] + if refs == None: + skipped = skipped + 1 + continue; + for resource in refs.keys(): + (relevance, id, section) = refs[resource] + updateWordHTML(word, resource, section, id, relevance) + i = i + 1 print "Found %d associations in HTML pages" % (i) @@ -1183,26 +1183,26 @@ def analyzeAPITop(): global API try: - doc = loadAPI(API) - ret = analyzeAPI(doc) - print "Analyzed %d blocs" % (ret) - doc.freeDoc() + doc = loadAPI(API) + ret = analyzeAPI(doc) + print "Analyzed %d blocs" % (ret) + doc.freeDoc() except: - print "Failed to parse and analyze %s" % (API) - print sys.exc_type, sys.exc_value - sys.exit(1) + print "Failed to parse and analyze %s" % (API) + print sys.exc_type, sys.exc_value + sys.exit(1) print "Indexed %d words" % (len(wordsDict)) i = 0 skipped = 0 for word in wordsDict.keys(): - refs = wordsDict[word] - if refs == None: - skipped = skipped + 1 - continue; - for (module, symbol) in refs.keys(): - updateWord(word, symbol, refs[(module, symbol)]) - i = i + 1 + refs = wordsDict[word] + if refs == None: + skipped = skipped + 1 + continue; + for (module, symbol) in refs.keys(): + updateWord(word, symbol, refs[(module, symbol)]) + i = i + 1 print "Found %d associations, skipped %d words" % (i, skipped) @@ -1212,53 +1212,53 @@ def usage(): def main(): try: - openMySQL() + openMySQL() except: - print "Failed to open the database" - print sys.exc_type, sys.exc_value - sys.exit(1) + print "Failed to open the database" + print sys.exc_type, sys.exc_value + sys.exit(1) args = sys.argv[1:] force = 0 if args: i = 0 - while i < len(args): - if args[i] == '--force': - force = 1 - elif args[i] == '--archive': - analyzeArchives(None, force) - elif args[i] == '--archive-year': - i = i + 1; - year = args[i] - months = ["January" , "February", "March", "April", "May", - "June", "July", "August", "September", "October", - "November", "December"]; - for month in months: - try: - str = "%s-%s" % (year, month) - T = time.strptime(str, "%Y-%B") - t = time.mktime(T) + 3600 * 24 * 10; - analyzeArchives(t, force) - except: - print "Failed to index month archive:" - print sys.exc_type, sys.exc_value - elif args[i] == '--archive-month': - i = i + 1; - month = args[i] - try: - T = time.strptime(month, "%Y-%B") - t = time.mktime(T) + 3600 * 24 * 10; - analyzeArchives(t, force) - except: - print "Failed to index month archive:" - print sys.exc_type, sys.exc_value - elif args[i] == '--API': - analyzeAPITop() - elif args[i] == '--docs': - analyzeHTMLTop() - else: - usage() - i = i + 1 + while i < len(args): + if args[i] == '--force': + force = 1 + elif args[i] == '--archive': + analyzeArchives(None, force) + elif args[i] == '--archive-year': + i = i + 1; + year = args[i] + months = ["January" , "February", "March", "April", "May", + "June", "July", "August", "September", "October", + "November", "December"]; + for month in months: + try: + str = "%s-%s" % (year, month) + T = time.strptime(str, "%Y-%B") + t = time.mktime(T) + 3600 * 24 * 10; + analyzeArchives(t, force) + except: + print "Failed to index month archive:" + print sys.exc_type, sys.exc_value + elif args[i] == '--archive-month': + i = i + 1; + month = args[i] + try: + T = time.strptime(month, "%Y-%B") + t = time.mktime(T) + 3600 * 24 * 10; + analyzeArchives(t, force) + except: + print "Failed to index month archive:" + print sys.exc_type, sys.exc_value + elif args[i] == '--API': + analyzeAPITop() + elif args[i] == '--docs': + analyzeHTMLTop() + else: + usage() + i = i + 1 else: usage() diff --git a/python/generator.py b/python/generator.py index 15751bd..ee9dfe4 100755 --- a/python/generator.py +++ b/python/generator.py @@ -90,8 +90,8 @@ class docParser(xml.sax.handler.ContentHandler): self.function_arg_info = None if attrs.has_key('name'): self.function_arg_name = attrs['name'] - if self.function_arg_name == 'from': - self.function_arg_name = 'frm' + if self.function_arg_name == 'from': + self.function_arg_name = 'frm' if attrs.has_key('type'): self.function_arg_type = attrs['type'] if attrs.has_key('info'): @@ -409,8 +409,8 @@ def print_function_wrapper(name, output, export, include): if name in skip_function: return 0 if name in skip_impl: - # Don't delete the function entry in the caller. - return 1 + # Don't delete the function entry in the caller. + return 1 c_call = ""; format="" @@ -426,8 +426,8 @@ def print_function_wrapper(name, output, export, include): c_args = c_args + " %s %s;\n" % (arg[1], arg[0]) if py_types.has_key(arg[1]): (f, t, n, c) = py_types[arg[1]] - if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0): - f = 't#' + if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0): + f = 't#' if f != None: format = format + f if t != None: @@ -438,10 +438,10 @@ def print_function_wrapper(name, output, export, include): arg[1], t, arg[0]); else: format_args = format_args + ", &%s" % (arg[0]) - if f == 't#': - format_args = format_args + ", &py_buffsize%d" % num_bufs - c_args = c_args + " int py_buffsize%d;\n" % num_bufs - num_bufs = num_bufs + 1 + if f == 't#': + format_args = format_args + ", &py_buffsize%d" % num_bufs + c_args = c_args + " int py_buffsize%d;\n" % num_bufs + num_bufs = num_bufs + 1 if c_call != "": c_call = c_call + ", "; c_call = c_call + "%s" % (arg[0]) @@ -459,14 +459,14 @@ def print_function_wrapper(name, output, export, include): if ret[0] == 'void': if file == "python_accessor": - if args[1][1] == "char *": - c_call = "\n free(%s->%s);\n" % ( - args[0][0], args[1][0], args[0][0], args[1][0]) - c_call = c_call + " %s->%s = (%s)strdup((const xmlChar *)%s);\n" % (args[0][0], - args[1][0], args[1][1], args[1][0]) - else: - c_call = "\n %s->%s = %s;\n" % (args[0][0], args[1][0], - args[1][0]) + if args[1][1] == "char *": + c_call = "\n free(%s->%s);\n" % ( + args[0][0], args[1][0], args[0][0], args[1][0]) + c_call = c_call + " %s->%s = (%s)strdup((const xmlChar *)%s);\n" % (args[0][0], + args[1][0], args[1][1], args[1][0]) + else: + c_call = "\n %s->%s = %s;\n" % (args[0][0], args[1][0], + args[1][0]) else: c_call = "\n %s(%s);\n" % (name, c_call); ret_convert = " Py_INCREF(Py_None);\n return(Py_None);\n" @@ -508,24 +508,24 @@ def print_function_wrapper(name, output, export, include): if file == "python": # Those have been manually generated - if cond != None and cond != "": - include.write("#endif\n"); - export.write("#endif\n"); - output.write("#endif\n"); + if cond != None and cond != "": + include.write("#endif\n"); + export.write("#endif\n"); + output.write("#endif\n"); return 1 if file == "python_accessor" and ret[0] != "void" and ret[2] is None: # Those have been manually generated - if cond != None and cond != "": - include.write("#endif\n"); - export.write("#endif\n"); - output.write("#endif\n"); + if cond != None and cond != "": + include.write("#endif\n"); + export.write("#endif\n"); + output.write("#endif\n"); return 1 output.write("PyObject *\n") output.write("libvirt_%s(PyObject *self ATTRIBUTE_UNUSED," % (name)) output.write(" PyObject *args") if format == "": - output.write(" ATTRIBUTE_UNUSED") + output.write(" ATTRIBUTE_UNUSED") output.write(") {\n") if ret[0] != 'void': output.write(" PyObject *py_retval;\n") @@ -557,38 +557,38 @@ def buildStubs(): global unknown_types try: - f = open(os.path.join(srcPref,"libvirt-api.xml")) - data = f.read() - (parser, target) = getparser() - parser.feed(data) - parser.close() + f = open(os.path.join(srcPref,"libvirt-api.xml")) + data = f.read() + (parser, target) = getparser() + parser.feed(data) + parser.close() except IOError, msg: - try: - f = open(os.path.join(srcPref,"..","docs","libvirt-api.xml")) - data = f.read() - (parser, target) = getparser() - parser.feed(data) - parser.close() - except IOError, msg: - print file, ":", msg - sys.exit(1) + try: + f = open(os.path.join(srcPref,"..","docs","libvirt-api.xml")) + data = f.read() + (parser, target) = getparser() + parser.feed(data) + parser.close() + except IOError, msg: + print file, ":", msg + sys.exit(1) n = len(functions.keys()) print "Found %d functions in libvirt-api.xml" % (n) py_types['pythonObject'] = ('O', "pythonObject", "pythonObject", "pythonObject") try: - f = open(os.path.join(srcPref,"libvirt-override-api.xml")) - data = f.read() - (parser, target) = getparser() - parser.feed(data) - parser.close() + f = open(os.path.join(srcPref,"libvirt-override-api.xml")) + data = f.read() + (parser, target) = getparser() + parser.feed(data) + parser.close() except IOError, msg: - print file, ":", msg + print file, ":", msg print "Found %d functions in libvirt-override-api.xml" % ( - len(functions.keys()) - n) + len(functions.keys()) - n) nb_wrap = 0 failed = 0 skipped = 0 @@ -604,17 +604,17 @@ def buildStubs(): wrapper.write("#include \"typewrappers.h\"\n") wrapper.write("#include \"libvirt.h\"\n\n") for function in functions.keys(): - ret = print_function_wrapper(function, wrapper, export, include) - if ret < 0: - failed = failed + 1 - functions_failed.append(function) - del functions[function] - if ret == 0: - skipped = skipped + 1 - functions_skipped.append(function) - del functions[function] - if ret == 1: - nb_wrap = nb_wrap + 1 + ret = print_function_wrapper(function, wrapper, export, include) + if ret < 0: + failed = failed + 1 + functions_failed.append(function) + del functions[function] + if ret == 0: + skipped = skipped + 1 + functions_skipped.append(function) + del functions[function] + if ret == 1: + nb_wrap = nb_wrap + 1 include.close() export.close() wrapper.close() @@ -623,7 +623,7 @@ def buildStubs(): print "Missing type converters: " for type in unknown_types.keys(): - print "%s:%d " % (type, len(unknown_types[type])), + print "%s:%d " % (type, len(unknown_types[type])), print for f in functions_failed: @@ -955,7 +955,7 @@ def buildWrappers(): global functions_noexcept for type in classes_type.keys(): - function_classes[classes_type[type][2]] = [] + function_classes[classes_type[type][2]] = [] # # Build the list of C types to look for ordered to start @@ -966,46 +966,46 @@ def buildWrappers(): ctypes_processed = {} classes_processed = {} for classe in primary_classes: - classes_list.append(classe) - classes_processed[classe] = () - for type in classes_type.keys(): - tinfo = classes_type[type] - if tinfo[2] == classe: - ctypes.append(type) - ctypes_processed[type] = () + classes_list.append(classe) + classes_processed[classe] = () + for type in classes_type.keys(): + tinfo = classes_type[type] + if tinfo[2] == classe: + ctypes.append(type) + ctypes_processed[type] = () for type in classes_type.keys(): - if ctypes_processed.has_key(type): - continue - tinfo = classes_type[type] - if not classes_processed.has_key(tinfo[2]): - classes_list.append(tinfo[2]) - classes_processed[tinfo[2]] = () + if ctypes_processed.has_key(type): + continue + tinfo = classes_type[type] + if not classes_processed.has_key(tinfo[2]): + classes_list.append(tinfo[2]) + classes_processed[tinfo[2]] = () - ctypes.append(type) - ctypes_processed[type] = () + ctypes.append(type) + ctypes_processed[type] = () for name in functions.keys(): - found = 0; - (desc, ret, args, file, cond) = functions[name] - for type in ctypes: - classe = classes_type[type][2] - - if name[0:3] == "vir" and len(args) >= 1 and args[0][1] == type: - found = 1 - func = nameFixup(name, classe, type, file) - info = (0, func, name, ret, args, file) - function_classes[classe].append(info) - elif name[0:3] == "vir" and len(args) >= 2 and args[1][1] == type \ - and file != "python_accessor" and not name in function_skip_index_one: - found = 1 - func = nameFixup(name, classe, type, file) - info = (1, func, name, ret, args, file) - function_classes[classe].append(info) - if found == 1: - continue - func = nameFixup(name, "None", file, file) - info = (0, func, name, ret, args, file) - function_classes['None'].append(info) + found = 0; + (desc, ret, args, file, cond) = functions[name] + for type in ctypes: + classe = classes_type[type][2] + + if name[0:3] == "vir" and len(args) >= 1 and args[0][1] == type: + found = 1 + func = nameFixup(name, classe, type, file) + info = (0, func, name, ret, args, file) + function_classes[classe].append(info) + elif name[0:3] == "vir" and len(args) >= 2 and args[1][1] == type \ + and file != "python_accessor" and not name in function_skip_index_one: + found = 1 + func = nameFixup(name, classe, type, file) + info = (1, func, name, ret, args, file) + function_classes[classe].append(info) + if found == 1: + continue + func = nameFixup(name, "None", file, file) + info = (0, func, name, ret, args, file) + function_classes['None'].append(info) classes = open("libvirt.py", "w") @@ -1032,60 +1032,60 @@ def buildWrappers(): extra.close() if function_classes.has_key("None"): - flist = function_classes["None"] - flist.sort(functionCompare) - oldfile = "" - for info in flist: - (index, func, name, ret, args, file) = info - if file != oldfile: - classes.write("#\n# Functions from module %s\n#\n\n" % file) - oldfile = file - classes.write("def %s(" % func) - n = 0 - for arg in args: - if n != 0: - classes.write(", ") - classes.write("%s" % arg[0]) - n = n + 1 - classes.write("):\n") - writeDoc(name, args, ' ', classes); - - for arg in args: - if classes_type.has_key(arg[1]): - classes.write(" if %s is None: %s__o = None\n" % - (arg[0], arg[0])) - classes.write(" else: %s__o = %s%s\n" % - (arg[0], arg[0], classes_type[arg[1]][0])) - if ret[0] != "void": - classes.write(" ret = "); - else: - classes.write(" "); - classes.write("libvirtmod.%s(" % name) - n = 0 - for arg in args: - if n != 0: - classes.write(", "); - classes.write("%s" % arg[0]) - if classes_type.has_key(arg[1]): - classes.write("__o"); - n = n + 1 - classes.write(")\n"); + flist = function_classes["None"] + flist.sort(functionCompare) + oldfile = "" + for info in flist: + (index, func, name, ret, args, file) = info + if file != oldfile: + classes.write("#\n# Functions from module %s\n#\n\n" % file) + oldfile = file + classes.write("def %s(" % func) + n = 0 + for arg in args: + if n != 0: + classes.write(", ") + classes.write("%s" % arg[0]) + n = n + 1 + classes.write("):\n") + writeDoc(name, args, ' ', classes); + + for arg in args: + if classes_type.has_key(arg[1]): + classes.write(" if %s is None: %s__o = None\n" % + (arg[0], arg[0])) + classes.write(" else: %s__o = %s%s\n" % + (arg[0], arg[0], classes_type[arg[1]][0])) + if ret[0] != "void": + classes.write(" ret = "); + else: + classes.write(" "); + classes.write("libvirtmod.%s(" % name) + n = 0 + for arg in args: + if n != 0: + classes.write(", "); + classes.write("%s" % arg[0]) + if classes_type.has_key(arg[1]): + classes.write("__o"); + n = n + 1 + classes.write(")\n"); if ret[0] != "void": - if classes_type.has_key(ret[0]): - # - # Raise an exception - # - if functions_noexcept.has_key(name): - classes.write(" if ret is None:return None\n"); - else: - classes.write( - " if ret is None:raise libvirtError('%s() failed')\n" % - (name)) - - classes.write(" return "); - classes.write(classes_type[ret[0]][1] % ("ret")); - classes.write("\n"); + if classes_type.has_key(ret[0]): + # + # Raise an exception + # + if functions_noexcept.has_key(name): + classes.write(" if ret is None:return None\n"); + else: + classes.write( + " if ret is None:raise libvirtError('%s() failed')\n" % + (name)) + + classes.write(" return "); + classes.write(classes_type[ret[0]][1] % ("ret")); + classes.write("\n"); # For functions returning an integral type there are # several things that we can do, depending on the @@ -1099,7 +1099,7 @@ def buildWrappers(): classes.write ((" if " + test + ": raise libvirtError ('%s() failed')\n") % ("ret", name)) - classes.write(" return ret\n") + classes.write(" return ret\n") elif is_list_type (ret[0]): if not functions_noexcept.has_key (name): @@ -1110,30 +1110,30 @@ def buildWrappers(): classes.write ((" if " + test + ": raise libvirtError ('%s() failed')\n") % ("ret", name)) - classes.write(" return ret\n") + classes.write(" return ret\n") - else: - classes.write(" return ret\n") + else: + classes.write(" return ret\n") - classes.write("\n"); + classes.write("\n"); for classname in classes_list: - if classname == "None": - pass - else: - if classes_ancestor.has_key(classname): - classes.write("class %s(%s):\n" % (classname, - classes_ancestor[classname])) - classes.write(" def __init__(self, _obj=None):\n") - if reference_keepers.has_key(classname): - rlist = reference_keepers[classname] - for ref in rlist: - classes.write(" self.%s = None\n" % ref[1]) - classes.write(" self._o = _obj\n") - classes.write(" %s.__init__(self, _obj=_obj)\n\n" % ( - classes_ancestor[classname])) - else: - classes.write("class %s:\n" % (classname)) + if classname == "None": + pass + else: + if classes_ancestor.has_key(classname): + classes.write("class %s(%s):\n" % (classname, + classes_ancestor[classname])) + classes.write(" def __init__(self, _obj=None):\n") + if reference_keepers.has_key(classname): + rlist = reference_keepers[classname] + for ref in rlist: + classes.write(" self.%s = None\n" % ref[1]) + classes.write(" self._o = _obj\n") + classes.write(" %s.__init__(self, _obj=_obj)\n\n" % ( + classes_ancestor[classname])) + else: + classes.write("class %s:\n" % (classname)) if classname in [ "virDomain", "virNetwork", "virInterface", "virStoragePool", "virStorageVol", "virNodeDevice", "virSecret","virStream", "virNWFilter" ]: @@ -1142,10 +1142,10 @@ def buildWrappers(): classes.write(" def __init__(self, dom, _obj=None):\n") else: classes.write(" def __init__(self, _obj=None):\n") - if reference_keepers.has_key(classname): - list = reference_keepers[classname] - for ref in list: - classes.write(" self.%s = None\n" % ref[1]) + if reference_keepers.has_key(classname): + list = reference_keepers[classname] + for ref in list: + classes.write(" self.%s = None\n" % ref[1]) if classname in [ "virDomain", "virNetwork", "virInterface", "virNodeDevice", "virSecret", "virStream", "virNWFilter" ]: @@ -1156,16 +1156,16 @@ def buildWrappers(): " self._conn = conn._conn\n") elif classname in [ "virDomainSnapshot" ]: classes.write(" self._dom = dom\n") - classes.write(" if _obj != None:self._o = _obj;return\n") - classes.write(" self._o = None\n\n"); - destruct=None - if classes_destructors.has_key(classname): - classes.write(" def __del__(self):\n") - classes.write(" if self._o != None:\n") - classes.write(" libvirtmod.%s(self._o)\n" % - classes_destructors[classname]); - classes.write(" self._o = None\n\n"); - destruct=classes_destructors[classname] + classes.write(" if _obj != None:self._o = _obj;return\n") + classes.write(" self._o = None\n\n"); + destruct=None + if classes_destructors.has_key(classname): + classes.write(" def __del__(self):\n") + classes.write(" if self._o != None:\n") + classes.write(" libvirtmod.%s(self._o)\n" % + classes_destructors[classname]); + classes.write(" self._o = None\n\n"); + destruct=classes_destructors[classname] if not class_skip_connect_impl.has_key(classname): # Build python safe 'connect' method @@ -1176,99 +1176,99 @@ def buildWrappers(): classes.write(" def domain(self):\n") classes.write(" return self._dom\n\n") - flist = function_classes[classname] - flist.sort(functionCompare) - oldfile = "" - for info in flist: - (index, func, name, ret, args, file) = info - # - # Do not provide as method the destructors for the class - # to avoid double free - # - if name == destruct: - continue; - if file != oldfile: - if file == "python_accessor": - classes.write(" # accessors for %s\n" % (classname)) - else: - classes.write(" #\n") - classes.write(" # %s functions from module %s\n" % ( - classname, file)) - classes.write(" #\n\n") - oldfile = file - classes.write(" def %s(self" % func) - n = 0 - for arg in args: - if n != index: - classes.write(", %s" % arg[0]) - n = n + 1 - classes.write("):\n") - writeDoc(name, args, ' ', classes); - n = 0 - for arg in args: - if classes_type.has_key(arg[1]): - if n != index: - classes.write(" if %s is None: %s__o = None\n" % - (arg[0], arg[0])) - classes.write(" else: %s__o = %s%s\n" % - (arg[0], arg[0], classes_type[arg[1]][0])) - n = n + 1 - if ret[0] != "void": - classes.write(" ret = "); - else: - classes.write(" "); - classes.write("libvirtmod.%s(" % name) - n = 0 - for arg in args: - if n != 0: - classes.write(", "); - if n != index: - classes.write("%s" % arg[0]) - if classes_type.has_key(arg[1]): - classes.write("__o"); - else: - classes.write("self"); - if classes_type.has_key(arg[1]): - classes.write(classes_type[arg[1]][0]) - n = n + 1 - classes.write(")\n"); + flist = function_classes[classname] + flist.sort(functionCompare) + oldfile = "" + for info in flist: + (index, func, name, ret, args, file) = info + # + # Do not provide as method the destructors for the class + # to avoid double free + # + if name == destruct: + continue; + if file != oldfile: + if file == "python_accessor": + classes.write(" # accessors for %s\n" % (classname)) + else: + classes.write(" #\n") + classes.write(" # %s functions from module %s\n" % ( + classname, file)) + classes.write(" #\n\n") + oldfile = file + classes.write(" def %s(self" % func) + n = 0 + for arg in args: + if n != index: + classes.write(", %s" % arg[0]) + n = n + 1 + classes.write("):\n") + writeDoc(name, args, ' ', classes); + n = 0 + for arg in args: + if classes_type.has_key(arg[1]): + if n != index: + classes.write(" if %s is None: %s__o = None\n" % + (arg[0], arg[0])) + classes.write(" else: %s__o = %s%s\n" % + (arg[0], arg[0], classes_type[arg[1]][0])) + n = n + 1 + if ret[0] != "void": + classes.write(" ret = "); + else: + classes.write(" "); + classes.write("libvirtmod.%s(" % name) + n = 0 + for arg in args: + if n != 0: + classes.write(", "); + if n != index: + classes.write("%s" % arg[0]) + if classes_type.has_key(arg[1]): + classes.write("__o"); + else: + classes.write("self"); + if classes_type.has_key(arg[1]): + classes.write(classes_type[arg[1]][0]) + n = n + 1 + classes.write(")\n"); if name == "virConnectClose": classes.write(" self._o = None\n") # For functions returning object types: if ret[0] != "void": - if classes_type.has_key(ret[0]): - # - # Raise an exception - # - if functions_noexcept.has_key(name): - classes.write( - " if ret is None:return None\n"); - else: + if classes_type.has_key(ret[0]): + # + # Raise an exception + # + if functions_noexcept.has_key(name): + classes.write( + " if ret is None:return None\n"); + else: if classname == "virConnect": classes.write( - " if ret is None:raise libvirtError('%s() failed', conn=self)\n" % + " if ret is None:raise libvirtError('%s() failed', conn=self)\n" % (name)) elif classname == "virDomain": classes.write( - " if ret is None:raise libvirtError('%s() failed', dom=self)\n" % + " if ret is None:raise libvirtError('%s() failed', dom=self)\n" % (name)) elif classname == "virNetwork": classes.write( - " if ret is None:raise libvirtError('%s() failed', net=self)\n" % + " if ret is None:raise libvirtError('%s() failed', net=self)\n" % (name)) elif classname == "virInterface": classes.write( - " if ret is None:raise libvirtError('%s() failed', net=self)\n" % + " if ret is None:raise libvirtError('%s() failed', net=self)\n" % (name)) elif classname == "virStoragePool": classes.write( - " if ret is None:raise libvirtError('%s() failed', pool=self)\n" % + " if ret is None:raise libvirtError('%s() failed', pool=self)\n" % (name)) elif classname == "virStorageVol": classes.write( - " if ret is None:raise libvirtError('%s() failed', vol=self)\n" % + " if ret is None:raise libvirtError('%s() failed', vol=self)\n" % (name)) elif classname == "virDomainSnapshot": classes.write( @@ -1276,54 +1276,54 @@ def buildWrappers(): (name)) else: classes.write( - " if ret is None:raise libvirtError('%s() failed')\n" % + " if ret is None:raise libvirtError('%s() failed')\n" % (name)) - # - # generate the returned class wrapper for the object - # - classes.write(" __tmp = "); - classes.write(classes_type[ret[0]][1] % ("ret")); - classes.write("\n"); + # + # generate the returned class wrapper for the object + # + classes.write(" __tmp = "); + classes.write(classes_type[ret[0]][1] % ("ret")); + classes.write("\n"); # - # Sometime one need to keep references of the source - # class in the returned class object. - # See reference_keepers for the list - # - tclass = classes_type[ret[0]][2] - if reference_keepers.has_key(tclass): - list = reference_keepers[tclass] - for pref in list: - if pref[0] == classname: - classes.write(" __tmp.%s = self\n" % - pref[1]) + # Sometime one need to keep references of the source + # class in the returned class object. + # See reference_keepers for the list + # + tclass = classes_type[ret[0]][2] + if reference_keepers.has_key(tclass): + list = reference_keepers[tclass] + for pref in list: + if pref[0] == classname: + classes.write(" __tmp.%s = self\n" % + pref[1]) # Post-processing - just before we return. if function_post.has_key(name): classes.write(" %s\n" % (function_post[name])); - # - # return the class - # - classes.write(" return __tmp\n"); - elif converter_type.has_key(ret[0]): - # - # Raise an exception - # - if functions_noexcept.has_key(name): - classes.write( - " if ret is None:return None"); + # + # return the class + # + classes.write(" return __tmp\n"); + elif converter_type.has_key(ret[0]): + # + # Raise an exception + # + if functions_noexcept.has_key(name): + classes.write( + " if ret is None:return None"); # Post-processing - just before we return. if function_post.has_key(name): classes.write(" %s\n" % (function_post[name])); - classes.write(" return "); - classes.write(converter_type[ret[0]] % ("ret")); - classes.write("\n"); + classes.write(" return "); + classes.write(converter_type[ret[0]] % ("ret")); + classes.write("\n"); # For functions returning an integral type there # are several things that we can do, depending on @@ -1412,15 +1412,15 @@ def buildWrappers(): classes.write (" return ret\n") - else: + else: # Post-processing - just before we return. if function_post.has_key(name): classes.write(" %s\n" % (function_post[name])); - classes.write(" return ret\n"); + classes.write(" return ret\n"); - classes.write("\n"); + classes.write("\n"); # Append "<classname>.py" to class def, iff it exists try: extra = open(os.path.join(srcPref,"libvirt-override-" + classname + ".py"), "r") diff --git a/python/tests/create.py b/python/tests/create.py index d2c434e..4e5f644 100755 --- a/python/tests/create.py +++ b/python/tests/create.py @@ -23,7 +23,7 @@ osroot = None for root in osroots: if os.access(root, os.R_OK): osroot = root - break + break if osroot == None: print "Could not find a guest OS root, edit to add the path in osroots" @@ -124,11 +124,11 @@ while i < 30: time.sleep(1) i = i + 1 try: - t = dom.info()[4] + t = dom.info()[4] except: okay = 0 - t = -1 - break; + t = -1 + break; if t == 0: break -- 1.7.4.1