Lines Matching refs:self
103 def __init__(self, dir, name, topname, title, next, prev, up): argument
104 self.dirname = dir
105 self.name = name
107 self.topname = topname
109 self.topname = name
110 self.title = title
111 self.next = next
112 self.prev = prev
113 self.up = up
114 self.lines = []
116 def write(self, *lines): argument
117 map(self.lines.append, lines)
119 def flush(self): argument
120 fp = open(self.dirname + '/' + makefile(self.name), 'w')
121 fp.write(self.prologue)
122 fp.write(self.text)
123 fp.write(self.epilogue)
126 def link(self, label, nodename, rel=None, rev=None): argument
134 self.write(label, ': <A HREF="', addr, '"', \
139 def finalize(self): argument
140 length = len(self.lines)
141 self.text = ''.join(self.lines)
142 self.lines = []
143 self.open_links()
144 self.output_links()
145 self.close_links()
146 links = ''.join(self.lines)
147 self.lines = []
148 self.prologue = (
149 self.DOCTYPE +
152 ' <TITLE>' + self.title + '</TITLE>\n'
154 + makefile(self.next) + '" TITLE="' + self.next + '">\n'
156 + makefile(self.prev) + '" TITLE="' + self.prev + '">\n'
158 + makefile(self.up) + '" TITLE="' + self.up + '">\n'
162 self.epilogue = '<P>\n%s</BODY></HTML>\n' % links
164 def open_links(self): argument
165 self.write('<HR>\n')
167 def close_links(self): argument
168 self.write('<HR>\n')
170 def output_links(self): argument
171 if self.cont != self.next:
172 self.link(' Cont', self.cont)
173 self.link(' Next', self.next, rel='Next')
174 self.link(' Prev', self.prev, rel='Previous')
175 self.link(' Up', self.up, rel='Up')
176 if self.name <> self.topname:
177 self.link(' Top', self.topname)
184 def open_links(self): argument
185 self.write('<DIV CLASS=Navigation>\n <HR>\n')
187 def close_links(self): argument
188 self.write(' <HR>\n</DIV>\n')
208 def __init__(self): argument
209 self.unknown = {} # statistics about unknown @-commands
210 self.filenames = {} # Check for identical filenames
211 self.debugging = 0 # larger values produce more output
212 self.print_headers = 0 # always print headers?
213 self.nodefp = None # open file we're writing to
214 self.nodelineno = 0 # Linenumber relative to node
215 self.links = None # Links from current node
216 self.savetext = None # If not None, save text head instead
217 self.savestack = [] # If not None, save text head instead
218 self.htmlhelp = None # html help data
219 self.dirname = 'tmp' # directory where files are created
220 self.includedir = '.' # directory to search @include files
221 self.nodename = '' # name of current node
222 self.topname = '' # name of top node (first node seen)
223 self.title = '' # title of this whole Texinfo tree
224 self.resetindex() # Reset all indices
225 self.contents = [] # Reset table of contents
226 self.numbering = [] # Reset section numbering counters
227 self.nofill = 0 # Normal operation: fill paragraphs
228 self.values={'html': 1} # Names that should be parsed in ifset
229 self.stackinfo={} # Keep track of state in the stack
231 self.footnotes = [] # Reset list of footnotes
232 self.itemarg = None # Reset command used by @item
233 self.itemnumber = None # Reset number for @item in @enumerate
234 self.itemindex = None # Reset item index name
235 self.node = None
236 self.nodestack = []
237 self.cont = 0
238 self.includedepth = 0
241 def sethtmlhelp(self, htmlhelp): argument
242 self.htmlhelp = htmlhelp
245 def setdirname(self, dirname): argument
246 self.dirname = dirname
249 def setincludedir(self, includedir): argument
250 self.includedir = includedir
253 def parse(self, fp): argument
261 self.parserest(fp, lineno)
264 def parserest(self, fp, initial_lineno): argument
266 self.done = 0
267 self.skip = 0
268 self.stack = []
270 while not self.done:
272 self.nodelineno = self.nodelineno + 1
275 if not self.skip: self.process(accu)
289 if not self.skip:
290 self.process(accu)
292 self.command(line, mo)
294 'format' not in self.stack and \
295 'example' not in self.stack:
297 if not self.skip:
298 self.process(accu)
299 if self.nofill:
300 self.write('\n')
302 self.write('<P>\n')
308 if self.skip:
310 if self.stack:
312 print '***', self.stack
313 if self.includedepth == 0:
314 while self.nodestack:
315 self.nodestack[-1].finalize()
316 self.nodestack[-1].flush()
317 del self.nodestack[-1]
320 def startsaving(self): argument
321 if self.savetext <> None:
322 self.savestack.append(self.savetext)
324 self.savetext = ''
327 def collectsavings(self): argument
328 savetext = self.savetext
329 if len(self.savestack) > 0:
330 self.savetext = self.savestack[-1]
331 del self.savestack[-1]
333 self.savetext = None
337 def write(self, *args): argument
343 if self.savetext <> None:
344 self.savetext = self.savetext + text
345 elif self.nodefp:
346 self.nodefp.write(text)
347 elif self.node:
348 self.node.write(text)
351 def endnode(self): argument
352 if self.savetext <> None:
354 dummy = self.collectsavings()
355 if self.footnotes:
356 self.writefootnotes()
357 if self.nodefp:
358 if self.nodelineno > 20:
359 self.write('<HR>\n')
360 [name, next, prev, up] = self.nodelinks[:4]
361 self.link('Next', next)
362 self.link('Prev', prev)
363 self.link('Up', up)
364 if self.nodename <> self.topname:
365 self.link('Top', self.topname)
366 self.write('<HR>\n')
367 self.write('</BODY>\n')
368 self.nodefp.close()
369 self.nodefp = None
370 elif self.node:
371 if not self.cont and \
372 (not self.node.type or \
373 (self.node.next and self.node.prev and self.node.up)):
374 self.node.finalize()
375 self.node.flush()
377 self.nodestack.append(self.node)
378 self.node = None
379 self.nodename = ''
383 def process(self, accu): argument
384 if self.debugging > 1:
385 print '!'*self.debugging, 'process:', self.skip, self.stack,
389 if self.inmenu():
395 self.expand(line)
407 self.write(' <LI><A HREF="',
411 self.htmlhelp.menuitem(nodename)
412 self.expand(line[end:])
415 self.expand(text)
418 def inmenu(self): argument
421 stack = self.stack
424 if self.stackinfo[len(stack)]:
432 def expand(self, text): argument
442 self.write(text[start:])
444 self.write(text[start:i])
448 self.write('\n')
451 self.write('<')
454 self.write('>')
457 self.write('&')
465 self.write('}')
470 method = getattr(self, 'close_' + cmd)
472 self.unknown_close(cmd)
492 self.write(c)
499 method = getattr(self, 'open_' + cmd)
501 self.unknown_open(cmd)
506 method = getattr(self, 'handle_' + cmd)
508 self.unknown_handle(cmd)
516 def unknown_open(self, cmd): argument
519 self.write('@', cmd)
520 if not self.unknown.has_key(cmd):
521 self.unknown[cmd] = 1
523 self.unknown[cmd] = self.unknown[cmd] + 1
525 def unknown_close(self, cmd): argument
528 self.write('}')
529 if not self.unknown.has_key(cmd):
530 self.unknown[cmd] = 1
532 self.unknown[cmd] = self.unknown[cmd] + 1
534 def unknown_handle(self, cmd): argument
536 self.write('@', cmd)
537 if not self.unknown.has_key(cmd):
538 self.unknown[cmd] = 1
540 self.unknown[cmd] = self.unknown[cmd] + 1
546 def handle_noindent(self): pass argument
548 def handle_refill(self): pass argument
552 def do_include(self, args): argument
554 file = os.path.join(self.includedir, file)
560 print '!'*self.debugging, '--> file', repr(file)
561 save_done = self.done
562 save_skip = self.skip
563 save_stack = self.stack
564 self.includedepth = self.includedepth + 1
565 self.parserest(fp, 0)
566 self.includedepth = self.includedepth - 1
568 self.done = save_done
569 self.skip = save_skip
570 self.stack = save_stack
571 print '!'*self.debugging, '<-- file', repr(file)
575 def open_dmn(self): pass argument
576 def close_dmn(self): pass argument
578 def open_dots(self): self.write('...') argument
579 def close_dots(self): pass argument
581 def open_bullet(self): pass argument
582 def close_bullet(self): pass argument
584 def open_TeX(self): self.write('TeX') argument
585 def close_TeX(self): pass argument
587 def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL) argument
588 def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL) argument
589 def close_copyright(self): pass argument
591 def open_minus(self): self.write('-') argument
592 def close_minus(self): pass argument
630 def open_exclamdown(self): self.write('¡') # upside-down ! argument
631 def close_exclamdown(self): pass argument
632 def open_questiondown(self): self.write('¿') # upside-down ? argument
633 def close_questiondown(self): pass argument
634 def open_aa(self): self.write('å') # a with circle argument
635 def close_aa(self): pass argument
636 def open_AA(self): self.write('Å') # A with circle argument
637 def close_AA(self): pass argument
638 def open_ae(self): self.write('æ') # ae ligatures argument
639 def close_ae(self): pass argument
640 def open_AE(self): self.write('Æ') # AE ligatures argument
641 def close_AE(self): pass argument
642 def open_o(self): self.write('ø') # o with slash argument
643 def close_o(self): pass argument
644 def open_O(self): self.write('Ø') # O with slash argument
645 def close_O(self): pass argument
646 def open_ss(self): self.write('ß') # es-zet or sharp S argument
647 def close_ss(self): pass argument
648 def open_oe(self): self.write('oe') # oe ligatures argument
649 def close_oe(self): pass argument
650 def open_OE(self): self.write('OE') # OE ligatures argument
651 def close_OE(self): pass argument
652 def open_l(self): self.write('l/') # suppressed-l argument
653 def close_l(self): pass argument
654 def open_L(self): self.write('L/') # suppressed-L argument
655 def close_L(self): pass argument
659 def open_result(self): self.write('=>') argument
660 def close_result(self): pass argument
662 def open_expansion(self): self.write('==>') argument
663 def close_expansion(self): pass argument
665 def open_print(self): self.write('-|') argument
666 def close_print(self): pass argument
668 def open_error(self): self.write('error-->') argument
669 def close_error(self): pass argument
671 def open_equiv(self): self.write('==') argument
672 def close_equiv(self): pass argument
674 def open_point(self): self.write('-!-') argument
675 def close_point(self): pass argument
679 def open_pxref(self): argument
680 self.write('see ')
681 self.startsaving()
682 def close_pxref(self): argument
683 self.makeref()
685 def open_xref(self): argument
686 self.write('See ')
687 self.startsaving()
688 def close_xref(self): argument
689 self.makeref()
691 def open_ref(self): argument
692 self.startsaving()
693 def close_ref(self): argument
694 self.makeref()
696 def open_inforef(self): argument
697 self.write('See info file ')
698 self.startsaving()
699 def close_inforef(self): argument
700 text = self.collectsavings()
705 self.write('`', file, '\', node `', node, '\'')
707 def makeref(self): argument
708 text = self.collectsavings()
718 self.write('<A HREF="', href, '">', label, '</A>')
721 def open_uref(self): argument
722 self.startsaving()
723 def close_uref(self): argument
724 text = self.collectsavings()
730 self.write('<A HREF="', href, '">', label, '</A>')
739 def open_image(self): argument
740 self.startsaving()
741 def close_image(self): argument
742 self.makeimage()
743 def makeimage(self): argument
744 text = self.collectsavings()
758 imagelocation = self.dirname + '/' + filename
769 self.write('<IMG SRC="', filename, '"', \
774 self.htmlhelp.addimage(imagelocation)
781 def open_(self): pass # Used by {text enclosed in braces} argument
782 def close_(self): pass argument
787 def open_cite(self): self.write('<CITE>') argument
788 def close_cite(self): self.write('</CITE>') argument
790 def open_code(self): self.write('<CODE>') argument
791 def close_code(self): self.write('</CODE>') argument
793 def open_t(self): self.write('<TT>') argument
794 def close_t(self): self.write('</TT>') argument
796 def open_dfn(self): self.write('<DFN>') argument
797 def close_dfn(self): self.write('</DFN>') argument
799 def open_emph(self): self.write('<EM>') argument
800 def close_emph(self): self.write('</EM>') argument
802 def open_i(self): self.write('<I>') argument
803 def close_i(self): self.write('</I>') argument
805 def open_footnote(self): argument
808 id = len(self.footnotes) + 1
809 self.write(self.FN_SOURCE_PATTERN % {'id': repr(id)})
810 self.startsaving()
812 def close_footnote(self): argument
813 id = len(self.footnotes) + 1
814 self.footnotes.append((id, self.collectsavings()))
816 def writefootnotes(self): argument
817 self.write(self.FN_HEADER)
818 for id, text in self.footnotes:
819 self.write(self.FN_TARGET_PATTERN
821 self.footnotes = []
823 def open_file(self): self.write('<CODE>') argument
824 def close_file(self): self.write('</CODE>') argument
826 def open_kbd(self): self.write('<KBD>') argument
827 def close_kbd(self): self.write('</KBD>') argument
829 def open_key(self): self.write('<KEY>') argument
830 def close_key(self): self.write('</KEY>') argument
832 def open_r(self): self.write('<R>') argument
833 def close_r(self): self.write('</R>') argument
835 def open_samp(self): self.write('`<SAMP>') argument
836 def close_samp(self): self.write('</SAMP>\'') argument
838 def open_sc(self): self.write('<SMALLCAPS>') argument
839 def close_sc(self): self.write('</SMALLCAPS>') argument
841 def open_strong(self): self.write('<STRONG>') argument
842 def close_strong(self): self.write('</STRONG>') argument
844 def open_b(self): self.write('<B>') argument
845 def close_b(self): self.write('</B>') argument
847 def open_var(self): self.write('<VAR>') argument
848 def close_var(self): self.write('</VAR>') argument
850 def open_w(self): self.write('<NOBREAK>') argument
851 def close_w(self): self.write('</NOBREAK>') argument
853 def open_url(self): self.startsaving() argument
854 def close_url(self): argument
855 text = self.collectsavings()
856 self.write('<A HREF="', text, '">', text, '</A>')
858 def open_email(self): self.startsaving() argument
859 def close_email(self): argument
860 text = self.collectsavings()
861 self.write('<A HREF="mailto:', text, '">', text, '</A>')
866 def open_small(self): pass argument
867 def close_small(self): pass argument
869 def command(self, line, mo): argument
873 if self.debugging > 1:
874 print '!'*self.debugging, 'command:', self.skip, self.stack, \
877 func = getattr(self, 'do_' + cmd)
880 func = getattr(self, 'bgn_' + cmd)
883 if not self.skip:
884 self.unknown_cmd(cmd, args)
886 self.stack.append(cmd)
889 if not self.skip or cmd == 'end':
892 def unknown_cmd(self, cmd, args): argument
894 if not self.unknown.has_key(cmd):
895 self.unknown[cmd] = 1
897 self.unknown[cmd] = self.unknown[cmd] + 1
899 def do_end(self, args): argument
905 if not self.stack or self.stack[-1] <> cmd:
908 del self.stack[-1]
910 func = getattr(self, 'end_' + cmd)
912 self.unknown_end(cmd)
916 def unknown_end(self, cmd): argument
919 if not self.unknown.has_key(cmd):
920 self.unknown[cmd] = 1
922 self.unknown[cmd] = self.unknown[cmd] + 1
926 def do_comment(self, args): pass argument
931 def bgn_ifinfo(self, args): pass argument
932 def end_ifinfo(self): pass argument
934 def bgn_iftex(self, args): self.skip = self.skip + 1 argument
935 def end_iftex(self): self.skip = self.skip - 1 argument
937 def bgn_ignore(self, args): self.skip = self.skip + 1 argument
938 def end_ignore(self): self.skip = self.skip - 1 argument
940 def bgn_tex(self, args): self.skip = self.skip + 1 argument
941 def end_tex(self): self.skip = self.skip - 1 argument
943 def do_set(self, args): argument
950 self.values[key] = value
952 def do_clear(self, args): argument
953 self.values[args] = None
955 def bgn_ifset(self, args): argument
956 if args not in self.values.keys() \
957 or self.values[args] is None:
958 self.skip = self.skip + 1
959 self.stackinfo[len(self.stack)] = 1
961 self.stackinfo[len(self.stack)] = 0
962 def end_ifset(self): argument
964 if self.stackinfo[len(self.stack) + 1]:
965 self.skip = self.skip - 1
966 del self.stackinfo[len(self.stack) + 1]
968 print '*** end_ifset: KeyError :', len(self.stack) + 1
970 def bgn_ifclear(self, args): argument
971 if args in self.values.keys() \
972 and self.values[args] is not None:
973 self.skip = self.skip + 1
974 self.stackinfo[len(self.stack)] = 1
976 self.stackinfo[len(self.stack)] = 0
977 def end_ifclear(self): argument
979 if self.stackinfo[len(self.stack) + 1]:
980 self.skip = self.skip - 1
981 del self.stackinfo[len(self.stack) + 1]
983 print '*** end_ifclear: KeyError :', len(self.stack) + 1
985 def open_value(self): argument
986 self.startsaving()
988 def close_value(self): argument
989 key = self.collectsavings()
990 if key in self.values.keys():
991 self.write(self.values[key])
1001 def do_settitle(self, args): argument
1002 self.startsaving()
1003 self.expand(args)
1004 self.title = self.collectsavings()
1005 def do_parskip(self, args): pass argument
1009 def do_bye(self, args): argument
1010 self.endnode()
1011 self.done = 1
1015 def bgn_titlepage(self, args): self.skip = self.skip + 1 argument
1016 def end_titlepage(self): self.skip = self.skip - 1 argument
1017 def do_shorttitlepage(self, args): pass argument
1019 def do_center(self, args): argument
1021 self.write('<H1>')
1022 self.expand(args)
1023 self.write('</H1>\n')
1046 def do_node(self, args): argument
1047 self.endnode()
1048 self.nodelineno = 0
1051 self.nodelinks = parts
1053 file = self.dirname + '/' + makefile(name)
1054 if self.filenames.has_key(file):
1057 if self.debugging: print '!'*self.debugging, '--- writing', file
1058 self.filenames[file] = 1
1060 self.nodename = name
1061 if self.cont and self.nodestack:
1062 self.nodestack[-1].cont = self.nodename
1063 if not self.topname: self.topname = name
1065 if self.title: title = title + ' -- ' + self.title
1066 self.node = self.Node(self.dirname, self.nodename, self.topname,
1068 self.htmlhelp.addnode(self.nodename,next,prev,up,file)
1070 def link(self, label, nodename): argument
1076 self.write(label, ': <A HREF="', addr, '" TYPE="',
1081 def popstack(self, type): argument
1082 if (self.node):
1083 self.node.type = type
1084 while self.nodestack:
1085 if self.nodestack[-1].type > type:
1086 self.nodestack[-1].finalize()
1087 self.nodestack[-1].flush()
1088 del self.nodestack[-1]
1089 elif self.nodestack[-1].type == type:
1090 if not self.nodestack[-1].next:
1091 self.nodestack[-1].next = self.node.name
1092 if not self.node.prev:
1093 self.node.prev = self.nodestack[-1].name
1094 self.nodestack[-1].finalize()
1095 self.nodestack[-1].flush()
1096 del self.nodestack[-1]
1098 if type > 1 and not self.node.up:
1099 self.node.up = self.nodestack[-1].name
1102 def do_chapter(self, args): argument
1103 self.heading('H1', args, 0)
1104 self.popstack(1)
1106 def do_unnumbered(self, args): argument
1107 self.heading('H1', args, -1)
1108 self.popstack(1)
1109 def do_appendix(self, args): argument
1110 self.heading('H1', args, -1)
1111 self.popstack(1)
1112 def do_top(self, args): argument
1113 self.heading('H1', args, -1)
1114 def do_chapheading(self, args): argument
1115 self.heading('H1', args, -1)
1116 def do_majorheading(self, args): argument
1117 self.heading('H1', args, -1)
1119 def do_section(self, args): argument
1120 self.heading('H1', args, 1)
1121 self.popstack(2)
1123 def do_unnumberedsec(self, args): argument
1124 self.heading('H1', args, -1)
1125 self.popstack(2)
1126 def do_appendixsec(self, args): argument
1127 self.heading('H1', args, -1)
1128 self.popstack(2)
1130 def do_heading(self, args): argument
1131 self.heading('H1', args, -1)
1133 def do_subsection(self, args): argument
1134 self.heading('H2', args, 2)
1135 self.popstack(3)
1136 def do_unnumberedsubsec(self, args): argument
1137 self.heading('H2', args, -1)
1138 self.popstack(3)
1139 def do_appendixsubsec(self, args): argument
1140 self.heading('H2', args, -1)
1141 self.popstack(3)
1142 def do_subheading(self, args): argument
1143 self.heading('H2', args, -1)
1145 def do_subsubsection(self, args): argument
1146 self.heading('H3', args, 3)
1147 self.popstack(4)
1148 def do_unnumberedsubsubsec(self, args): argument
1149 self.heading('H3', args, -1)
1150 self.popstack(4)
1151 def do_appendixsubsubsec(self, args): argument
1152 self.heading('H3', args, -1)
1153 self.popstack(4)
1154 def do_subsubheading(self, args): argument
1155 self.heading('H3', args, -1)
1157 def heading(self, type, args, level): argument
1159 while len(self.numbering) <= level:
1160 self.numbering.append(0)
1161 del self.numbering[level+1:]
1162 self.numbering[level] = self.numbering[level] + 1
1164 for i in self.numbering:
1167 self.contents.append((level, args, self.nodename))
1168 self.write('<', type, '>')
1169 self.expand(args)
1170 self.write('</', type, '>\n')
1171 if self.debugging or self.print_headers:
1174 def do_contents(self, args): argument
1176 self.listcontents('Table of Contents', 999)
1178 def do_shortcontents(self, args): argument
1183 def listcontents(self, title, maxlevel): argument
1184 self.write('<H1>', title, '</H1>\n<UL COMPACT PLAIN>\n')
1186 for level, title, node in self.contents:
1191 self.write(' '*prevlevels[-1], '<UL PLAIN>\n')
1197 self.write(' '*prevlevels[-1],
1199 self.write(' '*level, '<LI> <A HREF="',
1201 self.expand(title)
1202 self.write('</A>\n')
1203 self.write('</UL>\n' * len(prevlevels))
1209 def do_page(self, args): pass argument
1211 def do_need(self, args): pass argument
1213 def bgn_group(self, args): pass argument
1214 def end_group(self): pass argument
1218 def do_sp(self, args): argument
1219 if self.nofill:
1220 self.write('\n')
1222 self.write('<P>\n')
1224 def do_hline(self, args): argument
1225 self.write('<HR>')
1229 def bgn_deffn(self, args): argument
1230 self.write('<DL>')
1231 self.do_deffnx(args)
1233 def end_deffn(self): argument
1234 self.write('</DL>\n')
1236 def do_deffnx(self, args): argument
1237 self.write('<DT>')
1240 self.expand('@b{%s}' % name)
1241 for word in rest: self.expand(' ' + makevar(word))
1243 self.write('\n<DD>')
1244 self.index('fn', name)
1246 def bgn_defun(self, args): self.bgn_deffn('Function ' + args) argument
1248 def do_defunx(self, args): self.do_deffnx('Function ' + args) argument
1250 def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args) argument
1252 def do_defmacx(self, args): self.do_deffnx('Macro ' + args) argument
1254 def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args) argument
1256 def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args) argument
1258 def bgn_defvr(self, args): argument
1259 self.write('<DL>')
1260 self.do_defvrx(args)
1264 def do_defvrx(self, args): argument
1265 self.write('<DT>')
1268 self.expand('@code{%s}' % name)
1270 for word in rest: self.expand(' ' + word)
1272 self.write('\n<DD>')
1273 self.index('vr', name)
1275 def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args) argument
1277 def do_defvarx(self, args): self.do_defvrx('Variable ' + args) argument
1279 def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args) argument
1281 def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args) argument
1285 def bgn_deftypefn(self, args): argument
1286 self.write('<DL>')
1287 self.do_deftypefnx(args)
1291 def do_deftypefnx(self, args): argument
1292 self.write('<DT>')
1295 self.expand('@code{%s} @b{%s}' % (datatype, name))
1296 for word in rest: self.expand(' ' + makevar(word))
1298 self.write('\n<DD>')
1299 self.index('fn', name)
1302 def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args) argument
1304 def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args) argument
1306 def bgn_deftypevr(self, args): argument
1307 self.write('<DL>')
1308 self.do_deftypevrx(args)
1312 def do_deftypevrx(self, args): argument
1313 self.write('<DT>')
1316 self.expand('@code{%s} @b{%s}' % (datatype, name))
1318 for word in rest: self.expand(' ' + word)
1320 self.write('\n<DD>')
1321 self.index('fn', name)
1323 def bgn_deftypevar(self, args): argument
1324 self.bgn_deftypevr('Variable ' + args)
1326 def do_deftypevarx(self, args): argument
1327 self.do_deftypevrx('Variable ' + args)
1331 def bgn_defcv(self, args): argument
1332 self.write('<DL>')
1333 self.do_defcvx(args)
1337 def do_defcvx(self, args): argument
1338 self.write('<DT>')
1341 self.expand('@b{%s}' % name)
1343 for word in rest: self.expand(' ' + word)
1345 self.write('\n<DD>')
1346 self.index('vr', '%s @r{on %s}' % (name, classname))
1348 def bgn_defivar(self, args): argument
1349 self.bgn_defcv('{Instance Variable} ' + args)
1351 def do_defivarx(self, args): argument
1352 self.do_defcvx('{Instance Variable} ' + args)
1354 def bgn_defop(self, args): argument
1355 self.write('<DL>')
1356 self.do_defopx(args)
1360 def do_defopx(self, args): argument
1361 self.write('<DT>')
1364 self.expand('@b{%s}' % name)
1365 for word in rest: self.expand(' ' + makevar(word))
1367 self.write('\n<DD>')
1368 self.index('fn', '%s @r{on %s}' % (name, classname))
1370 def bgn_defmethod(self, args): argument
1371 self.bgn_defop('Method ' + args)
1373 def do_defmethodx(self, args): argument
1374 self.do_defopx('Method ' + args)
1378 def bgn_deftp(self, args): argument
1379 self.write('<DL>')
1380 self.do_deftpx(args)
1384 def do_deftpx(self, args): argument
1385 self.write('<DT>')
1388 self.expand('@b{%s}' % name)
1389 for word in rest: self.expand(' ' + word)
1391 self.write('\n<DD>')
1392 self.index('tp', name)
1396 def bgn_enumerate(self, args): argument
1398 self.write('<OL>\n')
1399 self.stackinfo[len(self.stack)] = '</OL>\n'
1401 self.itemnumber = args
1402 self.write('<UL>\n')
1403 self.stackinfo[len(self.stack)] = '</UL>\n'
1404 def end_enumerate(self): argument
1405 self.itemnumber = None
1406 self.write(self.stackinfo[len(self.stack) + 1])
1407 del self.stackinfo[len(self.stack) + 1]
1409 def bgn_itemize(self, args): argument
1410 self.itemarg = args
1411 self.write('<UL>\n')
1412 def end_itemize(self): argument
1413 self.itemarg = None
1414 self.write('</UL>\n')
1416 def bgn_table(self, args): argument
1417 self.itemarg = args
1418 self.write('<DL>\n')
1419 def end_table(self): argument
1420 self.itemarg = None
1421 self.write('</DL>\n')
1423 def bgn_ftable(self, args): argument
1424 self.itemindex = 'fn'
1425 self.bgn_table(args)
1426 def end_ftable(self): argument
1427 self.itemindex = None
1428 self.end_table()
1430 def bgn_vtable(self, args): argument
1431 self.itemindex = 'vr'
1432 self.bgn_table(args)
1433 def end_vtable(self): argument
1434 self.itemindex = None
1435 self.end_table()
1437 def do_item(self, args): argument
1438 if self.itemindex: self.index(self.itemindex, args)
1439 if self.itemarg:
1440 if self.itemarg[0] == '@' and self.itemarg[1] and \
1441 self.itemarg[1] in string.ascii_letters:
1442 args = self.itemarg + '{' + args + '}'
1445 args = self.itemarg + ' ' + args
1446 if self.itemnumber <> None:
1447 args = self.itemnumber + '. ' + args
1448 self.itemnumber = increment(self.itemnumber)
1449 if self.stack and self.stack[-1] == 'table':
1450 self.write('<DT>')
1451 self.expand(args)
1452 self.write('\n<DD>')
1453 elif self.stack and self.stack[-1] == 'multitable':
1454 self.write('<TR><TD>')
1455 self.expand(args)
1456 self.write('</TD>\n</TR>\n')
1458 self.write('<LI>')
1459 self.expand(args)
1460 self.write(' ')
1464 def bgn_multitable(self, args): argument
1465 self.itemarg = None # should be handled by columnfractions
1466 self.write('<TABLE BORDER="">\n')
1467 def end_multitable(self): argument
1468 self.itemarg = None
1469 self.write('</TABLE>\n<BR>\n')
1470 def handle_columnfractions(self): argument
1472 self.itemarg = None
1473 def handle_tab(self): argument
1474 self.write('</TD>\n <TD>')
1479 def bgn_quotation(self, args): self.write('<BLOCKQUOTE>') argument
1480 def end_quotation(self): self.write('</BLOCKQUOTE>\n') argument
1482 def bgn_example(self, args): argument
1483 self.nofill = self.nofill + 1
1484 self.write('<PRE>')
1485 def end_example(self): argument
1486 self.write('</PRE>\n')
1487 self.nofill = self.nofill - 1
1504 def do_exdent(self, args): self.expand(args + '\n') argument
1507 def bgn_flushleft(self, args): argument
1508 self.nofill = self.nofill + 1
1509 self.write('<PRE>\n')
1510 def end_flushleft(self): argument
1511 self.write('</PRE>\n')
1512 self.nofill = self.nofill - 1
1514 def bgn_flushright(self, args): argument
1515 self.nofill = self.nofill + 1
1516 self.write('<ADDRESS COMPACT>\n')
1517 def end_flushright(self): argument
1518 self.write('</ADDRESS>\n')
1519 self.nofill = self.nofill - 1
1521 def bgn_menu(self, args): argument
1522 self.write('<DIR>\n')
1523 self.write(' <STRONG><EM>Menu</EM></STRONG><P>\n')
1524 self.htmlhelp.beginmenu()
1525 def end_menu(self): argument
1526 self.write('</DIR>\n')
1527 self.htmlhelp.endmenu()
1529 def bgn_cartouche(self, args): pass argument
1530 def end_cartouche(self): pass argument
1534 def resetindex(self): argument
1535 self.noncodeindices = ['cp']
1536 self.indextitle = {}
1537 self.indextitle['cp'] = 'Concept'
1538 self.indextitle['fn'] = 'Function'
1539 self.indextitle['ky'] = 'Keyword'
1540 self.indextitle['pg'] = 'Program'
1541 self.indextitle['tp'] = 'Type'
1542 self.indextitle['vr'] = 'Variable'
1544 self.whichindex = {}
1545 for name in self.indextitle.keys():
1546 self.whichindex[name] = []
1548 def user_index(self, name, args): argument
1549 if self.whichindex.has_key(name):
1550 self.index(name, args)
1554 def do_cindex(self, args): self.index('cp', args) argument
1555 def do_findex(self, args): self.index('fn', args) argument
1556 def do_kindex(self, args): self.index('ky', args) argument
1557 def do_pindex(self, args): self.index('pg', args) argument
1558 def do_tindex(self, args): self.index('tp', args) argument
1559 def do_vindex(self, args): self.index('vr', args) argument
1561 def index(self, name, args): argument
1562 self.whichindex[name].append((args, self.nodename))
1563 self.htmlhelp.index(args, self.nodename)
1565 def do_synindex(self, args): argument
1571 if not self.whichindex.has_key(old) or \
1572 not self.whichindex.has_key(new):
1576 self.whichindex[old] is not self.whichindex[new]:
1577 inew = self.whichindex[new]
1578 inew[len(inew):] = self.whichindex[old]
1579 self.whichindex[old] = inew
1582 def do_printindex(self, args): argument
1585 if self.whichindex.has_key(name):
1586 self.prindex(name)
1590 def prindex(self, name): argument
1591 iscodeindex = (name not in self.noncodeindices)
1592 index = self.whichindex[name]
1594 if self.debugging:
1595 print '!'*self.debugging, '--- Generating', \
1596 self.indextitle[name], 'index'
1614 self.write('<DL COMPACT>\n')
1619 if self.debugging > 1: print '!'*self.debugging, key, ':', node
1620 self.write('<DT>')
1623 self.expand(key)
1624 self.write('\n<DD><A HREF="%s">%s</A>\n' % (makefile(node), node))
1626 self.write('</DL>\n')
1630 def report(self): argument
1631 if self.unknown:
1633 cmds = self.unknown.keys()
1636 print cmd.ljust(20), self.unknown[cmd]
1653 def bgn_quotation(self, args): self.write('<BQ>') argument
1654 def end_quotation(self): self.write('</BQ>\n') argument
1656 def bgn_example(self, args): argument
1659 self.nofill = self.nofill + 1
1660 self.write('<PRE CLASS=example><CODE>')
1661 def end_example(self): argument
1662 self.write("</CODE></PRE>\n")
1663 self.nofill = self.nofill - 1
1665 def bgn_flushleft(self, args): argument
1666 self.nofill = self.nofill + 1
1667 self.write('<PRE CLASS=flushleft>\n')
1669 def bgn_flushright(self, args): argument
1670 self.nofill = self.nofill + 1
1671 self.write('<DIV ALIGN=right CLASS=flushright><ADDRESS COMPACT>\n')
1672 def end_flushright(self): argument
1673 self.write('</ADDRESS></DIV>\n')
1674 self.nofill = self.nofill - 1
1676 def bgn_menu(self, args): argument
1677 self.write('<UL PLAIN CLASS=menu>\n')
1678 self.write(' <LH>Menu</LH>\n')
1679 def end_menu(self): argument
1680 self.write('</UL>\n')
1711 def __init__(self,helpbase,dirname): argument
1712 self.helpbase = helpbase
1713 self.dirname = dirname
1714 self.projectfile = None
1715 self.contentfile = None
1716 self.indexfile = None
1717 self.nodelist = []
1718 self.nodenames = {} # nodename : index
1719 self.nodeindex = {}
1720 self.filenames = {} # filename : filename
1721 self.indexlist = [] # (args,nodename) == (key,location)
1722 self.current = ''
1723 self.menudict = {}
1724 self.dumped = {}
1727 def addnode(self,name,next,prev,up,filename): argument
1731 self.filenames[filename] = filename
1733 self.nodeindex[name] = len(self.nodelist)
1734 self.nodelist.append(node)
1736 self.current = name
1737 self.menudict[self.current] = []
1739 def menuitem(self,nodename): argument
1740 menu = self.menudict[self.current]
1744 def addimage(self,imagename): argument
1745 self.filenames[imagename] = imagename
1747 def index(self, args, nodename): argument
1748 self.indexlist.append((args,nodename))
1750 def beginmenu(self): argument
1753 def endmenu(self): argument
1756 def finalize(self): argument
1757 if not self.helpbase:
1761 resultfile = self.helpbase + '.chm'
1762 projectfile = self.helpbase + '.hhp'
1763 contentfile = self.helpbase + '.hhc'
1764 indexfile = self.helpbase + '.hhk'
1767 title = self.helpbase
1770 (topname,topnext,topprev,topup,topfile) = self.nodelist[0]
1798 self.dumpfiles(fp)
1821 self.dumpnodes(fp)
1843 self.dumpindex(fp)
1851 def dumpfiles(self, outfile=sys.stdout): argument
1852 filelist = self.filenames.values()
1857 def dumpnodes(self, outfile=sys.stdout): argument
1858 self.dumped = {}
1859 if self.nodelist:
1860 nodename, dummy, dummy, dummy, dummy = self.nodelist[0]
1861 self.topnode = nodename
1864 for node in self.nodelist:
1865 self.dumpnode(node,0,outfile)
1868 def dumpnode(self, node, indent=0, outfile=sys.stdout): argument
1872 self.current = nodename
1875 if self.dumped.has_key(nodename):
1877 self.dumped[nodename] = 1
1888 menu = self.menudict[nodename]
1889 self.dumpmenu(menu,indent+2,outfile)
1893 def dumpmenu(self, menu, indent=0, outfile=sys.stdout): argument
1895 currentnode = self.current
1896 if currentnode != self.topnode: # XXX this is a hack
1900 menunode = self.getnode(item)
1901 self.dumpnode(menunode,indent,outfile)
1902 if currentnode != self.topnode: # XXX this is a hack
1906 def getnode(self, nodename): argument
1908 index = self.nodeindex[nodename]
1909 return self.nodelist[index]
1916 def dumpindex(self, outfile=sys.stdout): argument
1918 for (key,location) in self.indexlist:
1919 key = self.codeexpand(key)
1921 location = self.dirname + '/' + location
1928 def codeexpand(self, line): argument
1929 co = self.codeprog.match(line)