granicus.if.org Git - zziplib/blob - docs/makedocs.py

   1 import sys
   2 from zzipdoc.match import *
   3 from zzipdoc.options import *
   4 from zzipdoc.textfile import *
   5 from zzipdoc.textfileheader import *
   6 from zzipdoc.functionheader import *
   7 from zzipdoc.functionprototype import *
   8 from zzipdoc.commentmarkup import *
   9 from zzipdoc.functionlisthtmlpage import *
  10 from zzipdoc.functionlistreference import *
  11 from zzipdoc.dbk2htm import *
  12
  13 def _src_to_xml(text):
  14     return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
  15
  16 class PerFileEntry:
  17     def __init__(self, header, comment):
  18         self.textfileheader = header
  19         self.filecomment = comment
  20 class PerFile:
  21     def __init__(self):
  22         self.textfileheaders = []
  23         self.filecomments = []
  24         self.entries = []
  25     def add(self, textfileheader, filecomment):
  26         self.textfileheaders += [ textfileheader ]
  27         self.filecomments += [ filecomment ]
  28         self.entries += [ PerFileEntry(textfileheader, filecomment) ]
  29     def where_filename(self, filename):
  30         for entry in self.entries:
  31             if entry.textfileheader.get_filename() == filename:
  32                 return entry
  33         return None
  34     def print_list_mainheader(self):
  35         for t_fileheader in self.headers:
  36             print t_fileheader.get_filename(), t_fileheader.src_mainheader()
  37
  38 class PerFunctionEntry:
  39     def __init__(self, header, comment, prototype):
  40         self.header = header
  41         self.comment = comment
  42         self.prototype = prototype
  43     def get_name(self):
  44         return self.prototype.get_name()
  45     def get_titleline(self):
  46         return self.header.get_titleline()
  47     def get_head(self):
  48         return self.prototype
  49     def get_body(self):
  50         return self.comment
  51 class PerFunction:
  52     def __init__(self):
  53         self.headers = []
  54         self.comments = []
  55         self.prototypes = []
  56         self.entries = []
  57     def add(self, functionheader, functioncomment, functionprototype):
  58         self.headers += [ functionheader ]
  59         self.comments += [ functionprototype ]
  60         self.prototypes += [ functionprototype ]
  61         self.entries += [ PerFunctionEntry(functionheader, functioncomment,
  62                                            functionprototype) ]
  63     def print_list_titleline(self):
  64         for funcheader in self.headers:
  65             print funcheader.get_filename(), "[=>]", funcheader.get_titleline()
  66     def print_list_name(self):
  67         for funcheader in self.prototypes:
  68             print funcheader.get_filename(), "[>>]", funcheader.get_name()
  69
  70 class PerFunctionFamilyEntry:
  71     def __init__(self, leader):
  72         self.leader = leader
  73         self.functions = []
  74     def contains(self, func):
  75         for item in self.functions:
  76             if item == func: return True
  77         return False
  78     def add(self, func):
  79         if not self.contains(func):
  80             self.functions += [ func ]
  81     def get_name(self):
  82         if self.leader is None: return None
  83         return self.leader.get_name()
  84 class PerFunctionFamily:
  85     def __init__(self):
  86         self.functions = []
  87         self.families = []
  88         self.retarget = {}
  89         self.entries = []
  90     def add_PerFunction(self, per_list):
  91         for item in per_list.entries:
  92             add_PerFunctionEntry(item)
  93     def add_PerFunctionEntry(self, item):
  94         self.functions += [ item ]
  95     def get_function(self, name):
  96         for item in self.functions:
  97             if item.get_name() == name:
  98                 return item
  99         return None
 100     def get_entry(self, name):
 101         for item in self.entries:
 102             if item.get_name() == name:
 103                 return item
 104         return None
 105     def fill_families(self):
 106         name_list = {}
 107         for func in self.functions:
 108             name = func.get_name()
 109             name_list[name] = func
 110         for func in self.functions:
 111             name = func.get_name()
 112             line = func.get_titleline()
 113             is_retarget = Match("=>\s*(\w+)")
 114             if line & is_retarget:
 115                 into = is_retarget[1]
 116                 self.retarget[name] = is_retarget[1]
 117         lead_list = []
 118         for name in self.retarget:
 119             into = self.retarget[name]
 120             if into not in name_list:
 121                 print ("function '"+name+"' retarget into '"+into+
 122                        "' does not exist - keep alone")
 123             if into in self.retarget:
 124                 other = self.retarget[into]
 125                 print ("function '"+name+"' retarget into '"+into+
 126                        "' which is itself a retarget into '"+other+"'")
 127             if into not in lead_list:
 128                 lead_list += [ into ]
 129         for func in self.functions:
 130             name = func.get_name()
 131             if name not in lead_list and name not in self.retarget:
 132                 lead_list += [ name ]
 133         for name in lead_list:
 134             func = self.get_function(name)
 135             if func is not None:
 136                 entry = PerFunctionFamilyEntry(func)
 137                 entry.add(func) # the first
 138                 self.entries += [ entry ]
 139             else:
 140                 print "head function '"+name+" has no entry"
 141         for func in self.functions:
 142             name = func.get_name()
 143             if name in self.retarget:
 144                 into = self.retarget[name]
 145                 entry = self.get_entry(into)
 146                 if entry is not None:
 147                     entry.add(func) # will not add duplicates
 148                 else:
 149                     print "into function '"+name+" has no entry"
 150     def print_list_name(self):
 151         for family in self.entries:
 152             name = family.get_name()
 153             print name, ":",
 154             for item in family.functions:
 155                 print item.get_name(), ",",
 156             print ""
 157 class HtmlManualPageAdapter:
 158     def __init__(self, entry):
 159         """ usually takes a PerFunctionEntry """
 160         self.entry = entry
 161     def get_name(self):
 162         return self.entry.get_name()
 163     def _head(self):
 164         return self.entry.get_head()
 165     def _body(self):
 166         return self.entry.get_body()
 167     def head_xml_text(self):
 168         return self._head().xml_text()
 169     def body_xml_text(self, name):
 170         return self._body().xml_text(name)
 171     def head_get_prespec(self):
 172         return self._head().get_prespec()
 173     def head_get_namespec(self):
 174         return self._head().get_namespec()
 175     def head_get_callspec(self):
 176         return self._head().get_callspec()
 177     def get_title(self):
 178         return self._body().header.get_title()
 179     def get_filename(self):
 180         return self._body().header.get_filename()
 181     def src_mainheader(self):
 182         return self._body().header.parent.textfile.src_mainheader()
 183     def get_mainheader(self):
 184         return _src_to_xml(self.src_mainheader())
 185 class RefEntryManualPageAdapter:
 186     def __init__(self, entry, per_file = None):
 187         """ usually takes a PerFunctionEntry """
 188         self.entry = entry
 189         self.per_file = per_file
 190     def get_name(self):
 191         return self.entry.get_name()
 192     def _head(self):
 193         return self.entry.get_head()
 194     def _body(self):
 195         return self.entry.get_body()
 196     def _textfile(self):
 197         return self._body().header.parent.textfile
 198     def head_xml_text(self):
 199         return self._head().xml_text()
 200     def body_xml_text(self, name):
 201         return self._body().xml_text(name)
 202     def get_title(self):
 203         return self._body().header.get_title()
 204     def get_filename(self):
 205         return self._body().header.get_filename()
 206     def src_mainheader(self):
 207         return self._textfile().src_mainheader()
 208     def get_mainheader(self):
 209         return _src_to_xml(self.src_mainheader())
 210     def get_includes(self):
 211         return ""
 212     def list_seealso(self):
 213         return self._body().header.get_alsolist()
 214     def get_authors(self):
 215         comment = None
 216         if self.per_file:
 217             entry = self.per_file.where_filename(self.get_filename())
 218             if entry:
 219                 comment = entry.filecomment.xml_text()
 220         if comment:
 221             check = Match(r"(?s)<para>\s*[Aa]uthors*\b:*((?:.(?!</para>))*.)</para>")
 222             if comment & check: return _src_to_xml(check[1])
 223         return None
 224     def get_copyright(self):
 225         comment = None
 226         if self.per_file:
 227             entry = self.per_file.where_filename(self.get_filename())
 228             if entry:
 229                 comment = entry.filecomment.xml_text()
 230         if comment:
 231             check = Match(r"(?s)<para>\s*[Cc]opyright\b((?:.(?!</para>))*.)</para>")
 232             if comment & check: return check[0]
 233         return None
 234
 235 def makedocs(filenames, o):
 236     textfiles = []
 237     for filename in filenames:
 238         textfile = TextFile(filename)
 239         textfile.parse()
 240         textfiles += [ textfile ]
 241     per_file = PerFile()
 242     for textfile in textfiles:
 243         textfileheader = TextFileHeader(textfile)
 244         textfileheader.parse()
 245         filecomment = CommentMarkup(textfileheader)
 246         filecomment.parse()
 247         per_file.add(textfileheader, filecomment)
 248     funcheaders = []
 249     for textfile in per_file.textfileheaders:
 250         funcheader = FunctionHeaderList(textfile)
 251         funcheader.parse()
 252         funcheaders += [ funcheader ]
 253     per_function = PerFunction()
 254     for funcheader in funcheaders:
 255         for child in funcheader.get_children():
 256             funcprototype = FunctionPrototype(child)
 257             funcprototype.parse()
 258             funccomment = CommentMarkup(child)
 259             funccomment.parse()
 260             per_function.add(child, funccomment, funcprototype)
 261     per_family = PerFunctionFamily()
 262     for item in per_function.entries:
 263         per_family.add_PerFunctionEntry(item)
 264     per_family.fill_families()
 265     # debug output....
 266     # per_file.print_list_mainheader()
 267     # per_function.print_list_titleline()
 268     # per_function.print_list_name()
 269     per_family.print_list_name()
 270     html = FunctionListHtmlPage(o)
 271     for item in per_family.entries:
 272         for func in item.functions:
 273             func_adapter = HtmlManualPageAdapter(func)
 274             if o.onlymainheader and not (Match("<"+o.onlymainheader+">")
 275                                          & func_adapter.src_mainheader()):
 276                     continue
 277             html.add(func_adapter)
 278         html.cut()
 279     html.cut()
 280     html_filename = "zziplib"+o.suffix+".html"
 281     try:
 282         print "writing "+html_filename
 283         fd = open(html_filename, "w")
 284         print >>fd, section2html(paramdef2html(html.xml_text()))
 285         fd.close()
 286     except IOError, e:
 287         print "could not open '"+html_filename+"'file", e
 288     man3 = FunctionListReference(o)
 289     for item in per_family.entries:
 290         for func in item.functions:
 291             func_adapter = RefEntryManualPageAdapter(func, per_file)
 292             if o.onlymainheader and not (Match("<"+o.onlymainheader+">")
 293                                          & func_adapter.src_mainheader()):
 294                     continue
 295             man3.add(func_adapter)
 296         man3.cut()
 297     man3.cut()
 298     man3_filename = "zziplib"+o.suffix+".docbook"
 299     try:
 300         print "writing "+man3_filename
 301         fd = open(man3_filename, "w")
 302         print >>fd, man3.xml_text()
 303         fd.close()
 304     except IOError, e:
 305         print "could not open '"+man3_filename+"'file", e
 306
 307
 308 if __name__ == "__main__":
 309     filenames = []
 310     o = Options()
 311     o.package = "ZZipLib"
 312     o.program = sys.argv[0]
 313     for item in sys.argv[1:]:
 314         if o.scan(item): continue
 315         filenames += [ item ]
 316     makedocs(filenames, o)
 317
 318