Lines Matching refs:self
92 def __init__(self, name, header=None, module=None, type=None, lineno = 0,
94 self.name = name
95 self.header = header
96 self.module = module
97 self.type = type
98 self.info = info
99 self.extra = extra
100 self.lineno = lineno
101 self.static = 0
103 self.conditionals = None
105 self.conditionals = conditionals[:]
106 if self.name == debugsym:
110 def __repr__(self):
111 r = "%s %s:" % (self.type, self.name)
112 if self.static:
114 if self.module != None:
115 r = r + " from %s" % (self.module)
116 if self.info != None:
117 r = r + " " + `self.info`
118 if self.extra != None:
119 r = r + " " + `self.extra`
120 if self.conditionals != None:
121 r = r + " " + `self.conditionals`
125 def set_header(self, header):
126 self.header = header
127 def set_module(self, module):
128 self.module = module
129 def set_type(self, type):
130 self.type = type
131 def set_info(self, info):
132 self.info = info
133 def set_extra(self, extra):
134 self.extra = extra
135 def set_lineno(self, lineno):
136 self.lineno = lineno
137 def set_static(self, static):
138 self.static = static
139 def set_conditionals(self, conditionals):
141 self.conditionals = None
143 self.conditionals = conditionals[:]
145 def get_name(self):
146 return self.name
147 def get_header(self):
148 return self.module
149 def get_module(self):
150 return self.module
151 def get_type(self):
152 return self.type
153 def get_info(self):
154 return self.info
155 def get_lineno(self):
156 return self.lineno
157 def get_extra(self):
158 return self.extra
159 def get_static(self):
160 return self.static
161 def get_conditionals(self):
162 return self.conditionals
164 def update(self, header, module, type = None, info = None, extra=None,
166 if self.name == debugsym:
169 if header != None and self.header == None:
170 self.set_header(module)
171 if module != None and (self.module == None or self.header == self.module):
172 self.set_module(module)
173 if type != None and self.type == None:
174 self.set_type(type)
176 self.set_info(info)
178 self.set_extra(extra)
180 self.set_conditionals(conditionals)
183 def __init__(self, name = "noname"):
184 self.name = name
185 self.identifiers = {}
186 self.functions = {}
187 self.variables = {}
188 self.includes = {}
189 self.structs = {}
190 self.enums = {}
191 self.typedefs = {}
192 self.macros = {}
193 self.references = {}
194 self.info = {}
196 def add_ref(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):
201 d = self.identifiers[name]
205 self.identifiers[name] = d
211 self.references[name] = d
218 def add(self, name, header, module, static, type, lineno, info=None, extra=None, conditionals = None):
223 d = self.identifiers[name]
227 self.identifiers[name] = d
234 self.functions[name] = d
236 self.functions[name] = d
238 self.variables[name] = d
240 self.includes[name] = d
242 self.structs[name] = d
244 self.enums[name] = d
246 self.typedefs[name] = d
248 self.macros[name] = d
257 def merge(self, idx):
263 if self.macros.has_key(id):
264 del self.macros[id]
265 if self.functions.has_key(id):
267 id, self.functions[id].header, idx.functions[id].header)
269 self.functions[id] = idx.functions[id]
270 self.identifiers[id] = idx.functions[id]
276 if self.macros.has_key(id):
277 del self.macros[id]
278 if self.variables.has_key(id):
280 id, self.variables[id].header, idx.variables[id].header)
282 self.variables[id] = idx.variables[id]
283 self.identifiers[id] = idx.variables[id]
285 if self.structs.has_key(id):
287 id, self.structs[id].header, idx.structs[id].header)
289 self.structs[id] = idx.structs[id]
290 self.identifiers[id] = idx.structs[id]
292 if self.typedefs.has_key(id):
294 id, self.typedefs[id].header, idx.typedefs[id].header)
296 self.typedefs[id] = idx.typedefs[id]
297 self.identifiers[id] = idx.typedefs[id]
303 if self.variables.has_key(id):
305 if self.functions.has_key(id):
307 if self.enums.has_key(id):
309 if self.macros.has_key(id):
311 id, self.macros[id].header, idx.macros[id].header)
313 self.macros[id] = idx.macros[id]
314 self.identifiers[id] = idx.macros[id]
316 if self.enums.has_key(id):
318 id, self.enums[id].header, idx.enums[id].header)
320 self.enums[id] = idx.enums[id]
321 self.identifiers[id] = idx.enums[id]
323 def merge_public(self, idx):
325 if self.functions.has_key(id):
328 self.functions[id].conditionals:
331 print " H: %s" % self.functions[id].conditionals
334 self.functions[id].update(None, up.module, up.type, up.info, up.extra)
340 def analyze_dict(self, type, dict):
354 def analyze(self):
355 self.analyze_dict("functions", self.functions)
356 self.analyze_dict("variables", self.variables)
357 self.analyze_dict("structs", self.structs)
358 self.analyze_dict("typedefs", self.typedefs)
359 self.analyze_dict("macros", self.macros)
364 def __init__(self, input):
365 self.input = input
366 self.tokens = []
367 self.line = ""
368 self.lineno = 0
370 def getline(self):
373 line = self.input.readline()
376 self.lineno = self.lineno + 1
383 n = self.input.readline()
384 self.lineno = self.lineno + 1
393 def getlineno(self):
394 return self.lineno
396 def push(self, token):
397 self.tokens.insert(0, token);
399 def debug(self):
400 print "Last token: ", self.last
401 print "Token queue: ", self.tokens
402 print "Line %d end: " % (self.lineno), self.line
404 def token(self):
405 while self.tokens == []:
406 if self.line == "":
407 line = self.getline()
409 line = self.line
410 self.line = ""
415 self.tokens = map((lambda x: ('preproc', x)),
429 self.line = line[i+1:]
439 line = self.getline()
442 self.last = ('string', tok)
443 return self.last
454 self.line = line[i+2:]
464 line = self.getline()
467 self.last = ('comment', tok)
468 return self.last
471 self.last = ('comment', line)
472 return self.last
476 self.line = line[i:]
480 self.line = line[i:]
484 self.line = line[i:]
506 self.tokens.append(('name', line[s:i]))
512 self.tokens.append(('sep', line[i]))
522 self.tokens.append(('name', '...'))
533 self.tokens.append(('op', line[i:j+1]))
536 self.tokens.append(('op', line[i]))
560 self.tokens.append(('name', line[s:i]))
562 tok = self.tokens[0]
563 self.tokens = self.tokens[1:]
564 self.last = tok
569 def __init__(self, filename, idx = None):
570 self.filename = filename
572 self.is_header = 1
574 self.is_header = 0
575 self.input = open(filename)
576 self.lexer = CLexer(self.input)
578 self.index = index()
580 self.index = idx
581 self.top_comment = ""
582 self.last_comment = ""
583 self.comment = None
584 self.collect_ref = 0
585 self.no_error = 0
586 self.conditionals = []
587 self.defines = []
589 def collect_references(self):
590 self.collect_ref = 1
592 def stop_error(self):
593 self.no_error = 1
595 def start_error(self):
596 self.no_error = 0
598 def lineno(self):
599 return self.lexer.getlineno()
601 def index_add(self, name, module, static, type, info=None, extra = None):
602 if self.is_header == 1:
603 self.index.add(name, module, module, static, type, self.lineno(),
604 info, extra, self.conditionals)
606 self.index.add(name, None, module, static, type, self.lineno(),
607 info, extra, self.conditionals)
609 def index_add_ref(self, name, module, static, type, info=None,
611 if self.is_header == 1:
612 self.index.add_ref(name, module, module, static, type,
613 self.lineno(), info, extra, self.conditionals)
615 self.index.add_ref(name, None, module, static, type, self.lineno(),
616 info, extra, self.conditionals)
618 def warning(self, msg):
619 if self.no_error:
623 def error(self, msg, token=-1):
624 if self.no_error:
630 self.lexer.debug()
633 def debug(self, msg, token=-1):
637 self.lexer.debug()
639 def parseTopComment(self, comment):
665 self.index.info = res
667 def parseComment(self, token):
668 if self.top_comment == "":
669 self.top_comment = token[1]
670 if self.comment == None or token[1][0] == '*':
671 self.comment = token[1];
673 self.comment = self.comment + token[1]
674 token = self.lexer.token()
676 if string.find(self.comment, "DOC_DISABLE") != -1:
677 self.stop_error()
679 if string.find(self.comment, "DOC_ENABLE") != -1:
680 self.start_error()
687 def parseTypeComment(self, name, quiet = 0):
694 if self.comment == None:
696 self.warning("Missing comment for type %s" % (name))
698 if self.comment[0] != '*':
700 self.warning("Missing * in type comment for %s" % (name))
702 lines = string.split(self.comment, '\n')
707 self.warning("Misformatted type comment for %s" % (name))
708 self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
726 self.warning("Type comment for %s lack description of the macro" % (name))
732 def parseMacroComment(self, name, quiet = 0):
739 if self.comment == None:
741 self.warning("Missing comment for macro %s" % (name))
743 if self.comment[0] != '*':
745 self.warning("Missing * in macro comment for %s" % (name))
747 lines = string.split(self.comment, '\n')
752 self.warning("Misformatted macro comment for %s" % (name))
753 self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
766 self.warning("Misformatted macro comment for %s" % (name))
767 self.warning(" problem with '%s'" % (lines[0]))
796 self.warning("Macro comment for %s lack description of the macro" % (name))
805 def mergeFunctionComment(self, name, description, quiet = 0):
815 if self.comment == None:
817 self.warning("Missing comment for function %s" % (name))
819 if self.comment[0] != '*':
821 self.warning("Missing * in function comment for %s" % (name))
823 lines = string.split(self.comment, '\n')
828 self.warning("Misformatted function comment for %s" % (name))
829 self.warning(" Expecting '* %s:' got '%s'" % (name, lines[0]))
843 self.warning("Misformatted function comment for %s" % (name))
844 self.warning(" problem with '%s'" % (lines[0]))
865 self.warning("Unable to find arg %s from function comment for %s" % (
904 self.warning("Function comment for %s lacks description of arg %s" % (name, args[i][1]))
907 self.warning("Function comment for %s lacks description of return value" % (name))
909 self.warning("Function comment for %s lacks description of the function" % (name))
913 def parsePreproc(self, token):
915 print "=> preproc ", token, self.lexer.tokens
918 token = self.lexer.token()
922 self.index_add(token[1], self.filename, not self.is_header,
924 return self.lexer.token()
927 token = self.lexer.token()
934 token = self.lexer.token()
938 token = self.lexer.token()
943 info = self.parseMacroComment(name, not self.is_header)
944 self.index_add(name, self.filename, not self.is_header,
966 apstr = self.lexer.tokens[0][1]
968 self.defines.append(apstr)
970 self.conditionals.append("defined(%s)" % apstr)
974 apstr = self.lexer.tokens[0][1]
976 self.defines.append(apstr)
978 self.conditionals.append("!defined(%s)" % apstr)
983 for tok in self.lexer.tokens:
988 self.defines.append(apstr)
990 self.conditionals.append(apstr)
994 if self.conditionals != [] and \
995 string.find(self.defines[-1], 'ENABLED') != -1:
996 self.conditionals[-1] = "!(%s)" % self.conditionals[-1]
998 if self.conditionals != [] and \
999 string.find(self.defines[-1], 'ENABLED') != -1:
1000 self.conditionals = self.conditionals[:-1]
1001 self.defines = self.defines[:-1]
1002 token = self.lexer.token()
1005 token = self.lexer.token()
1013 def token(self):
1016 token = self.lexer.token()
1019 token = self.parseComment(token)
1022 token = self.parsePreproc(token)
1028 token = self.lexer.token()
1030 token = self.lexer.token()
1036 token = self.lexer.token()
1038 token = self.lexer.token()
1049 def parseTypedef(self, token):
1052 token = self.parseType(token)
1054 self.error("parsing typedef")
1056 base_type = self.type
1058 #self.debug("end typedef type", token)
1062 signature = self.signature
1065 d = self.mergeFunctionComment(name,
1067 self.index_add(name, self.filename, not self.is_header,
1071 self.index_add(name, self.filename, not self.is_header,
1076 info = self.parseTypeComment(name, 1)
1077 self.index_add(name, self.filename, not self.is_header,
1079 token = self.token()
1081 self.error("parsing typedef: expecting a name")
1083 #self.debug("end typedef", token)
1086 token = self.token()
1089 token = self.token()
1096 self.error("parsing typedef: expecting ';'", token)
1098 token = self.token()
1105 def parseBlock(self, token):
1108 token = self.token()
1109 token = self.parseBlock(token)
1111 self.comment = None
1112 token = self.token()
1115 if self.collect_ref == 1:
1117 token = self.token()
1120 self.index_add_ref(oldtok[1], self.filename,
1122 token = self.token()
1124 token = self.token()
1127 self.index_add_ref(oldtok[1], self.filename,
1130 self.index_add_ref(oldtok[1], self.filename,
1133 self.index_add_ref(oldtok[1], self.filename,
1137 token = self.token()
1143 def parseStruct(self, token):
1145 #self.debug("start parseStruct", token)
1148 token = self.token()
1149 token = self.parseTypeBlock(token)
1151 self.struct_fields = fields
1152 #self.debug("end parseStruct", token)
1154 token = self.token()
1157 base_type = self.type
1158 #self.debug("before parseType", token)
1159 token = self.parseType(token)
1160 #self.debug("after parseType", token)
1163 token = self.token()
1165 self.comment = None
1166 token = self.token()
1167 fields.append((self.type, fname, self.comment))
1168 self.comment = None
1170 self.error("parseStruct: expecting ;", token)
1172 token = self.token()
1173 token = self.parseTypeBlock(token)
1175 token = self.token()
1177 token = self.token()
1179 self.error("parseStruct: expecting ;", token)
1181 self.error("parseStruct: name", token)
1182 token = self.token()
1183 self.type = base_type;
1184 self.struct_fields = fields
1185 #self.debug("end parseStruct", token)
1192 def parseEnumBlock(self, token):
1193 self.enums = []
1195 self.comment = None
1200 token = self.token()
1201 token = self.parseTypeBlock(token)
1204 if self.comment != None:
1205 comment = self.comment
1206 self.comment = None
1207 self.enums.append((name, value, comment))
1208 token = self.token()
1212 if self.comment != None:
1213 comment = string.strip(self.comment)
1214 self.comment = None
1215 self.enums.append((name, value, comment))
1218 token = self.token()
1223 token = self.token()
1227 token = self.token()
1232 self.warning("Failed to compute value of enum %s" % (name))
1235 token = self.token()
1237 token = self.token()
1244 def parseTypeBlock(self, token):
1247 token = self.token()
1248 token = self.parseTypeBlock(token)
1250 token = self.token()
1253 token = self.token()
1261 def parseType(self, token):
1262 self.type = ""
1263 self.struct_fields = []
1264 self.signature = None
1272 if self.type == "":
1273 self.type = token[1]
1275 self.type = self.type + " " + token[1]
1276 token = self.token()
1279 if self.type == "":
1280 self.type = token[1]
1282 self.type = self.type + " " + token[1]
1284 if self.type == "":
1285 self.type = tmp[1]
1287 self.type = self.type + " " + tmp[1]
1290 if self.type == "":
1291 self.type = token[1]
1293 self.type = self.type + " " + token[1]
1294 token = self.token()
1298 token = self.token()
1300 token = self.token()
1301 token = self.parseStruct(token)
1303 self.type = self.type + " " + nametok[1] + " *"
1304 token = self.token()
1306 self.type = self.type + " *"
1307 token = self.token()
1310 token = self.token()
1312 self.error("struct : expecting name", token)
1315 self.type = self.type + " " + nametok[1]
1319 self.lexer.push(token)
1324 if self.type == "":
1325 self.type = token[1]
1327 self.type = self.type + " " + token[1]
1328 self.enums = []
1329 token = self.token()
1331 token = self.token()
1332 token = self.parseEnumBlock(token)
1334 self.error("parsing enum: expecting '{'", token)
1337 self.lexer.push(token)
1341 for enum in self.enums:
1342 self.index_add(enum[0], self.filename,
1343 not self.is_header, "enum",
1348 if self.type == "":
1349 self.type = token[1]
1351 self.type = self.type + " " + token[1]
1353 self.error("parsing type %s: expecting a name" % (self.type),
1356 token = self.token()
1359 self.type = self.type + " " + token[1]
1360 token = self.token()
1366 self.type = self.type + token[1]
1367 token = self.token()
1369 self.type = self.type + token[1]
1370 token = self.token()
1372 self.error("parsing function type, name expected", token);
1374 self.type = self.type + token[1]
1376 token = self.token()
1378 self.type = self.type + token[1]
1379 token = self.token()
1381 token = self.token()
1382 type = self.type;
1383 token = self.parseSignature(token);
1384 self.type = type;
1386 self.error("parsing function type, '(' expected", token);
1389 self.error("parsing function type, ')' expected", token);
1391 self.lexer.push(token)
1400 token = self.token()
1402 self.type = self.type + nametok[1]
1404 self.type = self.type + token[1]
1405 token = self.token()
1408 self.type = self.type + token[1]
1409 token = self.token()
1411 self.type = self.type + token[1]
1412 token = self.token()
1414 self.error("parsing array type, ']' expected", token);
1418 token = self.token()
1419 token = self.token()
1420 self.lexer.push(token)
1428 def parseSignature(self, token):
1431 self.signature = []
1432 token = self.token()
1435 token = self.parseType(token)
1437 signature.append((self.type, token[1], None))
1438 token = self.token()
1440 token = self.token()
1444 if self.type == "...":
1445 signature.append((self.type, "...", None))
1447 signature.append((self.type, None, None))
1450 token = self.token()
1453 token = self.token()
1455 self.signature = signature
1462 def parseGlobal(self, token):
1465 token = self.token()
1470 token = self.token()
1474 token = self.token()
1475 # print 'Entering extern "C line ', self.lineno()
1479 token = self.parseGlobal(token)
1481 self.error(
1484 token = self.parseGlobal(token)
1485 # print 'Exiting extern "C" line', self.lineno()
1486 token = self.token()
1492 token = self.token()
1497 token = self.token()
1498 return self.parseTypedef(token)
1500 token = self.parseType(token)
1501 type_orig = self.type
1505 self.name = token[1]
1506 token = self.token()
1511 token = self.token()
1515 token = self.token()
1521 token = self.token()
1523 token = self.token()
1524 token = self.parseBlock(token)
1526 self.comment = None
1529 token = self.token()
1530 self.comment = None
1533 self.error("missing ';' or ',' after value")
1537 self.comment = None
1538 token = self.token()
1540 self.index_add(self.name, self.filename,
1541 not self.is_header, "struct", self.struct_fields)
1543 self.index_add(self.name, self.filename,
1544 not self.is_header, "variable", type)
1547 token = self.token()
1548 token = self.parseSignature(token)
1552 d = self.mergeFunctionComment(self.name,
1553 ((type, None), self.signature), 1)
1554 self.index_add(self.name, self.filename, static,
1556 token = self.token()
1558 d = self.mergeFunctionComment(self.name,
1559 ((type, None), self.signature), static)
1560 self.index_add(self.name, self.filename, static,
1562 token = self.token()
1563 token = self.parseBlock(token);
1565 self.comment = None
1566 self.index_add(self.name, self.filename, static,
1569 token = self.token()
1572 token = self.token()
1574 self.name = token[1]
1575 token = self.token()
1581 def parse(self):
1582 self.warning("Parsing %s" % (self.filename))
1583 token = self.token()
1586 token = self.parseGlobal(token)
1588 self.error("token %s %s unexpected at the top level" % (
1590 token = self.parseGlobal(token)
1592 self.parseTopComment(self.top_comment)
1593 return self.index
1598 def __init__(self, name, directories=['.'], excludes=[]):
1599 self.name = name
1600 self.directories = directories
1601 self.excludes = excludes + ignored_files.keys()
1602 self.modules = {}
1603 self.headers = {}
1604 self.idx = index()
1605 self.xref = {}
1606 self.index = {}
1608 self.basename = 'libxml'
1610 self.basename = name
1612 def indexString(self, id, str):
1643 elif self.xref.has_key(token):
1644 self.xref[token].append(id)
1646 self.xref[token] = [id]
1650 def analyze(self):
1651 print "Project %s : %d headers, %d modules" % (self.name, len(self.headers.keys()), len(self.modules.keys()))
1652 self.idx.analyze()
1654 def scanHeaders(self):
1655 for header in self.headers.keys():
1658 self.headers[header] = idx;
1659 self.idx.merge(idx)
1661 def scanModules(self):
1662 for module in self.modules.keys():
1666 self.modules[module] = idx
1667 self.idx.merge_public(idx)
1669 def scan(self):
1670 for directory in self.directories:
1674 for excl in self.excludes:
1679 self.modules[file] = None;
1683 for excl in self.excludes:
1688 self.headers[file] = None;
1689 self.scanHeaders()
1690 self.scanModules()
1692 def modulename_file(self, file):
1700 def serialize_enum(self, output, name):
1701 id = self.idx.enums[name]
1703 self.modulename_file(id.header)))
1718 def serialize_macro(self, output, name):
1719 id = self.idx.macros[name]
1721 self.modulename_file(id.header)))
1727 self.indexString(name, desc)
1733 self.indexString(name, desc)
1740 def serialize_typedef(self, output, name):
1741 id = self.idx.typedefs[name]
1744 name, self.modulename_file(id.header), id.info))
1746 if self.idx.structs.has_key(name) and ( \
1747 type(self.idx.structs[name].info) == type(()) or
1748 type(self.idx.structs[name].info) == type([])):
1751 for field in self.idx.structs[name].info:
1753 self.indexString(name, desc)
1766 name, self.modulename_file(id.header), id.info))
1777 def serialize_variable(self, output, name):
1778 id = self.idx.variables[name]
1781 name, self.modulename_file(id.header), id.info))
1784 name, self.modulename_file(id.header)))
1786 def serialize_function(self, output, name):
1787 id = self.idx.functions[name]
1792 name, self.modulename_file(id.header),
1793 self.modulename_file(id.module)))
1809 self.modulename_file(id.module))
1812 self.indexString(name, desc)
1819 self.indexString(name, ret[1])
1827 self.indexString(name, param[2])
1832 def serialize_exports(self, output, file):
1833 module = self.modulename_file(file)
1835 dict = self.headers[file]
1887 def serialize_xrefs_files(self, output):
1888 headers = self.headers.keys()
1891 module = self.modulename_file(file)
1893 dict = self.headers[file]
1903 def serialize_xrefs_functions(self, output):
1905 for name in self.idx.functions.keys():
1906 id = self.idx.functions[name]
1934 def serialize_xrefs_constructors(self, output):
1936 for name in self.idx.functions.keys():
1937 id = self.idx.functions[name]
1961 def serialize_xrefs_alpha(self, output):
1963 ids = self.idx.identifiers.keys()
1975 def serialize_xrefs_references(self, output):
1976 typ = self.idx.identifiers.keys()
1979 idf = self.idx.identifiers[id]
1982 'html/' + self.basename + '-' +
1983 self.modulename_file(module) + '.html#' +
1986 def serialize_xrefs_index(self, output):
1987 index = self.xref
2033 def serialize_xrefs(self, output):
2035 self.serialize_xrefs_references(output)
2038 self.serialize_xrefs_alpha(output)
2041 self.serialize_xrefs_constructors(output)
2044 self.serialize_xrefs_functions(output)
2047 self.serialize_xrefs_files(output)
2050 self.serialize_xrefs_index(output)
2053 def serialize(self):
2054 filename = "%s-api.xml" % self.name
2058 output.write("<api name='%s'>\n" % self.name)
2060 headers = self.headers.keys()
2063 self.serialize_exports(output, file)
2066 macros = self.idx.macros.keys()
2069 self.serialize_macro(output, macro)
2070 enums = self.idx.enums.keys()
2073 self.serialize_enum(output, enum)
2074 typedefs = self.idx.typedefs.keys()
2077 self.serialize_typedef(output, typedef)
2078 variables = self.idx.variables.keys()
2081 self.serialize_variable(output, variable)
2082 functions = self.idx.functions.keys()
2085 self.serialize_function(output, function)
2090 filename = "%s-refs.xml" % self.name
2094 output.write("<apirefs name='%s'>\n" % self.name)
2095 self.serialize_xrefs(output)