Lines Matching refs:self
103 def __init__(self, dir, name, topname, title, next, prev, up):
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):
118 self.lines.append(line)
120 def flush(self):
121 with open(self.dirname + '/' + makefile(self.name), 'w') as fp:
122 fp.write(self.prologue)
123 fp.write(self.text)
124 fp.write(self.epilogue)
126 def link(self, label, nodename, rel=None, rev=None):
134 self.write(label, ': <A HREF="', addr, '"', \
139 def finalize(self):
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):
165 self.write('<HR>\n')
167 def close_links(self):
168 self.write('<HR>\n')
170 def output_links(self):
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):
185 self.write('<DIV CLASS=Navigation>\n <HR>\n')
187 def close_links(self):
188 self.write(' <HR>\n</DIV>\n')
208 def __init__(self):
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):
242 self.htmlhelp = htmlhelp
245 def setdirname(self, dirname):
246 self.dirname = dirname
249 def setincludedir(self, includedir):
250 self.includedir = includedir
253 def parse(self, fp):
261 self.parserest(fp, lineno)
264 def parserest(self, fp, initial_lineno):
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):
321 if self.savetext is not None:
322 self.savestack.append(self.savetext)
324 self.savetext = ''
327 def collectsavings(self):
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):
343 if self.savetext is not 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):
352 if self.savetext is not 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):
384 if self.debugging > 1:
385 print('!'*self.debugging, 'process:', self.skip, self.stack, end=' ')
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):
419 #if 'menu' in self.stack:
420 # print 'inmenu :', self.skip, self.stack, self.stackinfo
421 stack = self.stack
424 if self.stackinfo[len(stack)]:
432 def expand(self, text):
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):
519 self.write('@', cmd)
520 if cmd not in self.unknown:
521 self.unknown[cmd] = 1
523 self.unknown[cmd] = self.unknown[cmd] + 1
525 def unknown_close(self, cmd):
528 self.write('}')
529 if cmd not in self.unknown:
530 self.unknown[cmd] = 1
532 self.unknown[cmd] = self.unknown[cmd] + 1
534 def unknown_handle(self, cmd):
536 self.write('@', cmd)
537 if cmd not in self.unknown:
538 self.unknown[cmd] = 1
540 self.unknown[cmd] = self.unknown[cmd] + 1
546 def handle_noindent(self): pass
548 def handle_refill(self): pass
552 def do_include(self, args):
554 file = os.path.join(self.includedir, file)
561 print('!'*self.debugging, '--> file', repr(file))
562 save_done = self.done
563 save_skip = self.skip
564 save_stack = self.stack
565 self.includedepth = self.includedepth + 1
566 self.parserest(fp, 0)
567 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
576 def close_dmn(self): pass
578 def open_dots(self): self.write('...')
579 def close_dots(self): pass
581 def open_bullet(self): pass
582 def close_bullet(self): pass
584 def open_TeX(self): self.write('TeX')
585 def close_TeX(self): pass
587 def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL)
588 def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL)
589 def close_copyright(self): pass
591 def open_minus(self): self.write('-')
592 def close_minus(self): pass
630 def open_exclamdown(self): self.write('¡') # upside-down !
631 def close_exclamdown(self): pass
632 def open_questiondown(self): self.write('¿') # upside-down ?
633 def close_questiondown(self): pass
634 def open_aa(self): self.write('å') # a with circle
635 def close_aa(self): pass
636 def open_AA(self): self.write('Å') # A with circle
637 def close_AA(self): pass
638 def open_ae(self): self.write('æ') # ae ligatures
639 def close_ae(self): pass
640 def open_AE(self): self.write('Æ') # AE ligatures
641 def close_AE(self): pass
642 def open_o(self): self.write('ø') # o with slash
643 def close_o(self): pass
644 def open_O(self): self.write('Ø') # O with slash
645 def close_O(self): pass
646 def open_ss(self): self.write('ß') # es-zet or sharp S
647 def close_ss(self): pass
648 def open_oe(self): self.write('oe') # oe ligatures
649 def close_oe(self): pass
650 def open_OE(self): self.write('OE') # OE ligatures
651 def close_OE(self): pass
652 def open_l(self): self.write('l/') # suppressed-l
653 def close_l(self): pass
654 def open_L(self): self.write('L/') # suppressed-L
655 def close_L(self): pass
659 def open_result(self): self.write('=>')
660 def close_result(self): pass
662 def open_expansion(self): self.write('==>')
663 def close_expansion(self): pass
665 def open_print(self): self.write('-|')
666 def close_print(self): pass
668 def open_error(self): self.write('error-->')
669 def close_error(self): pass
671 def open_equiv(self): self.write('==')
672 def close_equiv(self): pass
674 def open_point(self): self.write('-!-')
675 def close_point(self): pass
679 def open_pxref(self):
680 self.write('see ')
681 self.startsaving()
682 def close_pxref(self):
683 self.makeref()
685 def open_xref(self):
686 self.write('See ')
687 self.startsaving()
688 def close_xref(self):
689 self.makeref()
691 def open_ref(self):
692 self.startsaving()
693 def close_ref(self):
694 self.makeref()
696 def open_inforef(self):
697 self.write('See info file ')
698 self.startsaving()
699 def close_inforef(self):
700 text = self.collectsavings()
705 self.write('`', file, '\', node `', node, '\'')
707 def makeref(self):
708 text = self.collectsavings()
718 self.write('<A HREF="', href, '">', label, '</A>')
721 def open_uref(self):
722 self.startsaving()
723 def close_uref(self):
724 text = self.collectsavings()
730 self.write('<A HREF="', href, '">', label, '</A>')
739 def open_image(self):
740 self.startsaving()
741 def close_image(self):
742 self.makeimage()
743 def makeimage(self):
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}
782 def close_(self): pass
787 def open_cite(self): self.write('<CITE>')
788 def close_cite(self): self.write('</CITE>')
790 def open_code(self): self.write('<CODE>')
791 def close_code(self): self.write('</CODE>')
793 def open_t(self): self.write('<TT>')
794 def close_t(self): self.write('</TT>')
796 def open_dfn(self): self.write('<DFN>')
797 def close_dfn(self): self.write('</DFN>')
799 def open_emph(self): self.write('<EM>')
800 def close_emph(self): self.write('</EM>')
802 def open_i(self): self.write('<I>')
803 def close_i(self): self.write('</I>')
805 def open_footnote(self):
806 # if self.savetext is not None:
808 id = len(self.footnotes) + 1
809 self.write(self.FN_SOURCE_PATTERN % {'id': repr(id)})
810 self.startsaving()
812 def close_footnote(self):
813 id = len(self.footnotes) + 1
814 self.footnotes.append((id, self.collectsavings()))
816 def writefootnotes(self):
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>')
824 def close_file(self): self.write('</CODE>')
826 def open_kbd(self): self.write('<KBD>')
827 def close_kbd(self): self.write('</KBD>')
829 def open_key(self): self.write('<KEY>')
830 def close_key(self): self.write('</KEY>')
832 def open_r(self): self.write('<R>')
833 def close_r(self): self.write('</R>')
835 def open_samp(self): self.write('`<SAMP>')
836 def close_samp(self): self.write('</SAMP>\'')
838 def open_sc(self): self.write('<SMALLCAPS>')
839 def close_sc(self): self.write('</SMALLCAPS>')
841 def open_strong(self): self.write('<STRONG>')
842 def close_strong(self): self.write('</STRONG>')
844 def open_b(self): self.write('<B>')
845 def close_b(self): self.write('</B>')
847 def open_var(self): self.write('<VAR>')
848 def close_var(self): self.write('</VAR>')
850 def open_w(self): self.write('<NOBREAK>')
851 def close_w(self): self.write('</NOBREAK>')
853 def open_url(self): self.startsaving()
854 def close_url(self):
855 text = self.collectsavings()
856 self.write('<A HREF="', text, '">', text, '</A>')
858 def open_email(self): self.startsaving()
859 def close_email(self):
860 text = self.collectsavings()
861 self.write('<A HREF="mailto:', text, '">', text, '</A>')
866 def open_small(self): pass
867 def close_small(self): pass
869 def command(self, line, mo):
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):
894 if cmd not in self.unknown:
895 self.unknown[cmd] = 1
897 self.unknown[cmd] = self.unknown[cmd] + 1
899 def do_end(self, args):
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):
919 if cmd not in self.unknown:
920 self.unknown[cmd] = 1
922 self.unknown[cmd] = self.unknown[cmd] + 1
926 def do_comment(self, args): pass
931 def bgn_ifinfo(self, args): pass
932 def end_ifinfo(self): pass
934 def bgn_iftex(self, args): self.skip = self.skip + 1
935 def end_iftex(self): self.skip = self.skip - 1
937 def bgn_ignore(self, args): self.skip = self.skip + 1
938 def end_ignore(self): self.skip = self.skip - 1
940 def bgn_tex(self, args): self.skip = self.skip + 1
941 def end_tex(self): self.skip = self.skip - 1
943 def do_set(self, args):
950 self.values[key] = value
952 def do_clear(self, args):
953 self.values[args] = None
955 def bgn_ifset(self, args):
956 if args not in self.values or self.values[args] is None:
957 self.skip = self.skip + 1
958 self.stackinfo[len(self.stack)] = 1
960 self.stackinfo[len(self.stack)] = 0
961 def end_ifset(self):
963 if self.stackinfo[len(self.stack) + 1]:
964 self.skip = self.skip - 1
965 del self.stackinfo[len(self.stack) + 1]
967 print('*** end_ifset: KeyError :', len(self.stack) + 1)
969 def bgn_ifclear(self, args):
970 if args in self.values and self.values[args] is not None:
971 self.skip = self.skip + 1
972 self.stackinfo[len(self.stack)] = 1
974 self.stackinfo[len(self.stack)] = 0
975 def end_ifclear(self):
977 if self.stackinfo[len(self.stack) + 1]:
978 self.skip = self.skip - 1
979 del self.stackinfo[len(self.stack) + 1]
981 print('*** end_ifclear: KeyError :', len(self.stack) + 1)
983 def open_value(self):
984 self.startsaving()
986 def close_value(self):
987 key = self.collectsavings()
988 if key in self.values:
989 self.write(self.values[key])
999 def do_settitle(self, args):
1000 self.startsaving()
1001 self.expand(args)
1002 self.title = self.collectsavings()
1003 def do_parskip(self, args): pass
1007 def do_bye(self, args):
1008 self.endnode()
1009 self.done = 1
1013 def bgn_titlepage(self, args): self.skip = self.skip + 1
1014 def end_titlepage(self): self.skip = self.skip - 1
1015 def do_shorttitlepage(self, args): pass
1017 def do_center(self, args):
1019 self.write('<H1>')
1020 self.expand(args)
1021 self.write('</H1>\n')
1044 def do_node(self, args):
1045 self.endnode()
1046 self.nodelineno = 0
1049 self.nodelinks = parts
1051 file = self.dirname + '/' + makefile(name)
1052 if file in self.filenames:
1055 if self.debugging: print('!'*self.debugging, '--- writing', file)
1056 self.filenames[file] = 1
1057 # self.nodefp = open(file, 'w')
1058 self.nodename = name
1059 if self.cont and self.nodestack:
1060 self.nodestack[-1].cont = self.nodename
1061 if not self.topname: self.topname = name
1063 if self.title: title = title + ' -- ' + self.title
1064 self.node = self.Node(self.dirname, self.nodename, self.topname,
1066 self.htmlhelp.addnode(self.nodename,next,prev,up,file)
1068 def link(self, label, nodename):
1074 self.write(label, ': <A HREF="', addr, '" TYPE="',
1079 def popstack(self, type):
1080 if (self.node):
1081 self.node.type = type
1082 while self.nodestack:
1083 if self.nodestack[-1].type > type:
1084 self.nodestack[-1].finalize()
1085 self.nodestack[-1].flush()
1086 del self.nodestack[-1]
1087 elif self.nodestack[-1].type == type:
1088 if not self.nodestack[-1].next:
1089 self.nodestack[-1].next = self.node.name
1090 if not self.node.prev:
1091 self.node.prev = self.nodestack[-1].name
1092 self.nodestack[-1].finalize()
1093 self.nodestack[-1].flush()
1094 del self.nodestack[-1]
1096 if type > 1 and not self.node.up:
1097 self.node.up = self.nodestack[-1].name
1100 def do_chapter(self, args):
1101 self.heading('H1', args, 0)
1102 self.popstack(1)
1104 def do_unnumbered(self, args):
1105 self.heading('H1', args, -1)
1106 self.popstack(1)
1107 def do_appendix(self, args):
1108 self.heading('H1', args, -1)
1109 self.popstack(1)
1110 def do_top(self, args):
1111 self.heading('H1', args, -1)
1112 def do_chapheading(self, args):
1113 self.heading('H1', args, -1)
1114 def do_majorheading(self, args):
1115 self.heading('H1', args, -1)
1117 def do_section(self, args):
1118 self.heading('H1', args, 1)
1119 self.popstack(2)
1121 def do_unnumberedsec(self, args):
1122 self.heading('H1', args, -1)
1123 self.popstack(2)
1124 def do_appendixsec(self, args):
1125 self.heading('H1', args, -1)
1126 self.popstack(2)
1128 def do_heading(self, args):
1129 self.heading('H1', args, -1)
1131 def do_subsection(self, args):
1132 self.heading('H2', args, 2)
1133 self.popstack(3)
1134 def do_unnumberedsubsec(self, args):
1135 self.heading('H2', args, -1)
1136 self.popstack(3)
1137 def do_appendixsubsec(self, args):
1138 self.heading('H2', args, -1)
1139 self.popstack(3)
1140 def do_subheading(self, args):
1141 self.heading('H2', args, -1)
1143 def do_subsubsection(self, args):
1144 self.heading('H3', args, 3)
1145 self.popstack(4)
1146 def do_unnumberedsubsubsec(self, args):
1147 self.heading('H3', args, -1)
1148 self.popstack(4)
1149 def do_appendixsubsubsec(self, args):
1150 self.heading('H3', args, -1)
1151 self.popstack(4)
1152 def do_subsubheading(self, args):
1153 self.heading('H3', args, -1)
1155 def heading(self, type, args, level):
1157 while len(self.numbering) <= level:
1158 self.numbering.append(0)
1159 del self.numbering[level+1:]
1160 self.numbering[level] = self.numbering[level] + 1
1162 for i in self.numbering:
1165 self.contents.append((level, args, self.nodename))
1166 self.write('<', type, '>')
1167 self.expand(args)
1168 self.write('</', type, '>\n')
1169 if self.debugging or self.print_headers:
1172 def do_contents(self, args):
1174 self.listcontents('Table of Contents', 999)
1176 def do_shortcontents(self, args):
1178 # self.listcontents('Short Contents', 0)
1181 def listcontents(self, title, maxlevel):
1182 self.write('<H1>', title, '</H1>\n<UL COMPACT PLAIN>\n')
1184 for level, title, node in self.contents:
1189 self.write(' '*prevlevels[-1], '<UL PLAIN>\n')
1195 self.write(' '*prevlevels[-1],
1197 self.write(' '*level, '<LI> <A HREF="',
1199 self.expand(title)
1200 self.write('</A>\n')
1201 self.write('</UL>\n' * len(prevlevels))
1207 def do_page(self, args): pass
1209 def do_need(self, args): pass
1211 def bgn_group(self, args): pass
1212 def end_group(self): pass
1216 def do_sp(self, args):
1217 if self.nofill:
1218 self.write('\n')
1220 self.write('<P>\n')
1222 def do_hline(self, args):
1223 self.write('<HR>')
1227 def bgn_deffn(self, args):
1228 self.write('<DL>')
1229 self.do_deffnx(args)
1231 def end_deffn(self):
1232 self.write('</DL>\n')
1234 def do_deffnx(self, args):
1235 self.write('<DT>')
1238 self.expand('@b{%s}' % name)
1239 for word in rest: self.expand(' ' + makevar(word))
1240 #self.expand(' -- ' + category)
1241 self.write('\n<DD>')
1242 self.index('fn', name)
1244 def bgn_defun(self, args): self.bgn_deffn('Function ' + args)
1246 def do_defunx(self, args): self.do_deffnx('Function ' + args)
1248 def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args)
1250 def do_defmacx(self, args): self.do_deffnx('Macro ' + args)
1252 def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args)
1254 def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args)
1256 def bgn_defvr(self, args):
1257 self.write('<DL>')
1258 self.do_defvrx(args)
1262 def do_defvrx(self, args):
1263 self.write('<DT>')
1266 self.expand('@code{%s}' % name)
1268 for word in rest: self.expand(' ' + word)
1269 #self.expand(' -- ' + category)
1270 self.write('\n<DD>')
1271 self.index('vr', name)
1273 def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args)
1275 def do_defvarx(self, args): self.do_defvrx('Variable ' + args)
1277 def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args)
1279 def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args)
1283 def bgn_deftypefn(self, args):
1284 self.write('<DL>')
1285 self.do_deftypefnx(args)
1289 def do_deftypefnx(self, args):
1290 self.write('<DT>')
1293 self.expand('@code{%s} @b{%s}' % (datatype, name))
1294 for word in rest: self.expand(' ' + makevar(word))
1295 #self.expand(' -- ' + category)
1296 self.write('\n<DD>')
1297 self.index('fn', name)
1300 def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args)
1302 def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args)
1304 def bgn_deftypevr(self, args):
1305 self.write('<DL>')
1306 self.do_deftypevrx(args)
1310 def do_deftypevrx(self, args):
1311 self.write('<DT>')
1314 self.expand('@code{%s} @b{%s}' % (datatype, name))
1316 for word in rest: self.expand(' ' + word)
1317 #self.expand(' -- ' + category)
1318 self.write('\n<DD>')
1319 self.index('fn', name)
1321 def bgn_deftypevar(self, args):
1322 self.bgn_deftypevr('Variable ' + args)
1324 def do_deftypevarx(self, args):
1325 self.do_deftypevrx('Variable ' + args)
1329 def bgn_defcv(self, args):
1330 self.write('<DL>')
1331 self.do_defcvx(args)
1335 def do_defcvx(self, args):
1336 self.write('<DT>')
1339 self.expand('@b{%s}' % name)
1341 for word in rest: self.expand(' ' + word)
1342 #self.expand(' -- %s of @code{%s}' % (category, classname))
1343 self.write('\n<DD>')
1344 self.index('vr', '%s @r{on %s}' % (name, classname))
1346 def bgn_defivar(self, args):
1347 self.bgn_defcv('{Instance Variable} ' + args)
1349 def do_defivarx(self, args):
1350 self.do_defcvx('{Instance Variable} ' + args)
1352 def bgn_defop(self, args):
1353 self.write('<DL>')
1354 self.do_defopx(args)
1358 def do_defopx(self, args):
1359 self.write('<DT>')
1362 self.expand('@b{%s}' % name)
1363 for word in rest: self.expand(' ' + makevar(word))
1364 #self.expand(' -- %s of @code{%s}' % (category, classname))
1365 self.write('\n<DD>')
1366 self.index('fn', '%s @r{on %s}' % (name, classname))
1368 def bgn_defmethod(self, args):
1369 self.bgn_defop('Method ' + args)
1371 def do_defmethodx(self, args):
1372 self.do_defopx('Method ' + args)
1376 def bgn_deftp(self, args):
1377 self.write('<DL>')
1378 self.do_deftpx(args)
1382 def do_deftpx(self, args):
1383 self.write('<DT>')
1386 self.expand('@b{%s}' % name)
1387 for word in rest: self.expand(' ' + word)
1388 #self.expand(' -- ' + category)
1389 self.write('\n<DD>')
1390 self.index('tp', name)
1394 def bgn_enumerate(self, args):
1396 self.write('<OL>\n')
1397 self.stackinfo[len(self.stack)] = '</OL>\n'
1399 self.itemnumber = args
1400 self.write('<UL>\n')
1401 self.stackinfo[len(self.stack)] = '</UL>\n'
1402 def end_enumerate(self):
1403 self.itemnumber = None
1404 self.write(self.stackinfo[len(self.stack) + 1])
1405 del self.stackinfo[len(self.stack) + 1]
1407 def bgn_itemize(self, args):
1408 self.itemarg = args
1409 self.write('<UL>\n')
1410 def end_itemize(self):
1411 self.itemarg = None
1412 self.write('</UL>\n')
1414 def bgn_table(self, args):
1415 self.itemarg = args
1416 self.write('<DL>\n')
1417 def end_table(self):
1418 self.itemarg = None
1419 self.write('</DL>\n')
1421 def bgn_ftable(self, args):
1422 self.itemindex = 'fn'
1423 self.bgn_table(args)
1424 def end_ftable(self):
1425 self.itemindex = None
1426 self.end_table()
1428 def bgn_vtable(self, args):
1429 self.itemindex = 'vr'
1430 self.bgn_table(args)
1431 def end_vtable(self):
1432 self.itemindex = None
1433 self.end_table()
1435 def do_item(self, args):
1436 if self.itemindex: self.index(self.itemindex, args)
1437 if self.itemarg:
1438 if self.itemarg[0] == '@' and self.itemarg[1] and \
1439 self.itemarg[1] in string.ascii_letters:
1440 args = self.itemarg + '{' + args + '}'
1443 args = self.itemarg + ' ' + args
1444 if self.itemnumber is not None:
1445 args = self.itemnumber + '. ' + args
1446 self.itemnumber = increment(self.itemnumber)
1447 if self.stack and self.stack[-1] == 'table':
1448 self.write('<DT>')
1449 self.expand(args)
1450 self.write('\n<DD>')
1451 elif self.stack and self.stack[-1] == 'multitable':
1452 self.write('<TR><TD>')
1453 self.expand(args)
1454 self.write('</TD>\n</TR>\n')
1456 self.write('<LI>')
1457 self.expand(args)
1458 self.write(' ')
1462 def bgn_multitable(self, args):
1463 self.itemarg = None # should be handled by columnfractions
1464 self.write('<TABLE BORDER="">\n')
1465 def end_multitable(self):
1466 self.itemarg = None
1467 self.write('</TABLE>\n<BR>\n')
1468 def handle_columnfractions(self):
1470 self.itemarg = None
1471 def handle_tab(self):
1472 self.write('</TD>\n <TD>')
1477 def bgn_quotation(self, args): self.write('<BLOCKQUOTE>')
1478 def end_quotation(self): self.write('</BLOCKQUOTE>\n')
1480 def bgn_example(self, args):
1481 self.nofill = self.nofill + 1
1482 self.write('<PRE>')
1483 def end_example(self):
1484 self.write('</PRE>\n')
1485 self.nofill = self.nofill - 1
1502 def do_exdent(self, args): self.expand(args + '\n')
1505 def bgn_flushleft(self, args):
1506 self.nofill = self.nofill + 1
1507 self.write('<PRE>\n')
1508 def end_flushleft(self):
1509 self.write('</PRE>\n')
1510 self.nofill = self.nofill - 1
1512 def bgn_flushright(self, args):
1513 self.nofill = self.nofill + 1
1514 self.write('<ADDRESS COMPACT>\n')
1515 def end_flushright(self):
1516 self.write('</ADDRESS>\n')
1517 self.nofill = self.nofill - 1
1519 def bgn_menu(self, args):
1520 self.write('<DIR>\n')
1521 self.write(' <STRONG><EM>Menu</EM></STRONG><P>\n')
1522 self.htmlhelp.beginmenu()
1523 def end_menu(self):
1524 self.write('</DIR>\n')
1525 self.htmlhelp.endmenu()
1527 def bgn_cartouche(self, args): pass
1528 def end_cartouche(self): pass
1532 def resetindex(self):
1533 self.noncodeindices = ['cp']
1534 self.indextitle = {}
1535 self.indextitle['cp'] = 'Concept'
1536 self.indextitle['fn'] = 'Function'
1537 self.indextitle['ky'] = 'Keyword'
1538 self.indextitle['pg'] = 'Program'
1539 self.indextitle['tp'] = 'Type'
1540 self.indextitle['vr'] = 'Variable'
1542 self.whichindex = {}
1543 for name in self.indextitle:
1544 self.whichindex[name] = []
1546 def user_index(self, name, args):
1547 if name in self.whichindex:
1548 self.index(name, args)
1552 def do_cindex(self, args): self.index('cp', args)
1553 def do_findex(self, args): self.index('fn', args)
1554 def do_kindex(self, args): self.index('ky', args)
1555 def do_pindex(self, args): self.index('pg', args)
1556 def do_tindex(self, args): self.index('tp', args)
1557 def do_vindex(self, args): self.index('vr', args)
1559 def index(self, name, args):
1560 self.whichindex[name].append((args, self.nodename))
1561 self.htmlhelp.index(args, self.nodename)
1563 def do_synindex(self, args):
1569 if old not in self.whichindex or \
1570 new not in self.whichindex:
1574 self.whichindex[old] is not self.whichindex[new]:
1575 inew = self.whichindex[new]
1576 inew[len(inew):] = self.whichindex[old]
1577 self.whichindex[old] = inew
1580 def do_printindex(self, args):
1583 if name in self.whichindex:
1584 self.prindex(name)
1588 def prindex(self, name):
1589 iscodeindex = (name not in self.noncodeindices)
1590 index = self.whichindex[name]
1592 if self.debugging:
1593 print('!'*self.debugging, '--- Generating', \
1594 self.indextitle[name], 'index')
1612 self.write('<DL COMPACT>\n')
1617 if self.debugging > 1: print('!'*self.debugging, key, ':', node)
1618 self.write('<DT>')
1621 self.expand(key)
1622 self.write('\n<DD><A HREF="%s">%s</A>\n' % (makefile(node), node))
1624 self.write('</DL>\n')
1628 def report(self):
1629 if self.unknown:
1631 cmds = sorted(self.unknown.keys())
1633 print(cmd.ljust(20), self.unknown[cmd])
1650 def bgn_quotation(self, args): self.write('<BQ>')
1651 def end_quotation(self): self.write('</BQ>\n')
1653 def bgn_example(self, args):
1656 self.nofill = self.nofill + 1
1657 self.write('<PRE CLASS=example><CODE>')
1658 def end_example(self):
1659 self.write("</CODE></PRE>\n")
1660 self.nofill = self.nofill - 1
1662 def bgn_flushleft(self, args):
1663 self.nofill = self.nofill + 1
1664 self.write('<PRE CLASS=flushleft>\n')
1666 def bgn_flushright(self, args):
1667 self.nofill = self.nofill + 1
1668 self.write('<DIV ALIGN=right CLASS=flushright><ADDRESS COMPACT>\n')
1669 def end_flushright(self):
1670 self.write('</ADDRESS></DIV>\n')
1671 self.nofill = self.nofill - 1
1673 def bgn_menu(self, args):
1674 self.write('<UL PLAIN CLASS=menu>\n')
1675 self.write(' <LH>Menu</LH>\n')
1676 def end_menu(self):
1677 self.write('</UL>\n')
1708 def __init__(self,helpbase,dirname):
1709 self.helpbase = helpbase
1710 self.dirname = dirname
1711 self.projectfile = None
1712 self.contentfile = None
1713 self.indexfile = None
1714 self.nodelist = []
1715 self.nodenames = {} # nodename : index
1716 self.nodeindex = {}
1717 self.filenames = {} # filename : filename
1718 self.indexlist = [] # (args,nodename) == (key,location)
1719 self.current = ''
1720 self.menudict = {}
1721 self.dumped = {}
1724 def addnode(self,name,next,prev,up,filename):
1727 # retrieve list with self.filenames.values()
1728 self.filenames[filename] = filename
1730 self.nodeindex[name] = len(self.nodelist)
1731 self.nodelist.append(node)
1733 self.current = name
1734 self.menudict[self.current] = []
1736 def menuitem(self,nodename):
1737 menu = self.menudict[self.current]
1741 def addimage(self,imagename):
1742 self.filenames[imagename] = imagename
1744 def index(self, args, nodename):
1745 self.indexlist.append((args,nodename))
1747 def beginmenu(self):
1750 def endmenu(self):
1753 def finalize(self):
1754 if not self.helpbase:
1758 resultfile = self.helpbase + '.chm'
1759 projectfile = self.helpbase + '.hhp'
1760 contentfile = self.helpbase + '.hhc'
1761 indexfile = self.helpbase + '.hhk'
1764 title = self.helpbase
1767 (topname,topnext,topprev,topup,topfile) = self.nodelist[0]
1795 self.dumpfiles(fp)
1817 self.dumpnodes(fp)
1838 self.dumpindex(fp)
1845 def dumpfiles(self, outfile=sys.stdout):
1846 filelist = sorted(self.filenames.values())
1850 def dumpnodes(self, outfile=sys.stdout):
1851 self.dumped = {}
1852 if self.nodelist:
1853 nodename, dummy, dummy, dummy, dummy = self.nodelist[0]
1854 self.topnode = nodename
1857 for node in self.nodelist:
1858 self.dumpnode(node,0,outfile)
1861 def dumpnode(self, node, indent=0, outfile=sys.stdout):
1865 self.current = nodename
1868 if nodename in self.dumped:
1870 self.dumped[nodename] = 1
1881 menu = self.menudict[nodename]
1882 self.dumpmenu(menu,indent+2,outfile)
1886 def dumpmenu(self, menu, indent=0, outfile=sys.stdout):
1888 currentnode = self.current
1889 if currentnode != self.topnode: # XXX this is a hack
1893 menunode = self.getnode(item)
1894 self.dumpnode(menunode,indent,outfile)
1895 if currentnode != self.topnode: # XXX this is a hack
1899 def getnode(self, nodename):
1901 index = self.nodeindex[nodename]
1902 return self.nodelist[index]
1909 def dumpindex(self, outfile=sys.stdout):
1911 for (key,location) in self.indexlist:
1912 key = self.codeexpand(key)
1914 location = self.dirname + '/' + location
1921 def codeexpand(self, line):
1922 co = self.codeprog.match(line)