1 #!/usr/bin/env python 2 3 """ 4 View annotated sources. 5 6 Copyright (C) 2006, 2007, 2010, 2011, 2012 Paul Boddie <paul@boddie.org.uk> 7 8 This program is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free Software 10 Foundation; either version 3 of the License, or (at your option) any later 11 version. 12 13 This program is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 16 details. 17 18 You should have received a copy of the GNU General Public License along with 19 this program. If not, see <http://www.gnu.org/licenses/>. 20 """ 21 22 from micropython.common import * 23 from micropython.data import * 24 from micropython.errors import * 25 from os.path import exists, extsep, join 26 import compiler.ast 27 import sys 28 import os 29 import textwrap 30 31 # Classes. 32 33 # HTML-related output production. 34 35 html_header = """<?xml version="1.0" encoding="iso-8859-15"?> 36 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 37 <html xmlns="http://www.w3.org/1999/xhtml"> 38 <head> 39 <title>%(title)s</title> 40 <style type="text/css"> 41 html { 42 background-color: black; color: white; 43 } 44 45 body { 46 padding-bottom: 4em; 47 font-size: 14pt; font-family: monospace; 48 background-color: black; color: white; 49 margin-top: 2em; 50 } 51 52 a { 53 text-decoration: none; 54 } 55 56 .nowrap { white-space: nowrap; } 57 .label { font-size: smaller; } 58 59 .class { margin-top: 1em; margin-bottom: 1em; } 60 .function { margin-top: 1em; margin-bottom: 1em; } 61 .body { padding-left: 2em; } 62 .for, .if, .tryexcept, .tryfinally, .while { margin-bottom: 1em; } 63 .keyword { color: yellow; } 64 .comment { color: blue; } 65 .class-name { color: cyan; } 66 .function-name { color: cyan; } 67 .specific-ref { color: #07F; } 68 .str { color: #FF00FF; } 69 .doc { color: #FF00FF; margin-top: 1em; margin-bottom: 1em; } 70 .doc.module { font-size: smaller; } 71 72 .popup { 73 display: none; 74 position: absolute; 75 top: 3ex; left: 0; 76 color: white; 77 z-index: 3; 78 } 79 80 .attributes-popup, 81 .types-popup { 82 display: none; 83 position: absolute; 84 bottom: 3ex; left: 0; 85 color: white; 86 z-index: 3; 87 } 88 89 .no-targets { 90 background-color: #d00; 91 color: white; 92 } 93 94 .any-target { 95 background-color: #d60; 96 color: white; 97 } 98 99 .attr, 100 .accessor, 101 .name, 102 .operation { 103 position: relative; 104 background-color: #300; 105 color: white; 106 } 107 108 .attr:hover, 109 .accessor:hover, 110 .name:hover, 111 .operation:hover { 112 background-color: #500; 113 padding-top: 0.5ex; 114 padding-bottom: 0.5ex; 115 z-index: 2; 116 } 117 118 .attr:hover .attributes-popup, 119 .accessor:hover .types-popup, 120 .name:hover .popup, 121 .operation:hover .popup { 122 display: block; 123 } 124 125 .attrnames, 126 .opnames, 127 .scope, 128 .typenames { 129 padding: 0.5em; 130 background-color: #700; 131 } 132 133 .name a, 134 .attrnames a, 135 .opnames a, 136 .scope a { 137 color: white; 138 } 139 140 .summary-class { 141 vertical-align: top; 142 } 143 144 th.summary-class { 145 font-weight: normal; 146 } 147 148 .summary-attr { 149 background-color: #070; 150 } 151 152 .summary-interface, 153 .summary-attr { 154 font-size: smaller; 155 } 156 157 .summary-interface.complete { 158 background-color: #050; 159 } 160 161 .summary-attr-absent { 162 border-left: 0.2em solid #070; 163 font-size: small; 164 } 165 166 .summary-class-attr { 167 background-color: #007; 168 font-size: smaller; 169 } 170 171 .summary-class-attr-absent { 172 border-left: 0.2em solid #007; 173 font-size: small; 174 } 175 176 .summary-ref { 177 color: white; 178 } 179 180 </style> 181 </head> 182 <body> 183 """ 184 185 html_footer = """</body> 186 </html> 187 """ 188 189 # Utility classes. 190 191 class Writer: 192 193 "A utility class providing useful HTML output methods." 194 195 # Methods which return strings. 196 197 def _text(self, text): 198 return text.replace("&", "&").replace("<", "<").replace(">", ">") 199 200 def _attr(self, attr): 201 return self._text(attr).replace("'", "'").replace('"', """) 202 203 def _url(self, url): 204 return self._attr(url).replace("#", "%23").replace("-", "%2d") 205 206 # Methods which write to the stream. 207 208 def _span_start(self, classes=None): 209 self.stream.write("<span class='%s'>" % (classes or "")) 210 211 def _span_end(self): 212 self.stream.write("</span>") 213 214 def _span(self, value, classes=None): 215 self._span_start(classes) 216 self.stream.write(self._text(value)) 217 self._span_end() 218 219 def _name_start(self, classes=None): 220 self._span_start(classes or "name") 221 222 _name_end = _span_end 223 224 def _name(self, name, classes=None): 225 self._name_start(classes) 226 self.stream.write(self._text(name)) 227 self._name_end() 228 229 def _popup_start(self, classes=None): 230 self._span_start(classes or "popup") 231 232 _popup_end = _span_end 233 234 def _comment(self, comment): 235 self._span("# %s" % comment, "comment") 236 self.stream.write("\n") 237 238 def _reserved(self, token, classes, leading=0, trailing=1): 239 if leading: 240 self.stream.write(" ") 241 self._span(token, classes) 242 if trailing: 243 self.stream.write(" ") 244 245 def _keyword(self, kw, leading=0, trailing=1): 246 self._reserved(kw, "keyword", leading, trailing) 247 248 def _doc(self, node, classes=None): 249 if node.doc is not None: 250 self._docstring(node.doc, classes) 251 252 def _docstring(self, s, classes=None): 253 self.stream.write("<pre class='doc%s'>" % (classes and " %s" % classes or "")) 254 self.stream.write('"""') 255 output = textwrap.dedent(s.replace('"""', '\\"\\"\\"')) 256 self.stream.write(self._text(output)) 257 self.stream.write('"""') 258 self.stream.write("</pre>\n") 259 260 def _object_name_def(self, module, obj, classes=None): 261 262 """ 263 Link to the summary for 'module' using 'obj'. The optional 'classes' 264 can be used to customise the CSS classes employed. 265 """ 266 267 if isinstance(obj, Class) or (isinstance(obj, Function) and obj.is_method()): 268 self._summary_link(module.full_name(), obj.full_name(), obj.name, classes) 269 else: 270 self._span(obj.name, classes) 271 272 def _object_name_ref(self, module, obj, name=None, classes=None): 273 274 """ 275 Link to the definition for 'module' using 'obj' with the optional 'name' 276 used as the label (instead of the name of 'obj'). The optional 'classes' 277 can be used to customise the CSS classes employed. 278 """ 279 280 self._name_link(module.full_name(), obj.full_name(), name or obj.name, classes) 281 282 def _summary_link(self, module_name, full_name, name, classes=None): 283 self._name_link("%s-summary" % module_name, full_name, name, classes) 284 285 def _name_link(self, module_name, full_name, name, classes=None): 286 self.stream.write("<a class='%s' href='%s%sxhtml#%s'>%s</a>" % ( 287 classes or "specific-ref", module_name, os.path.extsep, 288 self._attr(full_name), self._text(name))) 289 290 def _module_link(self, module_name, classes=None): 291 self.stream.write("<a class='%s' href='%s%sxhtml'>%s</a>" % ( 292 classes or "name", module_name, os.path.extsep, 293 self._text(module_name))) 294 295 def _scope(self, scope, attr): 296 self.stream.write("<div class='scope'>" 297 "<span class='label'>scope</span><br />%s<br/>" % scope) 298 values = self._values_to_attribute_names(attr) 299 if values: 300 self.stream.write("<span class='label'>values</span><br />") 301 self._attribute_list(values) 302 self.stream.write("</div>\n") 303 304 def _assname(self, name, node): 305 self._span_start("assname") 306 if not self._attrcombined(name, node): 307 self._span(name) 308 self._span_end() 309 310 def _op(self, symbol, name=None, leading=0, trailing=1): 311 if leading: 312 self.stream.write(" ") 313 self._span_start(name and "operation" or None) 314 self._span(symbol, "operator") 315 if name is not None: 316 self._popup_start() 317 self.stream.write("<div class='opnames'>") 318 self._name_link("operator", "operator.%s" % name, name) 319 self.stream.write("</div>\n") 320 self._popup_end() 321 # NOTE: Handle "is" and "in". 322 self._span_end() 323 if trailing: 324 self.stream.write(" ") 325 326 def _names_list_start(self, label, classes): 327 self.stream.write("<div class='%s'><span class='label'>%s</span><br />" % (classes, label)) 328 329 def _names_list_end(self): 330 self.stream.write("</div>\n") 331 332 def _names_list(self, names, label, classes): 333 if not names: 334 return 335 names = list(names) 336 names.sort() 337 338 self._names_list_start(label, classes) 339 first = True 340 for name in names: 341 if not first: 342 self.stream.write("<br />") 343 self.stream.write(name) 344 first = False 345 self._names_list_end() 346 347 def _attrcombined(self, name, node): 348 attrcombined = node._attrcombined and node._attrcombined.get(name) or [] 349 350 # Since assigned values will not be shown, produce a sorted list of 351 # distinct attribute name lists. 352 353 all_attrnames = set() 354 for usage in attrcombined: 355 if usage: 356 all_attrnames.add(tuple(usage.keys())) 357 358 if not all_attrnames: 359 return False 360 361 all_attrnames = list(all_attrnames) 362 all_attrnames.sort() 363 364 # Write the lists of attribute names. 365 366 self._name_start() 367 self.stream.write(name) 368 self._popup_start() 369 for attrnames in all_attrnames: 370 self._attrnames(attrnames) 371 self._popup_end() 372 self._name_end() 373 return True 374 375 def _attrnames(self, attrnames): 376 self._names_list(attrnames, "attributes", "attrnames") 377 378 def _typenames(self, typenames): 379 self._names_list(typenames, "types", "typenames") 380 381 def _accessor_start(self, target_names): 382 if target_names: 383 self._span_start("accessor") 384 self._popup_start("types-popup") 385 self._typenames(target_names) 386 self._popup_end() 387 388 def _accessor_end(self, target_names): 389 if target_names: 390 self._span_end() 391 392 def _values_to_attribute_names(self, attr): 393 394 "Get the output form of the values referenced by 'attr'." 395 396 if isinstance(attr, Const): 397 return [(repr(attr.get_value()), attr)] 398 elif isinstance(attr, Instance): 399 return [] 400 401 have_instances = False 402 values = [] 403 for v in attr.get_values(): 404 if isinstance(v, Const): 405 values.append((repr(v.get_value()), v)) 406 elif not isinstance(v, Instance): 407 values.append((v.full_name(), v)) 408 else: 409 have_instances = True 410 411 if have_instances: 412 values.append(("...", None)) 413 414 values.sort() 415 return values 416 417 def _attributes_to_attribute_names(self, attributes, attrname): 418 419 "Get the output form of the 'attributes'." 420 421 output = [] 422 for value, target, target_name in attributes: 423 if value and not isinstance(value, Instance): 424 fullname = value.full_name() 425 else: 426 fullname = target_name + "." + attrname 427 output.append((fullname, value)) 428 429 output.sort() 430 return output 431 432 def _attribute_start(self, attrname, attributes): 433 if attributes: 434 self._span_start("attr") 435 self._popup_start("attributes-popup") 436 self._names_list_start("attributes", "attrnames") 437 self._attribute_list(attributes) 438 self._names_list_end() 439 self._popup_end() 440 441 def _attribute_list(self, attributes): 442 443 # Mix links to attributes with labels indicating undetermined 444 # attributes. 445 446 last = None 447 for fullname, value in attributes: 448 if fullname != last: 449 if last is not None: 450 self.stream.write("<br />") 451 if value is not None and not isinstance(value, Instance): 452 self._object_name_ref(value.module, value, fullname, classes="attribute-name") 453 else: 454 self.stream.write(self._text(fullname)) 455 last = fullname 456 457 def _attribute_end(self, attributes): 458 if attributes: 459 self._span_end() 460 461 def _get_possible_types(self, attrname): 462 objtable = self.program.get_object_table() 463 return objtable.any_possible_objects([attrname]) 464 465 def _get_attributes(self, possible_types, attrname): 466 objtable = self.program.get_object_table() 467 attributes = [] 468 for target_name in possible_types: 469 target = objtable.get_object(target_name) 470 try: 471 attr = objtable.access(target_name, attrname) 472 except TableError: 473 continue 474 if attr.is_static_attribute(): 475 for v in attr.get_values(): 476 attributes.append((v, target, target_name)) 477 else: 478 attributes.append((None, target, target_name)) 479 480 return attributes 481 482 # Summary classes. 483 484 class Summary(Writer): 485 486 "Summarise classes and attributes in modules." 487 488 def __init__(self, module, program): 489 self.module = module 490 self.program = program 491 492 def to_stream(self, stream): 493 494 "Write the summary to the given 'stream'." 495 496 self.stream = stream 497 self.stream.write(html_header % { 498 "title" : "Module: %s" % self.module.full_name() 499 }) 500 self._write_classes(self.module) 501 self.stream.write(html_footer) 502 503 def _write_classes(self, module): 504 505 all_classes = {} 506 507 for obj in self.module.all_objects: 508 if isinstance(obj, Class): 509 all_classes[obj.name] = obj 510 511 if all_classes: 512 513 all_class_names = all_classes.keys() 514 all_class_names.sort() 515 516 self.stream.write("<table cellspacing='5' cellpadding='5'>\n") 517 self.stream.write("<thead>\n") 518 self.stream.write("<tr>\n") 519 self.stream.write("<th>Classes</th><th>Attributes</th>\n") 520 self.stream.write("</tr>\n") 521 self.stream.write("</thead>\n") 522 523 for name in all_class_names: 524 self._write_class(all_classes[name]) 525 526 self.stream.write("</table>\n") 527 528 def _write_class(self, obj): 529 530 # Write the class... 531 532 self.stream.write("<tbody class='class'>\n") 533 self.stream.write("<tr>\n") 534 self.stream.write("<th class='summary-class' id='%s' rowspan='2'>" % self._attr(obj.full_name())) 535 self._object_name_ref(self.module, obj, classes="class-name") 536 self.stream.write("</th>\n") 537 538 # ...and instance attribute names in order... 539 540 attrs = obj.instance_attributes().values() 541 attrs.sort(cmp=lambda x, y: cmp(x.position, y.position)) 542 543 if attrs: 544 for attr in attrs: 545 self.stream.write("<td class='summary-attr'>%s</td>\n" % self._text(attr.name)) 546 else: 547 self.stream.write("<td class='summary-attr-absent'>None</td>\n") 548 549 self.stream.write("</tr>\n") 550 self.stream.write("<tr>\n") 551 552 # ...and class attribute names in order. 553 554 attrs = obj.class_attributes().values() 555 attrs.sort(cmp=lambda x, y: cmp(x.position, y.position)) 556 557 if attrs: 558 for attr in attrs: 559 if attr.is_strict_constant(): 560 value = attr.get_value() 561 if not isinstance(value, Const): 562 self.stream.write("<td class='summary-class-attr' id='%s'>" % self._attr(value.full_name())) 563 self._object_name_ref(self.module, value, attr.name, classes="summary-ref") 564 self.stream.write("</td>\n") 565 else: 566 self.stream.write("<td class='summary-class-attr'>%s</td>\n" % self._text(attr.name)) 567 else: 568 self.stream.write("<td class='summary-class-attr'>%s</td>\n" % self._text(attr.name)) 569 else: 570 self.stream.write("<td class='summary-class-attr-absent'>None</td>\n") 571 572 self.stream.write("</tr>\n") 573 self.stream.write("</tbody>\n") 574 575 class Interfaces(Writer): 576 577 "Summarise the interfaces used by reading the object table cache." 578 579 def __init__(self, program): 580 self.program = program 581 582 def to_stream(self, stream): 583 584 "Write the summary to the given 'stream'." 585 586 self.stream = stream 587 self.stream.write(html_header % { 588 "title" : "Interfaces" 589 }) 590 self._write_interfaces() 591 self.stream.write(html_footer) 592 593 def _write_interfaces(self): 594 objtable = self.program.get_object_table() 595 all_interfaces = objtable.all_cache.items() 596 all_interfaces.sort() 597 598 self.stream.write("<table cellspacing='5' cellpadding='5'>\n") 599 self.stream.write("<thead>\n") 600 self.stream.write("<tr>\n") 601 self.stream.write("<th>Complete Interfaces</th>\n") 602 self.stream.write("</tr>\n") 603 self.stream.write("</thead>\n") 604 self._write_interface_type(all_interfaces, "complete") 605 self.stream.write("</table>\n") 606 607 def _write_interface_type(self, interfaces, classes=""): 608 self.stream.write("<tbody>\n") 609 610 for names, objects in interfaces: 611 if names: 612 names = list(names) 613 names.sort() 614 self.stream.write("<tr>\n") 615 self.stream.write("<td class='summary-interface %s'>%s</td>" % (classes, ", ".join(names))) 616 self.stream.write("</tr>\n") 617 618 self.stream.write("</tbody>\n") 619 620 # Source code classes. 621 622 class AnnotatedSource(ASTVisitor, Writer): 623 624 "A module source code browser." 625 626 def __init__(self, module, program): 627 self.visitor = self 628 self.module = module 629 self.program = program 630 self.program.unknown_target_nodes = [] 631 self.units = [] 632 633 def to_stream(self, stream): 634 635 "Write the annotated code to the given 'stream'." 636 637 self.stream = stream 638 self.stream.write(html_header % { 639 "title" : "Module: %s" % self.module.full_name() 640 }) 641 self.dispatch(self.module.astnode) 642 self.stream.write(html_footer) 643 644 def visitModule(self, node): 645 self.units.append(node.unit) 646 647 self._doc(node, "module") 648 self.default(node) 649 650 self.units.pop() 651 652 # Statements. 653 654 def visitAssert(self, node): 655 self.stream.write("<div class='assert nowrap'>\n") 656 self._keyword("assert") 657 self.dispatch(node.test) 658 if node.fail: 659 self.stream.write(", ") 660 self.dispatch(node.fail) 661 self.stream.write("</div>\n") 662 663 def visitAssign(self, node): 664 self.stream.write("<div class='assign nowrap'>\n") 665 for lvalue in node.nodes: 666 self.dispatch(lvalue) 667 self.stream.write(" = ") 668 self.dispatch(node.expr) 669 self.stream.write("</div>\n") 670 671 def visitAugAssign(self, node): 672 self.stream.write("<div class='augassign nowrap'>\n") 673 self.dispatch(node.node) 674 self._op(node.op, operator_functions[node.op], 1) 675 self.dispatch(node.expr) 676 self.stream.write("</div>\n") 677 678 def visitBreak(self, node): 679 self.stream.write("<div class='break nowrap'>\n") 680 self._keyword("break") 681 self.stream.write("</div>\n") 682 683 def visitClass(self, node): 684 if not used_by_unit(node): 685 self._docstring('"Class %s not generated."' % node.name) 686 return 687 688 # Use inspected details where possible. 689 690 cls = node.unit 691 self.units.append(cls) 692 693 bases = cls.bases 694 self.stream.write("<div class='class nowrap' id='%s'>\n" % cls.full_name()) 695 696 # Write the declaration line. 697 698 self.stream.write("<div>\n") 699 self._keyword("class") 700 self._object_name_def(self.module, cls, "class-name") 701 702 # Suppress the "object" class appearing alone. 703 704 if bases and not (len(bases) == 1 and bases[0].name == "object"): 705 self.stream.write("(") 706 first = True 707 for base in bases: 708 if not first: 709 self.stream.write(", ") 710 711 self._object_name_ref(base.module, base) 712 713 first = False 714 self.stream.write(")") 715 716 self.stream.write(":\n") 717 self.stream.write("</div>\n") 718 719 # Write the docstring and class body. 720 721 self.stream.write("<div class='body nowrap'>\n") 722 self._doc(node) 723 724 # NOTE: Some streams may not support tell. 725 726 x = self.stream.tell() 727 728 self.default(node.code) 729 730 # Check for no output. 731 732 if x == self.stream.tell(): 733 self.visitPass(None) 734 735 self.stream.write("</div>\n") 736 self.stream.write("</div>\n") 737 738 self.units.pop() 739 740 def visitContinue(self, node): 741 self.stream.write("<div class='continue nowrap'>\n") 742 self._keyword("continue") 743 self.stream.write("</div>\n") 744 745 def visitDiscard(self, node): 746 self.stream.write("<div class='discard nowrap'>\n") 747 self.default(node) 748 self.stream.write("</div>\n") 749 750 def visitFor(self, node): 751 self.stream.write("<div class='if nowrap'>\n") 752 self.stream.write("<div>\n") 753 self._keyword("for") 754 self.dispatch(node.assign) 755 self._keyword("in", 1) 756 self.dispatch(node.list) 757 self.stream.write(":\n") 758 self.stream.write("</div>\n") 759 self.stream.write("<div class='body nowrap'>\n") 760 self.dispatch(node.body) 761 self.stream.write("</div>\n") 762 if node.else_ is not None: 763 self.stream.write("<div>\n") 764 self._keyword("else", trailing=0) 765 self.stream.write(":\n") 766 self.stream.write("</div>\n") 767 self.stream.write("<div class='body nowrap'>\n") 768 self.dispatch(node.else_) 769 self.stream.write("</div>\n") 770 self.stream.write("</div>\n") 771 772 def visitFrom(self, node): 773 self.stream.write("<div class='from nowrap'>\n") 774 self._keyword("from") 775 self._module_link(node.modname) 776 self._keyword("import", 1) 777 first = True 778 for name, alias in node.names: 779 if not first: 780 self.stream.write(", ") 781 self._name(name) 782 if alias: 783 self._keyword("as", 1) 784 self._name(alias) 785 first = False 786 self.stream.write("</div>\n") 787 788 def visitFunction(self, node): 789 if not used_by_unit(node): 790 self._docstring('"Function %s not generated."' % node.name) 791 return 792 793 fn = node.unit 794 self.units.append(fn) 795 796 self.stream.write("<div class='function nowrap' id='%s'>\n" % fn.full_name()) 797 798 # Write the declaration line. 799 800 self.stream.write("<div>\n") 801 self._keyword("def") 802 self._object_name_def(self.module, fn, "function-name") 803 804 self.stream.write("(") 805 self._parameters(fn, node) 806 self.stream.write(")") 807 self.stream.write(":\n") 808 self.stream.write("</div>\n") 809 810 self.stream.write("<div class='body nowrap'>\n") 811 self._doc(node) 812 self.dispatch(node.code) 813 self.stream.write("</div>\n") 814 self.stream.write("</div>\n") 815 816 self.units.pop() 817 818 def visitGlobal(self, node): 819 self.stream.write("<div class='global nowrap'>\n") 820 self._keyword("global") 821 first = True 822 for name in node.names: 823 if not first: 824 self.stream.write(", ") 825 self.stream.write(name) 826 first = False 827 self.stream.write("</div>\n") 828 829 def visitIf(self, node): 830 self.stream.write("<div class='if nowrap'>\n") 831 first = True 832 for compare, stmt in node.tests: 833 self.stream.write("<div>\n") 834 if first: 835 self._keyword("if") 836 else: 837 self._keyword("elif") 838 self.dispatch(compare) 839 self.stream.write(":\n") 840 self.stream.write("</div>\n") 841 self.stream.write("<div class='body nowrap'>\n") 842 self.dispatch(stmt) 843 self.stream.write("</div>\n") 844 first = False 845 if node.else_ is not None: 846 self.stream.write("<div>\n") 847 self._keyword("else", trailing=0) 848 self.stream.write(":\n") 849 self.stream.write("</div>\n") 850 self.stream.write("<div class='body nowrap'>\n") 851 self.dispatch(node.else_) 852 self.stream.write("</div>\n") 853 self.stream.write("</div>\n") 854 855 def visitImport(self, node): 856 self.stream.write("<div class='import nowrap'>\n") 857 self._keyword("import") 858 first = True 859 for name, alias in node.names: 860 if not first: 861 self.stream.write(",\n") 862 self._module_link(name) 863 if alias: 864 self._keyword("as", 1) 865 self._name(alias) 866 first = False 867 self.stream.write("</div>\n") 868 869 def visitPass(self, node): 870 self.stream.write("<div class='pass nowrap'>\n") 871 self._keyword("pass") 872 self.stream.write("</div>\n") 873 874 def visitPrint(self, node): 875 self.stream.write("<div class='print nowrap'>\n") 876 self._keyword("print") 877 if node.dest is not None: 878 self.stream.write(">>\n") 879 self.dispatch(node.dest) 880 self.stream.write(",\n") 881 for n in node.nodes: 882 self.dispatch(n) 883 self.stream.write(",\n") 884 self.stream.write("</div>\n") 885 886 def visitPrintnl(self, node): 887 self.stream.write("<div class='printnl nowrap'>\n") 888 self._keyword("print") 889 if node.dest is not None: 890 self.stream.write(">>\n") 891 self.dispatch(node.dest) 892 first = False 893 else: 894 first = True 895 for n in node.nodes: 896 if not first: 897 self.stream.write(",\n") 898 self.dispatch(n) 899 first = False 900 self.stream.write("</div>\n") 901 902 def visitRaise(self, node): 903 self.stream.write("<div class='raise nowrap'>\n") 904 self._keyword("raise") 905 if node.expr1 is not None: 906 self.dispatch(node.expr1) 907 if node.expr2 is not None: 908 self.stream.write(",\n") 909 self.dispatch(node.expr2) 910 if node.expr3 is not None: 911 self.stream.write(",\n") 912 self.dispatch(node.expr3) 913 self.stream.write("</div>\n") 914 915 def visitReturn(self, node): 916 self.stream.write("<div class='return nowrap'>\n") 917 self._keyword("return") 918 self.dispatch(node.value) 919 self.stream.write("</div>\n") 920 921 def visitStmt(self, node): 922 self.stream.write("<div class='stmt nowrap'>\n") 923 self.default(node) 924 self.stream.write("</div>\n") 925 926 def visitTryExcept(self, node): 927 self.stream.write("<div class='tryexcept nowrap'>\n") 928 self.stream.write("<div>\n") 929 self._keyword("try", trailing=0) 930 self.stream.write(":\n") 931 self.stream.write("</div>\n") 932 self.stream.write("<div class='body nowrap'>\n") 933 self.dispatch(node.body) 934 self.stream.write("</div>\n") 935 for spec, assign, statement in node.handlers: 936 self.stream.write("<div>\n") 937 self._keyword("except") 938 if spec is not None: 939 self.dispatch(spec) 940 if assign is not None: 941 self.stream.write(",\n") 942 self.dispatch(assign) 943 self.stream.write(":\n") 944 self.stream.write("</div>\n") 945 self.stream.write("<div class='body nowrap'>\n") 946 self.dispatch(statement) 947 self.stream.write("</div>\n") 948 if node.else_ is not None: 949 self.stream.write("<div>\n") 950 self._keyword("else", trailing=0) 951 self.stream.write(":\n") 952 self.stream.write("</div>\n") 953 self.stream.write("<div class='body nowrap'>\n") 954 self.dispatch(node.else_) 955 self.stream.write("</div>\n") 956 self.stream.write("</div>\n") 957 958 def visitTryFinally(self, node): 959 self.stream.write("<div class='tryfinally nowrap'>\n") 960 self.stream.write("<div>\n") 961 self._keyword("try", trailing=0) 962 self.stream.write(":\n") 963 self.stream.write("</div>\n") 964 self.stream.write("<div class='body nowrap'>\n") 965 self.dispatch(node.body) 966 self.stream.write("</div>\n") 967 self.stream.write("<div>\n") 968 self._keyword("finally", trailing=0) 969 self.stream.write(":\n") 970 self.stream.write("</div>\n") 971 self.stream.write("<div class='body nowrap'>\n") 972 self.dispatch(node.final) 973 self.stream.write("</div>\n") 974 self.stream.write("</div>\n") 975 976 def visitWhile(self, node): 977 self.stream.write("<div class='while nowrap'>\n") 978 self.stream.write("<div>\n") 979 self._keyword("while") 980 self.dispatch(node.test) 981 self.stream.write(":\n") 982 self.stream.write("</div>\n") 983 self.stream.write("<div class='body nowrap'>\n") 984 self.dispatch(node.body) 985 self.stream.write("</div>\n") 986 if node.else_ is not None: 987 self.stream.write("<div>\n") 988 self._keyword("else", trailing=0) 989 self.stream.write(":\n") 990 self.stream.write("</div>\n") 991 self.stream.write("<div class='body nowrap'>\n") 992 self.dispatch(node.else_) 993 self.stream.write("</div>\n") 994 self.stream.write("</div>\n") 995 996 def visitYield(self, node): 997 self.stream.write("<div class='yield nowrap'>\n") 998 self._keyword("yield") 999 self.dispatch(node.value) 1000 self.stream.write("</div>\n") 1001 1002 # Expression-related helper methods. 1003 1004 def _visitBitBinary(self, node, symbol): 1005 name = operator_functions[node.__class__.__name__] 1006 self._span_start(name) 1007 first = True 1008 for node in node.nodes: 1009 if not first: 1010 self._op(symbol, name, 1) 1011 self.dispatch(node) 1012 first = False 1013 self._span_end() 1014 1015 def _visitBinary(self, node, symbol): 1016 name = operator_functions[node.__class__.__name__] 1017 self._span_start(name) 1018 self.dispatch(node.left) 1019 self._op(symbol, name, 1) 1020 self.dispatch(node.right) 1021 self._span_end() 1022 1023 def _visitUnary(self, node, symbol): 1024 name = operator_functions[node.__class__.__name__] 1025 self._span_start(name) 1026 self._op(symbol, name, trailing=0) 1027 self.dispatch(node.expr) 1028 self._span_end() 1029 1030 # Expressions. 1031 1032 def visitAdd(self, node): 1033 self._visitBinary(node, "+") 1034 1035 def visitAnd(self, node): 1036 self._span_start("and") 1037 first = True 1038 for n in node.nodes: 1039 if not first: 1040 self._keyword("and", 1) 1041 self.dispatch(n) 1042 first = False 1043 self._span_end() 1044 1045 def visitAssAttr(self, node): 1046 possible_types = self.possible_accessor_types(node, defining_users=0) 1047 1048 # Record whether types were already deduced. If not, get types using 1049 # only this attribute. 1050 1051 deduced = possible_types 1052 if not possible_types: 1053 possible_types = self._get_possible_types(node.attrname) 1054 1055 attributes = self._get_attributes(possible_types, node.attrname) 1056 1057 wraps_getattr = self._has_descendant(node.expr, compiler.ast.Getattr) 1058 1059 if not wraps_getattr: 1060 self._span_start("assattr") 1061 self._accessor_start(possible_types) 1062 self.dispatch(node.expr) 1063 if not wraps_getattr: 1064 self._accessor_end(possible_types) 1065 self.stream.write(".") 1066 self._attribute_start(node.attrname, self._attributes_to_attribute_names(attributes, node.attrname)) 1067 self._span(node.attrname, "attrname" + (not possible_types and " no-targets" or not deduced and " any-target" or "")) 1068 self._attribute_end(attributes) 1069 if not wraps_getattr: 1070 self._span_end() 1071 1072 def visitAssList(self, node): 1073 self._span_start("list") 1074 self.stream.write("[") 1075 self._sequence(node) 1076 self.stream.write("]") 1077 self._span_end() 1078 1079 def visitAssName(self, node): 1080 self._assname(node.name, node) 1081 1082 def visitAssTuple(self, node): 1083 self._span_start("tuple") 1084 self.stream.write("(") 1085 self._sequence(node) 1086 self.stream.write(")") 1087 self._span_end() 1088 1089 def visitBitand(self, node): 1090 self._visitBitBinary(node, "&") 1091 1092 def visitBitor(self, node): 1093 self._visitBitBinary(node, "|") 1094 1095 def visitBitxor(self, node): 1096 self._visitBitBinary(node, "^") 1097 1098 def visitCallFunc(self, node): 1099 self._span_start("callfunc") 1100 self.dispatch(node.node) 1101 self._span_start("call") 1102 self.stream.write("(") 1103 first = True 1104 for arg in node.args: 1105 if not first: 1106 self.stream.write(", ") 1107 self.dispatch(arg) 1108 first = False 1109 if node.star_args is not None: 1110 if not first: 1111 self.stream.write(", *") 1112 self.dispatch(node.star_args) 1113 first = False 1114 if node.dstar_args is not None: 1115 if not first: 1116 self.stream.write(", **") 1117 self.dispatch(node.dstar_args) 1118 first = False 1119 self.stream.write(")") 1120 self._span_end() 1121 self._span_end() 1122 1123 def visitCompare(self, node): 1124 self._span_start("compare") 1125 self.dispatch(node.expr) 1126 for op_name, expr in node.ops: 1127 self._op(op_name, operator_functions.get(op_name), 1) 1128 self.dispatch(expr) 1129 self._span_end() 1130 1131 def visitConst(self, node): 1132 if isinstance(node.value, (str, unicode)): 1133 self._span_start("str") 1134 self.stream.write(self._text(repr(node.value))) 1135 if isinstance(node.value, (str, unicode)): 1136 self._span_end() 1137 1138 def visitDict(self, node): 1139 self._span_start("dict") 1140 self.stream.write("{") 1141 self._mapping(node) 1142 self.stream.write("}") 1143 self._span_end() 1144 1145 def visitDiv(self, node): 1146 self._visitBinary(node, "/") 1147 1148 def visitFloorDiv(self, node): 1149 self._visitBinary(node, "//") 1150 1151 def visitGetattr(self, node): 1152 possible_types = self.possible_accessor_types(node, defining_users=0) 1153 1154 # Record whether types were already deduced. If not, get types using 1155 # only this attribute. 1156 1157 deduced = possible_types 1158 if not possible_types: 1159 possible_types = self._get_possible_types(node.attrname) 1160 1161 attributes = self._get_attributes(possible_types, node.attrname) 1162 1163 wraps_getattr = self._has_descendant(node.expr, compiler.ast.Getattr) 1164 1165 if not wraps_getattr: 1166 self._span_start("getattr") 1167 self._accessor_start(possible_types) 1168 1169 self.dispatch(node.expr) 1170 1171 if not wraps_getattr: 1172 self._accessor_end(possible_types) 1173 1174 self.stream.write(".") 1175 1176 self._attribute_start(node.attrname, self._attributes_to_attribute_names(attributes, node.attrname)) 1177 self._span(node.attrname, "attrname" + (not possible_types and " no-targets" or not deduced and " any-target" or "")) 1178 self._attribute_end(attributes) 1179 1180 if not wraps_getattr: 1181 self._span_end() 1182 1183 def visitGenExpr(self, node): 1184 self._span_start("genexpr") 1185 self.stream.write("(") 1186 self.dispatch(node.code) 1187 self.stream.write(")") 1188 self._span_end() 1189 1190 def visitGenExprFor(self, node): 1191 self._span_start("genexprfor") 1192 self._keyword("for", 1) 1193 self._span_start("item") 1194 self.dispatch(node.assign) 1195 self._span_end() 1196 self._keyword("in", 1) 1197 self._span_start("collection") 1198 self.dispatch(node.iter) 1199 self._span_end() 1200 for if_ in node.ifs: 1201 self.dispatch(if_) 1202 self._span_end() 1203 1204 def visitGenExprIf(self, node): 1205 self._span_start("genexprif") 1206 self._span_start("conditional") 1207 self._keyword("if", 1) 1208 self.dispatch(node.test) 1209 self._span_end() 1210 self._span_end() 1211 1212 def visitGenExprInner(self, node): 1213 self._span_start("genexprinner") 1214 self.dispatch(node.expr) 1215 for qual in node.quals: 1216 self.dispatch(qual) 1217 self._span_end() 1218 1219 def visitIfExp(self, node): 1220 self._span_start("ifexp") 1221 self.dispatch(node.then) 1222 self._keyword("if", 1) 1223 self.dispatch(node.test) 1224 self._keyword("else", 1) 1225 self.dispatch(node.else_) 1226 self._span_end() 1227 1228 def visitInvert(self, node): 1229 self._visitUnary(node, "~") 1230 1231 def visitKeyword(self, node): 1232 self._span_start("keyword-arg") 1233 self.stream.write(node.name) 1234 self.stream.write("=") 1235 self.dispatch(node.expr) 1236 self._span_end() 1237 1238 def visitLambda(self, node): 1239 fn = node.unit 1240 self.units.append(fn) 1241 1242 self._span_start("lambda") 1243 self._keyword("lambda") 1244 self._parameters(fn, node) 1245 self.stream.write(": ") 1246 self._span_start("code") 1247 self.dispatch(node.code) 1248 self._span_end() 1249 self._span_end() 1250 1251 self.units.pop() 1252 1253 def visitLeftShift(self, node): 1254 self._visitBinary(node, "<<") 1255 1256 visitList = visitAssList 1257 1258 def visitListComp(self, node): 1259 self._span_start("listcomp") 1260 self.stream.write("[") 1261 self.dispatch(node.expr) 1262 for qual in node.quals: 1263 self.dispatch(qual) 1264 self.stream.write("]") 1265 self._span_end() 1266 1267 def visitListCompFor(self, node): 1268 self._span_start("listcompfor") 1269 self._keyword("for", 1) 1270 self._span_start("item") 1271 self.dispatch(node.assign) 1272 self._span_end() 1273 self._keyword("in", 1) 1274 self._span_start("collection") 1275 self.dispatch(node.list) 1276 self._span_end() 1277 for if_ in node.ifs: 1278 self.dispatch(if_) 1279 self._span_end() 1280 1281 def visitListCompIf(self, node): 1282 self._span_start("listcompif") 1283 self._span_start("conditional") 1284 self._keyword("if", 1) 1285 self.dispatch(node.test) 1286 self._span_end() 1287 self._span_end() 1288 1289 def visitMod(self, node): 1290 self._visitBinary(node, "%") 1291 1292 def visitMul(self, node): 1293 self._visitBinary(node, "*") 1294 1295 def visitName(self, node): 1296 if node._scope: 1297 scope = node._scope 1298 self._name_start() 1299 self.stream.write(node.name) 1300 self._popup_start() 1301 self._scope(node._scope, node._attr) 1302 self._popup_end() 1303 self._name_end() 1304 else: 1305 self._span(node.name) 1306 1307 def visitNot(self, node): 1308 self._span_start("not") 1309 self._keyword("not") 1310 self.dispatch(node.expr) 1311 self._span_end() 1312 1313 def visitOr(self, node): 1314 self._span_start("or") 1315 first = True 1316 for n in node.nodes: 1317 if not first: 1318 self._keyword("or", 1) 1319 self.dispatch(n) 1320 first = False 1321 self._span_end() 1322 1323 def visitPower(self, node): 1324 self._visitBinary(node, "**") 1325 1326 def visitRightShift(self, node): 1327 self._visitBinary(node, ">>") 1328 1329 def visitSlice(self, node): 1330 self._span_start("slice") 1331 self.dispatch(node.expr) 1332 self.stream.write("[") 1333 if node.lower: 1334 self.dispatch(node.lower) 1335 self.stream.write(":") 1336 if node.upper: 1337 self.dispatch(node.upper) 1338 # NOTE: Step? 1339 self.stream.write("]") 1340 self._span_end() 1341 1342 def visitSliceobj(self, node): 1343 self._span_start("sliceobj") 1344 first = True 1345 for n in node.nodes: 1346 if not first: 1347 self.stream.write(":") 1348 self.dispatch(n) 1349 self._span_end() 1350 1351 def visitSub(self, node): 1352 self._visitBinary(node, "-") 1353 1354 def visitSubscript(self, node): 1355 self._span_start("subscript") 1356 self.dispatch(node.expr) 1357 self.stream.write("[") 1358 first = True 1359 for sub in node.subs: 1360 if not first: 1361 self.stream.write(", ") 1362 self.dispatch(sub) 1363 first = False 1364 self.stream.write("]") 1365 self._span_end() 1366 1367 visitTuple = visitAssTuple 1368 1369 def visitUnaryAdd(self, node): 1370 self._visitUnary(node, "+") 1371 1372 def visitUnarySub(self, node): 1373 self._visitUnary(node, "-") 1374 1375 # Output preparation methods. 1376 1377 def _sequence(self, node): 1378 first = True 1379 for n in node.nodes: 1380 if not first: 1381 self.stream.write(", ") 1382 self.dispatch(n) 1383 first = False 1384 1385 def _mapping(self, node): 1386 first = True 1387 for k, v in node.items: 1388 if not first: 1389 self.stream.write(", ") 1390 self.dispatch(k) 1391 self.stream.write(" : ") 1392 self.dispatch(v) 1393 first = False 1394 1395 def _parameters(self, fn, node): 1396 nparams = len(fn.positional_names) 1397 ndefaults = len(fn.defaults) 1398 first_with_default = nparams - ndefaults 1399 1400 first = True 1401 for n, param in enumerate(fn.positional_names): 1402 if not first: 1403 self.stream.write(", ") 1404 1405 # Handle tuple parameters. 1406 1407 if isinstance(param, tuple): 1408 self._tuple_parameter(param, node) 1409 else: 1410 self._assname(param, node) 1411 1412 n_default = n - first_with_default 1413 if n_default >= 0: 1414 self._default(fn.defaults[n_default]) 1415 first = False 1416 1417 if fn.has_star: 1418 if not first: 1419 self.stream.write(", *") 1420 self._name(fn.star_name) 1421 1422 if fn.has_dstar: 1423 if not first: 1424 self.stream.write(", **") 1425 self._name(fn.dstar_name) 1426 1427 def _tuple_parameter(self, parameters, node): 1428 self.stream.write("(") 1429 1430 first = True 1431 for param in parameters: 1432 if not first: 1433 self.stream.write(", ") 1434 1435 # Handle tuples. 1436 1437 if isinstance(param, tuple): 1438 self._tuple_parameter(param, node) 1439 else: 1440 self._assname(param, node) 1441 1442 first = False 1443 1444 self.stream.write(")") 1445 1446 def _default(self, default): 1447 self.stream.write("=") 1448 self.dispatch(default) 1449 1450 # Statistics gathering methods. 1451 1452 def possible_accessor_types(self, node, defining_users=1): 1453 possible_types = [tn for (tn, st) in ASTVisitor.possible_accessor_types(self, node, defining_users)] 1454 if not possible_types: 1455 self.program.unknown_target_nodes.append((self.units[-1], node)) 1456 return possible_types 1457 1458 # Utility methods. 1459 1460 def _has_descendant(self, node, nodetype): 1461 if isinstance(node, nodetype): 1462 return True 1463 else: 1464 for n in node.getChildNodes(): 1465 if self._has_descendant(n, nodetype): 1466 return True 1467 return False 1468 1469 # Convenience functions. 1470 1471 def summarise(module, program, filename): 1472 stream = open(filename, "wb") 1473 try: 1474 summary = Summary(module, program) 1475 summary.to_stream(stream) 1476 finally: 1477 stream.close() 1478 1479 def annotate(module, program, filename): 1480 stream = open(filename, "wb") 1481 try: 1482 source = AnnotatedSource(module, program) 1483 source.to_stream(stream) 1484 finally: 1485 stream.close() 1486 1487 def interfaces(program, filename): 1488 stream = open(filename, "wb") 1489 try: 1490 source = Interfaces(program) 1491 source.to_stream(stream) 1492 finally: 1493 stream.close() 1494 1495 def report(program, directory): 1496 if not exists(directory): 1497 os.mkdir(directory) 1498 1499 for module in program.get_importer().get_modules(): 1500 annotate(module, program, join(directory, "%s%sxhtml" % (module.full_name(), extsep))) 1501 summarise(module, program, join(directory, "%s-summary%sxhtml" % (module.full_name(), extsep))) 1502 1503 interfaces(program, join(directory, "-interfaces%sxhtml" % extsep)) 1504 1505 # vim: tabstop=4 expandtab shiftwidth=4