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