makepanda: Remove old and obsolete gendocs scripts

direct/src/directscripts/gendocs.py

@@ -1,986 +0,0 @@
-########################################################################
-#
-# Documentation generator for panda.
-#
-# How to use this module:
-#
-#   from direct.directscripts import gendocs
-#   gendocs.generate(version, indirlist, directdirlist, docdir, header, footer, urlprefix, urlsuffix)
-#
-#   - version is the panda version number
-#
-#   - indirlist is the name of a directory, or a list of directories,
-#     containing the "xxx.in" files that interrogate generates.  No
-#     slash at end.
-#
-#   - directdirlist is the name of a directory, or a list of
-#     directories, containing the source code for "direct," as well as
-#     for other Python-based trees that should be included in the
-#     documentation pages.  No slash at end.
-#
-#   - docdir is the name of a directory into which HTML files
-#     will be emitted.  No slash at end.
-#
-#   - header is a string that will be placed at the front of
-#     every HTML page.
-#
-#   - footer is a string that will be placed at the end of
-#     every HTML page.
-#
-#   - urlprefix is a string that will be appended to the front of
-#     every URL.
-#
-#   - urlsuffix is a string that will be appended to the end of
-#     every URL.
-#
-########################################################################
-#
-# The major subsystems are:
-#
-# * The module that loads interrogate databases.
-#
-# * The module that loads python parse-trees.
-#
-# * The "code database", which provides a single access point
-#   for both interrogate databases and python parse trees.
-#
-# * The HTML generator.
-#
-########################################################################
-
-import os, sys, parser, symbol, token, re
-
-########################################################################
-#
-# assorted utility functions
-#
-########################################################################
-
-SECHEADER = re.compile("^[A-Z][a-z]+\\s*:")
-JUNKHEADER = re.compile("^((Function)|(Access))\\s*:")
-IMPORTSTAR = re.compile("^from\\s+([a-zA-Z0-9_.]+)\\s+import\\s+[*]\\s*$")
-IDENTIFIER = re.compile("[a-zA-Z0-9_]+")
-FILEHEADER = re.compile(
-r"""^// Filename: [a-zA-Z.]+
-// Created by:  [a-zA-Z. ()0-9]+(
-//)?
-////////////////////////////////////////////////////////////////////
-//
-// PANDA 3D SOFTWARE
-// Copyright \(c\) Carnegie Mellon University.  All rights reserved.
-//
-// All use of this software is subject to the terms of the revised BSD
-// license.  You should have received a copy of this license along
-// with this source code in a file named "LICENSE."
-//
-////////////////////////////////////////////////////////////////////""")
-
-def readFile(fn):
-    try:
-        srchandle = open(fn, "r")
-        data = srchandle.read()
-        srchandle.close()
-        return data
-    except:
-        sys.exit("Cannot read "+fn)
-
-def writeFile(wfile, data):
-    try:
-        dsthandle = open(wfile, "wb")
-        dsthandle.write(data)
-        dsthandle.close()
-    except:
-        sys.exit("Cannot write "+wfile)
-
-def writeFileLines(wfile, lines):
-    try:
-        dsthandle = open(wfile, "wb")
-        for x in lines:
-            dsthandle.write(x)
-            dsthandle.write("\n")
-        dsthandle.close()
-    except:
-        sys.exit("Cannot write "+wfile)
-
-def findFiles(dirlist, ext, ign, list):
-    if isinstance(dirlist, str):
-        dirlist = [dirlist]
-    for dir in dirlist:
-        for file in os.listdir(dir):
-            full = dir + "/" + file
-            if full not in ign and file not in ign:
-                if (os.path.isfile(full)):
-                    if (file.endswith(ext)):
-                        list.append(full)
-                elif (os.path.isdir(full)):
-                    findFiles(full, ext, ign, list)
-
-def pathToModule(result):
-    if (result[-3:]==".py"): result=result[:-3]
-    result = result.replace("/src/","/")
-    result = result.replace("/",".")
-    return result
-
-def textToHTML(comment, sep, delsection=None):
-    sections = [""]
-    included = {}
-    for line in comment.split("\n"):
-        line = line.lstrip(" ").lstrip(sep).lstrip(" ").rstrip("\r").rstrip(" ")
-        if (line == ""):
-            sections.append("")
-        elif (line[0]=="*") or (line[0]=="-"):
-            sections.append(line)
-            sections.append("")
-        elif (SECHEADER.match(line)):
-            sections.append(line)
-        else:
-            sections[-1] = sections[-1] + " " + line
-    total = ""
-    for sec in sections:
-        if (sec != ""):
-            sec = sec.replace("&","&")
-            sec = sec.replace("<","&lt;")
-            sec = sec.replace(">","&gt;")
-            sec = sec.replace("  "," ")
-            sec = sec.replace("  "," ")
-            if (delsection != None) and (delsection.match(sec)):
-                included[sec] = 1
-            if sec not in included:
-                included[sec] = 1
-                total = total + sec + "<br>\n"
-    return total
-
-def linkTo(link, text):
-    return '<a href="' + link + '">' + text + '</a>'
-
-def convertToPythonFn(fn):
-    result = ""
-    lastc = 0
-    for c in fn:
-        if (c!="_"):
-            if (lastc=="_"):
-                result = result + c.upper()
-            else:
-                result = result + c
-        lastc = c
-    return result
-
-def removeFileLicense(content):
-    # Removes the license part at the top of a file.
-    return re.sub(FILEHEADER, "", content).strip()
-
-########################################################################
-#
-# Interrogate Database Tokenizer
-#
-########################################################################
-
-class InterrogateTokenizer:
-    """
-    A big string, with a "parse pointer", and routines to
-    extract integers and strings.  The token syntax is that
-    used by interrogate databases.
-    """
-
-    def __init__(self, fn):
-        self.fn = fn
-        self.pos = 0
-        self.data = readFile(fn)
-
-    def readint(self):
-        neg = 0
-        while (self.data[self.pos].isspace()):
-            self.pos += 1
-        if (self.data[self.pos] == "-"):
-            neg = 1
-            self.pos += 1
-        if (self.data[self.pos].isdigit()==0):
-            print("File position " + str(self.pos))
-            print("Text: " + self.data[self.pos:self.pos+50])
-            sys.exit("Syntax error in interrogate file format 0")
-        value = 0
-        while (self.data[self.pos].isdigit()):
-            value = value*10 + int(self.data[self.pos])
-            self.pos += 1
-        if (neg): value = -value
-        return value
-
-    def readstring(self):
-        length = self.readint()
-        if (self.data[self.pos].isspace()==0):
-            sys.exit("Syntax error in interrogate file format 1")
-        self.pos += 1
-        body = self.data[self.pos:self.pos+length]
-        if (len(body) != length):
-            sys.exit("Syntax error in interrogate file format 2")
-        self.pos += length
-        return body
-
-########################################################################
-#
-# Interrogate Database Storage/Parsing
-#
-########################################################################
-
-def parseInterrogateIntVec(tokzr):
-    length = tokzr.readint()
-    result = []
-    for i in range(length):
-        result.append(tokzr.readint())
-    return result
-
-class InterrogateFunction:
-    def __init__(self, tokzr, db):
-        self.db = db
-        self.index = tokzr.readint()
-        self.componentname = tokzr.readstring()
-        self.flags = tokzr.readint()
-        self.classindex = tokzr.readint()
-        self.scopedname = tokzr.readstring()
-        self.cwrappers = parseInterrogateIntVec(tokzr)
-        self.pythonwrappers = parseInterrogateIntVec(tokzr)
-        self.comment = tokzr.readstring()
-        self.prototype = tokzr.readstring()
-
-class InterrogateEnumValue:
-    def __init__(self, tokzr):
-        self.name = tokzr.readstring()
-        self.scopedname = tokzr.readstring()
-        self.value = tokzr.readint()
-
-class InterrogateDerivation:
-    def __init__(self, tokzr):
-        self.flags = tokzr.readint()
-        self.base = tokzr.readint()
-        self.upcast = tokzr.readint()
-        self.downcast = tokzr.readint()
-
-class InterrogateType:
-    def __init__(self, tokzr, db):
-        self.db = db
-        self.index = tokzr.readint()
-        self.componentname = tokzr.readstring()
-        self.flags = tokzr.readint()
-        self.scopedname = tokzr.readstring()
-        self.truename = tokzr.readstring()
-        self.outerclass = tokzr.readint()
-        self.atomictype = tokzr.readint()
-        self.wrappedtype = tokzr.readint()
-        self.constructors = parseInterrogateIntVec(tokzr)
-        self.destructor = tokzr.readint()
-        self.elements = parseInterrogateIntVec(tokzr)
-        self.methods = parseInterrogateIntVec(tokzr)
-        self.casts = parseInterrogateIntVec(tokzr)
-        self.derivations = []
-        nderivations = tokzr.readint()
-        for i in range(nderivations):
-            self.derivations.append(InterrogateDerivation(tokzr))
-        self.enumvalues = []
-        nenumvalues = tokzr.readint()
-        for i in range(nenumvalues):
-            self.enumvalues.append(InterrogateEnumValue(tokzr))
-        self.nested = parseInterrogateIntVec(tokzr)
-        self.comment = tokzr.readstring()
-
-class InterrogateParameter:
-    def __init__(self, tokzr):
-        self.name = tokzr.readstring()
-        self.parameterflags = tokzr.readint()
-        self.type = tokzr.readint()
-
-class InterrogateWrapper:
-    def __init__(self, tokzr, db):
-        self.db = db
-        self.index = tokzr.readint()
-        self.componentname = tokzr.readstring()
-        self.flags = tokzr.readint()
-        self.function = tokzr.readint()
-        self.returntype = tokzr.readint()
-        self.returnvaluedestructor = tokzr.readint()
-        self.uniquename = tokzr.readstring()
-        self.parameters = []
-        nparameters = tokzr.readint()
-        for i in range(nparameters):
-            self.parameters.append(InterrogateParameter(tokzr))
-
-class InterrogateDatabase:
-    def __init__(self, tokzr):
-        self.fn = tokzr.fn
-        self.magic = tokzr.readint()
-        version1 = tokzr.readint()
-        version2 = tokzr.readint()
-        if (version1 != 2) or (version2 != 2):
-            sys.exit("This program only understands interrogate file format 2.2")
-        self.library = tokzr.readstring()
-        self.libhash = tokzr.readstring()
-        self.module = tokzr.readstring()
-        self.functions = {}
-        self.wrappers = {}
-        self.types = {}
-        self.namedtypes = {}
-        count_functions = tokzr.readint()
-        for i in range(count_functions):
-            fn = InterrogateFunction(tokzr, self)
-            self.functions[fn.index] = fn
-        count_wrappers = tokzr.readint()
-        for i in range(count_wrappers):
-            wr = InterrogateWrapper(tokzr, self)
-            self.wrappers[wr.index] = wr
-        count_types = tokzr.readint()
-        for i in range(count_types):
-            tp = InterrogateType(tokzr, self)
-            self.types[tp.index] = tp
-            self.namedtypes[tp.scopedname] = tp
-
-########################################################################
-#
-# Pattern Matching for Python Parse Trees
-#
-########################################################################
-
-def printTree(tree, indent):
-    spacing = "                                                        "[:indent]
-    if isinstance(tree, tuple) and isinstance(tree[0], int):
-        if tree[0] in symbol.sym_name:
-            for i in range(len(tree)):
-                if (i==0):
-                    print(spacing + "(symbol." + symbol.sym_name[tree[0]] + ",")
-                else:
-                    printTree(tree[i], indent+1)
-            print(spacing + "),")
-        elif tree[0] in token.tok_name:
-            print(spacing + "(token." + token.tok_name[tree[0]] + ", '" + tree[1] + "'),")
-        else:
-            print(spacing + str(tree))
-    else:
-        print(spacing + str(tree))
-
-
-COMPOUND_STMT_PATTERN = (
-    symbol.stmt,
-    (symbol.compound_stmt, ['compound'])
-    )
-
-
-DOCSTRING_STMT_PATTERN = (
-    symbol.stmt,
-    (symbol.simple_stmt,
-     (symbol.small_stmt,
-      (symbol.expr_stmt,
-       (symbol.testlist,
-        (symbol.test,
-         (symbol.or_test,
-           (symbol.and_test,
-            (symbol.not_test,
-             (symbol.comparison,
-              (symbol.expr,
-               (symbol.xor_expr,
-                (symbol.and_expr,
-                 (symbol.shift_expr,
-                  (symbol.arith_expr,
-                   (symbol.term,
-                    (symbol.factor,
-                     (symbol.power,
-                      (symbol.atom,
-                       (token.STRING, ['docstring'])
-                       ))))))))))))))))),
-     (token.NEWLINE, '')
-     ))
-
-DERIVATION_PATTERN = (
-    symbol.test,
-    (symbol.or_test,
-     (symbol.and_test,
-      (symbol.not_test,
-       (symbol.comparison,
-        (symbol.expr,
-         (symbol.xor_expr,
-          (symbol.and_expr,
-           (symbol.shift_expr,
-            (symbol.arith_expr,
-             (symbol.term,
-              (symbol.factor,
-               (symbol.power,
-                (symbol.atom,
-                 (token.NAME, ['classname'])
-   ))))))))))))))
-
-ASSIGNMENT_STMT_PATTERN = (
-    symbol.stmt,
-    (symbol.simple_stmt,
-     (symbol.small_stmt,
-      (symbol.expr_stmt,
-       (symbol.testlist,
-        (symbol.test,
-         (symbol.or_test,
-           (symbol.and_test,
-            (symbol.not_test,
-             (symbol.comparison,
-              (symbol.expr,
-               (symbol.xor_expr,
-                (symbol.and_expr,
-                 (symbol.shift_expr,
-                  (symbol.arith_expr,
-                   (symbol.term,
-                    (symbol.factor,
-                     (symbol.power,
-                      (symbol.atom,
-                       (token.NAME, ['varname']),
-       ))))))))))))))),
-       (token.EQUAL, '='),
-       (symbol.testlist, ['rhs']))),
-     (token.NEWLINE, ''),
-   ))
-
-class ParseTreeInfo:
-    docstring = ''
-    name = ''
-
-    def __init__(self, tree, name, file):
-        """
-        The code can be a string (in which case it is parsed), or it
-        can be in parse tree form already.
-        """
-        self.name = name
-        self.file = file
-        self.class_info = {}
-        self.function_info = {}
-        self.assign_info = {}
-        self.derivs = {}
-        if isinstance(tree, str):
-            try:
-                tree = parser.suite(tree+"\n").totuple()
-                if (tree):
-                    found, vars = self.match(DOCSTRING_STMT_PATTERN, tree[1])
-                    if found:
-                        self.docstring = vars["docstring"]
-            except:
-                print("CAUTION --- Parse failed: " + name)
-        if isinstance(tree, tuple):
-            self.extract_info(tree)
-
-    def match(self, pattern, data, vars=None):
-        """
-        pattern
-            Pattern to match against, possibly containing variables.
-        data
-            Data to be checked and against which variables are extracted.
-        vars
-            Dictionary of variables which have already been found.  If not
-            provided, an empty dictionary is created.
-
-        The `pattern' value may contain variables of the form ['varname']
-        which are allowed to parseTreeMatch anything.  The value that is
-        parseTreeMatched is returned as part of a dictionary which maps
-        'varname' to the parseTreeMatched value.  'varname' is not required
-        to be a string object, but using strings makes patterns and the code
-        which uses them more readable.  This function returns two values: a
-        boolean indicating whether a parseTreeMatch was found and a
-        dictionary mapping variable names to their associated values.
-        """
-        if vars is None:
-            vars = {}
-        if type(pattern) is list:       # 'variables' are ['varname']
-            vars[pattern[0]] = data
-            return 1, vars
-        if type(pattern) is not tuple:
-            return (pattern == data), vars
-        if len(data) != len(pattern):
-            return 0, vars
-        for pattern, data in map(None, pattern, data):
-            same, vars = self.match(pattern, data, vars)
-            if not same:
-                break
-        return same, vars
-
-    def extract_info(self, tree):
-        # extract docstring
-        found = 0
-        if len(tree) == 2:
-            found, vars = self.match(DOCSTRING_STMT_PATTERN[1], tree[1])
-        elif len(tree) >= 4:
-            found, vars = self.match(DOCSTRING_STMT_PATTERN, tree[3])
-        if found:
-            self.docstring = eval(vars['docstring'])
-        # discover inner definitions
-        for node in tree[1:]:
-            found, vars = self.match(ASSIGNMENT_STMT_PATTERN, node)
-            if found:
-                self.assign_info[vars['varname']] = 1
-            found, vars = self.match(COMPOUND_STMT_PATTERN, node)
-            if found:
-                cstmt = vars['compound']
-                if cstmt[0] == symbol.funcdef:
-                    name = cstmt[2][1]
-                    # Workaround for a weird issue with static and classmethods
-                    if name == "def":
-                        name = cstmt[3][1]
-                        self.function_info[name] = ParseTreeInfo(cstmt and cstmt[-1] or None, name, self.file)
-                        self.function_info[name].prototype = self.extract_tokens("", cstmt[4])
-                    else:
-                        self.function_info[name] = ParseTreeInfo(cstmt and cstmt[-1] or None, name, self.file)
-                        self.function_info[name].prototype = self.extract_tokens("", cstmt[3])
-                elif cstmt[0] == symbol.classdef:
-                    name = cstmt[2][1]
-                    self.class_info[name] = ParseTreeInfo(cstmt and cstmt[-1] or None, name, self.file)
-                    self.extract_derivs(self.class_info[name], cstmt)
-
-    def extract_derivs(self, classinfo, tree):
-        if (len(tree)==8):
-            derivs = tree[4]
-            for deriv in derivs[1:]:
-                found, vars = self.match(DERIVATION_PATTERN, deriv)
-                if (found):
-                    classinfo.derivs[vars["classname"]] = 1
-
-    def extract_tokens(self, str, tree):
-        if (isinstance(tree, tuple)):
-            if tree[0] in token.tok_name:
-                str = str + tree[1]
-                if (tree[1]==","): str=str+" "
-            elif tree[0] in symbol.sym_name:
-                for sub in tree[1:]:
-                    str = self.extract_tokens(str, sub)
-        return str
-
-########################################################################
-#
-# The code database contains:
-#
-#  - a list of InterrogateDatabase objects representing C++ modules.
-#  - a list of ParseTreeInfo objects representing python modules.
-#
-# Collectively, these make up all the data about all the code.
-#
-########################################################################
-
-class CodeDatabase:
-    def __init__(self, cxxlist, pylist):
-        self.types = {}
-        self.funcs = {}
-        self.goodtypes = {}
-        self.funcExports = {}
-        self.typeExports = {}
-        self.varExports = {}
-        self.globalfn = []
-        self.formattedprotos = {}
-        print("Reading C++ source files")
-        for cxx in cxxlist:
-            tokzr = InterrogateTokenizer(cxx)
-            idb = InterrogateDatabase(tokzr)
-            for type in idb.types.values():
-                if (type.flags & 8192) or type.scopedname not in self.types:
-                    self.types[type.scopedname] = type
-                if (type.flags & 8192) and (type.atomictype == 0) and (type.scopedname.count(" ")==0) and (type.scopedname.count(":")==0):
-                    self.goodtypes[type.scopedname] = type
-                    self.typeExports.setdefault("pandac.PandaModules", []).append(type.scopedname)
-            for func in idb.functions.values():
-                type = idb.types.get(func.classindex)
-                func.pyname = convertToPythonFn(func.componentname)
-                if (type == None):
-                    self.funcs["GLOBAL."+func.pyname] = func
-                    self.globalfn.append("GLOBAL."+func.pyname)
-                    self.funcExports.setdefault("pandac.PandaModules", []).append(func.pyname)
-                else:
-                    self.funcs[type.scopedname+"."+func.pyname] = func
-        print("Reading Python sources files")
-        for py in pylist:
-            pyinf = ParseTreeInfo(readFile(py), py, py)
-            mod = pathToModule(py)
-            for type in pyinf.class_info.keys():
-                typinf = pyinf.class_info[type]
-                self.types[type] = typinf
-                self.goodtypes[type] = typinf
-                self.typeExports.setdefault(mod, []).append(type)
-                for func in typinf.function_info.keys():
-                    self.funcs[type+"."+func] = typinf.function_info[func]
-            for func in pyinf.function_info.keys():
-                self.funcs["GLOBAL."+func] = pyinf.function_info[func]
-                self.globalfn.append("GLOBAL."+func)
-                self.funcExports.setdefault(mod, []).append(func)
-            for var in pyinf.assign_info.keys():
-                self.varExports.setdefault(mod, []).append(var)
-
-    def getClassList(self):
-        return list(self.goodtypes.keys())
-
-    def getGlobalFunctionList(self):
-        return self.globalfn
-
-    def getClassComment(self, cn):
-        type = self.types.get(cn)
-        if (isinstance(type, InterrogateType)):
-            return textToHTML(type.comment,"/")
-        elif (isinstance(type, ParseTreeInfo)):
-            return textToHTML(type.docstring,"#")
-        else:
-            return ""
-
-    def getClassParents(self, cn):
-        type = self.types.get(cn)
-        if (isinstance(type, InterrogateType)):
-            parents = []
-            for deriv in type.derivations:
-                basetype = type.db.types[deriv.base]
-                parents.append(basetype.scopedname)
-            return parents
-        elif (isinstance(type, ParseTreeInfo)):
-            return list(type.derivs.keys())
-        else:
-            return []
-
-    def getClassConstants(self, cn):
-        type = self.types.get(cn)
-        if (isinstance(type, InterrogateType)):
-            result = []
-            for subtype in type.nested:
-                enumtype = type.db.types[subtype]
-                if (len(enumtype.enumvalues)):
-                    for enumvalue in enumtype.enumvalues:
-                        name = convertToPythonFn(enumvalue.name)
-                        result.append((name, "("+enumtype.componentname+")"))
-                    result.append(("",""))
-            return result
-        else:
-            return []
-
-    def buildInheritance(self, inheritance, cn):
-        if (inheritance.count(cn) == 0):
-            inheritance.append(cn)
-            for parent in self.getClassParents(cn):
-                self.buildInheritance(inheritance, parent)
-
-    def getInheritance(self, cn):
-        inheritance = []
-        self.buildInheritance(inheritance, cn)
-        return inheritance
-
-    def getClassImport(self, cn):
-        type = self.types.get(cn)
-        if (isinstance(type, InterrogateType)):
-            return "pandac.PandaModules"
-        else:
-            return pathToModule(type.file)
-
-    def getClassConstructors(self, cn):
-        # Only detects C++ constructors, not Python constructors, since
-        # those are treated as ordinary methods.
-        type = self.types.get(cn)
-        result = []
-        if (isinstance(type, InterrogateType)):
-            for constructor in type.constructors:
-                func = type.db.functions[constructor]
-                if (func.classindex == type.index):
-                    result.append(type.scopedname+"."+func.pyname)
-        return result
-
-    def getClassMethods(self, cn):
-        type = self.types.get(cn)
-        result = []
-        if (isinstance(type, InterrogateType)):
-            for method in type.methods:
-                func = type.db.functions[method]
-                if (func.classindex == type.index):
-                    result.append(type.scopedname+"."+func.pyname)
-        elif (isinstance(type, ParseTreeInfo)):
-            for method in type.function_info.keys():
-                result.append(type.name + "." + method)
-        return result
-
-    def getFunctionName(self, fn):
-        func = self.funcs.get(fn)
-        if (isinstance(func, InterrogateFunction)):
-            return func.pyname
-        elif (isinstance(func, ParseTreeInfo)):
-            return func.name
-        else:
-            return fn
-
-    def getFunctionImport(self, fn):
-        func = self.funcs.get(fn)
-        if (isinstance(func, InterrogateFunction)):
-            return "pandac.PandaModules"
-        else:
-            return pathToModule(func.file)
-
-    def getFunctionPrototype(self, fn, urlprefix, urlsuffix):
-        func = self.funcs.get(fn)
-        if (isinstance(func, InterrogateFunction)):
-            if fn in self.formattedprotos:
-                proto = self.formattedprotos[fn]
-            else:
-                proto = func.prototype
-                proto = proto.replace(" inline "," ")
-                if (proto.startswith("inline ")): proto = proto[7:]
-                proto = proto.replace("basic_string< char >", "string")
-                proto = textToHTML(proto,"")
-                if "." in fn:
-                    for c in self.goodtypes.keys():
-                        if c != fn.split(".")[0] and (c in proto):
-                            proto = re.sub("\\b%s\\b" % c, linkTo(urlprefix+c+urlsuffix, c), proto)
-                self.formattedprotos[fn] = proto
-            return proto
-        elif (isinstance(func, ParseTreeInfo)):
-            return textToHTML("def "+func.name+func.prototype,"")
-        return fn
-
-    def getFunctionComment(self, fn):
-        func = self.funcs.get(fn)
-        if (isinstance(func, InterrogateFunction)):
-            return textToHTML(removeFileLicense(func.comment), "/", JUNKHEADER)
-        elif (isinstance(func, ParseTreeInfo)):
-            return textToHTML(func.docstring, "#")
-        return fn
-
-    def isFunctionPython(self, fn):
-        func = self.funcs.get(fn)
-        if (isinstance(func, InterrogateFunction)):
-            return False
-        elif (isinstance(func, ParseTreeInfo)):
-            return True
-        return False
-
-    def getFuncExports(self, mod):
-        return self.funcExports.get(mod, [])
-
-    def getTypeExports(self, mod):
-        return self.typeExports.get(mod, [])
-
-    def getVarExports(self, mod):
-        return self.varExports.get(mod, [])
-
-########################################################################
-#
-# The "Class Rename Dictionary" - Yech.
-#
-########################################################################
-
-CLASS_RENAME_DICT = {
-    # No longer used, now empty.
-}
-
-
-########################################################################
-#
-# HTML generation
-#
-########################################################################
-
-def makeCodeDatabase(indirlist, directdirlist):
-    if isinstance(directdirlist, str):
-        directdirlist = [directdirlist]
-    ignore = {}
-    ignore["__init__.py"] = 1
-    for directdir in directdirlist:
-        ignore[directdir + "/src/directscripts"] = 1
-        ignore[directdir + "/src/extensions"] = 1
-        ignore[directdir + "/src/extensions_native"] = 1
-        ignore[directdir + "/src/ffi"] = 1
-        ignore[directdir + "/built"] = 1
-    cxxfiles = []
-    pyfiles = []
-    findFiles(indirlist,     ".in", ignore, cxxfiles)
-    findFiles(directdirlist, ".py", ignore, pyfiles)
-    return CodeDatabase(cxxfiles, pyfiles)
-
-def generateFunctionDocs(code, method, urlprefix, urlsuffix):
-    name = code.getFunctionName(method)
-    proto = code.getFunctionPrototype(method, urlprefix, urlsuffix)
-    comment = code.getFunctionComment(method)
-    if (comment == ""): comment = "Undocumented function.<br>\n"
-    chunk = '<table bgcolor="e8e8e8" border=0 cellspacing=0 cellpadding=5 width="100%"><tr><td>' + "\n"
-    chunk = chunk + '<a name="' + name + '"><b>' + name + "</b></a><br>\n"
-    chunk = chunk + proto + "<br>\n"
-    chunk = chunk + comment
-    chunk = chunk + "</td></tr></table><br>\n"
-    return chunk
-
-def generateLinkTable(link, text, cols, urlprefix, urlsuffix):
-    column = (len(link)+cols-1)/cols
-    percent = 100 / cols
-    result = '<table width="100%">\n'
-    for i in range(column):
-        line = ""
-        for j in range(cols):
-            slot = i + column*j
-            linkval = ""
-            textval = ""
-            if (slot < len(link)): linkval = link[slot]
-            if (slot < len(text)): textval = text[slot]
-            if (i==0):
-                line = line + '<td width="' + str(percent) + '%">' + linkTo(urlprefix+linkval+urlsuffix, textval) + "</td>"
-            else:
-                line = line + '<td>' + linkTo(urlprefix+linkval+urlsuffix, textval) + "</td>"
-        result = result + "<tr>" + line + "</tr>\n"
-    result = result + "</table>\n"
-    return result
-
-def generate(pversion, indirlist, directdirlist, docdir, header, footer, urlprefix, urlsuffix):
-    code = makeCodeDatabase(indirlist, directdirlist)
-    classes = code.getClassList()[:]
-    classes.sort(None, str.lower)
-    xclasses = classes[:]
-    print("Generating HTML pages")
-    for type in classes:
-        body = "<h1>" + type + "</h1>\n"
-        comment = code.getClassComment(type)
-        body = body + "<ul>\nfrom " + code.getClassImport(type) + " import " + type + "</ul>\n\n"
-        body = body + "<ul>\n" + comment + "</ul>\n\n"
-        inheritance = code.getInheritance(type)
-        body = body + "<h2>Inheritance:</h2>\n<ul>\n"
-        for inh in inheritance:
-            line = "  " + linkTo(urlprefix+inh+urlsuffix, inh) + ": "
-            for parent in code.getClassParents(inh):
-                line = line + linkTo(urlprefix+parent+urlsuffix, parent) + " "
-            body = body + line + "<br>\n"
-        body = body + "</ul>\n"
-        for sclass in inheritance:
-            methods = code.getClassMethods(sclass)[:]
-            methods.sort(None, str.lower)
-            constructors = code.getClassConstructors(sclass)
-            if (len(methods) > 0 or len(constructors) > 0):
-                body = body + "<h2>Methods of "+sclass+":</h2>\n<ul>\n"
-                if len(constructors) > 0:
-                    fn = code.getFunctionName(constructors[0])
-                    body = body + '<a href="#' + fn + '">' + fn + " (Constructor)</a><br>\n"
-                for method in methods:
-                    fn = code.getFunctionName(method)
-                    body = body + '<a href="#' + fn + '">' + fn + "</a><br>\n"
-                body = body + "</ul>\n"
-        for sclass in inheritance:
-            enums = code.getClassConstants(sclass)[:]
-            if (len(enums) > 0):
-                body = body + "<h2>Constants in "+sclass+":</h2>\n<ul><table>\n"
-                for (value, comment) in enums:
-                    body = body + "<tr><td>" + value + "</td><td>" + comment + "</td></tr>\n"
-                body = body + "</table></ul>"
-        for sclass in inheritance:
-            constructors = code.getClassConstructors(sclass)
-            for constructor in constructors:
-                body = body + generateFunctionDocs(code, constructor, urlprefix, urlsuffix)
-            methods = code.getClassMethods(sclass)[:]
-            methods.sort(None, str.lower)
-            for method in methods:
-                body = body + generateFunctionDocs(code, method, urlprefix, urlsuffix)
-        body = header + body + footer
-        writeFile(docdir + "/" + type + ".html", body)
-        if type in CLASS_RENAME_DICT:
-            modtype = CLASS_RENAME_DICT[type]
-            writeFile(docdir + "/" + modtype + ".html", body)
-            xclasses.append(modtype)
-    xclasses.sort(None, str.lower)
-
-    index = "<h1>List of Classes - Panda " + pversion + "</h1>\n"
-    index = index + generateLinkTable(xclasses, xclasses, 3, urlprefix, urlsuffix)
-    fnlist = code.getGlobalFunctionList()[:]
-    fnlist.sort(None, str.lower)
-    fnnames = []
-    for i in range(len(fnlist)):
-        fnnames.append(code.getFunctionName(fnlist[i]))
-    index = header + index + footer
-    writeFile(docdir + "/classes.html", index)
-
-    index = "<h1>List of Global Functions - Panda " + pversion + "</h1>\n"
-    index = index + generateLinkTable(fnnames, fnnames, 3,"#","")
-    for func in fnlist:
-        index = index + generateFunctionDocs(code, func, urlprefix, urlsuffix)
-    index = header + index + footer
-    writeFile(docdir + "/functions.html", index)
-
-    table = {}
-    for type in classes:
-        for method in code.getClassMethods(type)[:]:
-            name = code.getFunctionName(method)
-            prefix = name[0].upper()
-            if prefix not in table:
-                table[prefix] = {}
-            if name not in table[prefix]:
-                table[prefix][name] = []
-            table[prefix][name].append(type)
-
-    index = "<h1>List of Methods - Panda " + pversion + "</h1>\n"
-
-    prefixes = list(table.keys())
-    prefixes.sort(None, str.lower)
-    for prefix in prefixes:
-        index = index + linkTo("#"+prefix, prefix) + " "
-    index = index + "<br><br>"
-    for prefix in prefixes:
-        index = index + '<a name="' + prefix + '">' + "\n"
-        names = list(table[prefix].keys())
-        names.sort(None, str.lower)
-        for name in names:
-            line = '<b>' + name + ":</b><ul>\n"
-            ctypes = table[prefix][name]
-            ctypes.sort(None, str.lower)
-            for type in ctypes:
-                line = line + "<li>" + linkTo(urlprefix+type+urlsuffix+"#"+name, type) + "\n"
-            line = line + "</ul>\n"
-            index = index + line + "\n"
-    index = header + index + footer
-    writeFile(docdir + "/methods.html", index)
-
-    index = "<h1>Panda " + pversion + "</h1>\n"
-    index = index + "<ul>\n"
-    index = index + "<li>" + linkTo(urlprefix+"classes"+urlsuffix, "List of all Classes") + "\n"
-    index = index + "</ul>\n"
-    index = index + "<ul>\n"
-    index = index + "<li>" + linkTo(urlprefix+"functions"+urlsuffix, "List of all Global Functions") + "\n"
-    index = index + "</ul>\n"
-    index = index + "<ul>\n"
-    index = index + "<li>" + linkTo(urlprefix+"methods"+urlsuffix, "List of all Methods (very long)") + "\n"
-    index = index + "</ul>\n"
-    writeFile(docdir + "/index.html", index)
-
-
-########################################################################
-#
-# IMPORT repair
-#
-########################################################################
-
-def expandImports(indirlist, directdirlist, fixdirlist):
-    code = makeCodeDatabase(indirlist, directdirlist)
-    fixfiles = []
-    findFiles(fixdirlist, ".py", {}, fixfiles)
-    for fixfile in fixfiles:
-        if (os.path.isfile(fixfile+".orig")):
-            text = readFile(fixfile+".orig")
-        else:
-            text = readFile(fixfile)
-            writeFile(fixfile+".orig", text)
-        text = text.replace("\r","")
-        lines = text.split("\n")
-        used = {}
-        for id in IDENTIFIER.findall(text):
-            used[id] = 1
-        result = []
-        for line in lines:
-            mat = IMPORTSTAR.match(line)
-            if (mat):
-                module = mat.group(1)
-                if (fixfile.count("/")!=0) and (module.count(".")==0):
-                    modfile = os.path.dirname(fixfile)+"/"+module+".py"
-                    if (os.path.isfile(modfile)):
-                        module = pathToModule(modfile)
-                typeExports = code.getTypeExports(module)
-                funcExports = code.getFuncExports(module)
-                varExports = code.getVarExports(module)
-                if (len(typeExports)+len(funcExports)+len(varExports)==0):
-                    result.append(line)
-                    print(fixfile + " : " + module + " : no exports")
-                else:
-                    print(fixfile + " : " + module + " : repairing")
-                    for x in funcExports:
-                        fn = code.getFunctionName(x)
-                        if fn in used:
-                            result.append("from "+module+" import "+fn)
-                    for x in typeExports:
-                        if x in used:
-                            result.append("from "+module+" import "+x)
-                    for x in varExports:
-                        if x in used:
-                            result.append("from "+module+" import "+x)
-            else:
-                result.append(line)
-        writeFileLines(fixfile, result)

makepanda/expandimports.bat

@@ -1,29 +0,0 @@
-@echo off
-
-REM
-REM Verify that we can find the 'expandimports' python script
-REM and the python interpreter.  If we can find both, then
-REM run 'expandimports'.
-REM
-
-set thirdparty=thirdparty
-if defined MAKEPANDA_THIRDPARTY set thirdparty=%MAKEPANDA_THIRDPARTY%
-
-if not exist makepanda\expandimports.py goto :missing1
-if not exist %thirdparty%\win-python\python.exe goto :missing2
-%thirdparty%\win-python\python.exe makepanda\expandimports.py %*
-goto done
-
-:missing1
-  echo You need to change directory to the root of the panda source tree
-  echo before invoking expandimports.
-  goto done
-
-:missing2
-  echo You seem to be missing the 'thirdparty' directory.  You probably checked
-  echo the source code out from GitHub.  The GitHub repository is
-  echo missing the 'thirdparty' directory.  You will need to supplement the
-  echo code by downloading the 'thirdparty' directory from www.panda3d.org
-  goto done
-
-:done

makepanda/expandimports.py

@@ -1,21 +0,0 @@
-########################################################################
-##
-## Win32 Usage: makepanda\expandimports.bat
-## Linux Usage: makepanda/expandimports.py
-##
-########################################################################
-
-import sys,os,re
-sys.path = ["direct/src/directscripts"] + sys.path
-import gendocs
-
-########################################################################
-##
-## Make sure panda has been built.
-##
-########################################################################
-
-if (os.path.isfile("built/pandac/input/libpgraph.in")==0) or (os.path.isfile("built/pandac/input/libputil.in")==0):
-    sys.exit("Cannot read the interrogate-output files in built/pandac/input")
-
-gendocs.expandImports("built/pandac/input", "direct", "samples")

makepanda/makechm.bat

@@ -1,29 +0,0 @@
-@echo off
-
-REM
-REM Verify that we can find the 'makechm' python script
-REM and the python interpreter.  If we can find both, then
-REM run 'makechm'.
-REM
-
-set thirdparty=thirdparty
-if defined MAKEPANDA_THIRDPARTY set thirdparty=%MAKEPANDA_THIRDPARTY%
-
-if not exist makepanda\makechm.py goto :missing1
-if not exist %thirdparty%\win-python\python.exe goto :missing2
-%thirdparty%\win-python\python.exe makepanda\makechm.py %*
-goto done
-
-:missing1
-  echo You need to change directory to the root of the panda source tree
-  echo before invoking makechm.
-  goto done
-
-:missing2
-  echo You seem to be missing the 'thirdparty' directory.  You probably checked
-  echo the source code out from GitHub.  The GitHub repository is
-  echo missing the 'thirdparty' directory.  You will need to supplement the
-  echo code by downloading the 'thirdparty' directory from www.panda3d.org
-  goto done
-
-:done

makepanda/makechm.py

@@ -1,281 +0,0 @@
-########################################################################
-##
-## Win32 Usage: makepanda\makechm.bat
-## Linux Usage: makepanda/makechm.py
-##
-## To use this script, you will need to have hhc.exe on your system.
-## For verbose output, run with -v or --verbose option.
-## To keep the temporary .hhc, .hhk, .hhp, .chw files use -k or --keep.
-##
-## You can also import this file as a python module. You will then have
-## access to three functions: makeCHM, makeManualCHM, makeReferenceCHM.
-## This is how you call them:
-##   makeCHM(outputfile, dirname, title)
-## where outputfile is the filename where the .chm file will be written,
-## and dirname is the directory containing the html files to include.
-## Title will be the title of the CHM file.
-## The functions makeManualCHM and makeReferenceCHM work exactly the
-## same, except that they work with a structure resembling that of the
-## Panda3D manual and reference, respectively.
-## Note: outputfile should not contain spaces.
-##
-########################################################################
-
-__all__ = ["makeCHM", "makeManualCHM", "makeReferenceCHM"]
-import os, re
-from sys import exit
-import xml.dom.minidom
-from xml.dom.minidom import Node
-
-VERBOSE = False
-KEEPTEMP = False
-
-if __name__ == "__main__":
-    from sys import argv
-    VERBOSE  = ("-v" in argv) or ("-vk" in argv) or ("-kv" in argv) or ("--verbose" in argv)
-    KEEPTEMP = ("-k" in argv) or ("-kv" in argv) or ("-vk" in argv) or ("--keep"    in argv)
-
-OPTIONBLOCK = """
-Binary TOC=Yes
-Compatibility=1.1 or later
-Compiled file=%s
-Contents file=%s.hhc
-Default Font=Arial,10,0
-Default topic=%s
-Display compile progress=VERBOSE
-Full-text search=Yes
-Index file=%s.hhk
-Language=0x409 English (United States)
-Title=%s""".replace("VERBOSE", VERBOSE and "Yes" or "No")
-
-HTMLBLOCK = """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
-  <head>
-    <meta name="generator" content="Panda3D - makechm.py">
-  </head>
-  <body>
-    <object type="text/site properties">
-      <param name="Window Styles" value="0x800025">
-      <param name="ImageType" value="Folder">
-      <param name="Font" value="Arial,8,0">
-    </object>
-    <ul>\n"""
-
-REFERENCEITEMS = [
-    ("index.html",     "Main Page"),
-    ("methods.html",   "Methods"),
-    ("functions.html", "Global Functions"),
-    ("classes.html",   "Classes"),
-]
-
-def urldecode(url):
-    regex = re.compile("%([0-9a-hA-H][0-9a-hA-H])", re.M)
-    return regex.sub(lambda x: chr(int(x.group(1), 16)), url)
-
-def ireplace(string, target, replacement):
-    """Case-insensitive replace."""
-    index = string.lower().find(target.lower())
-    if index >= 0:
-        result = string[:index] + replacement + string[index + len(target):]
-        return result
-    else:
-        return string
-
-def parseAnchor(node):
-    """Parses an XML minidom node representing an anchor and returns a tuple
-    containing the href and the content of the link."""
-    assert node.nodeType == Node.ELEMENT_NODE
-    assert node.localName == "a"
-    href = ""
-    title = ""
-    for localName, a in node.attributes.items():
-        if localName.lower() == "href":
-            href = a
-    for e in node.childNodes:
-        if e.nodeType == Node.TEXT_NODE:
-            title += e.data
-    return href, title
-
-def parseManualTree(node):
-    """Parses a tree of the manual Main_Page and returns it through a list containing tuples:
-    [(title, href, [(title, href, [...]), ...]), ...]"""
-    if node.nodeType != Node.ELEMENT_NODE: return []
-    result = []
-    lastadded = None
-    for e in node.childNodes:
-        if e.nodeType == Node.ELEMENT_NODE:
-            if e.localName == "ol":
-                assert lastadded != None
-                for i in xrange(len(result)):
-                    if result[i][:2] == lastadded:
-                        result[i] = lastadded + (parseManualTree(e),)
-            elif e.localName == "a":
-                href, title = parseAnchor(e)
-                lastadded = title, href
-                result.append((title, href, None))
-    return result
-
-def parseManualTOC(filename):
-    """Reads the manual's Main_Page file and returns a list of all the trees found."""
-    filename = open(filename)
-    text = filename.read()
-    filename.close()
-    text = text.split("<h2>Table of Contents</h2>")[1].split("</div>")[0]
-    text = "<root>" + text.replace("<li>", "") + "</root>"
-    text = re.sub(re.compile("<!--([^>]+)>"), "", text)
-    result = []
-    for e in xml.dom.minidom.parseString(text).childNodes[0].childNodes:
-        if e.nodeType == Node.ELEMENT_NODE:
-            result.append(parseManualTree(e))
-    return result
-
-def treeToHTML(tree, dirname, indent = ""):
-    """Converts a tree into HTML code suitable for .hhc or .hhk files. The tree should be like:
-    [(title, href, [(title, href, [...]), ...]), ...]"""
-    html = ""
-    for title, href, sub in tree:
-        html += indent + "<li><object type=\"text/sitemap\">\n"
-        html += indent + "  <param name=\"Name\" value=\"%s\">\n" % title.replace("CXX", "C++").replace("\"", "&quot;")
-        html += indent + "  <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, href))
-        html += indent + "</object>\n"
-        if sub != None:
-            html += indent + "<ul>\n"
-            html += treeToHTML(sub, dirname, indent + "  ")
-            html += indent + "</ul>\n"
-    return html
-
-def makeCHM(outputfile, dirname, title, special = None):
-    """Creates a CHM file based on a directory of HTML files. See the top of this file for more info."""
-    assert special == None or special in ["manual", "reference"]
-    reference = (special == "reference")
-    manual = (special == "manual")
-    base = ireplace(outputfile, ".chm", "")
-    if os.path.isfile(base + ".chm"): os.remove(base + ".chm")
-    # Create the hhp file
-    hhp = open(base + ".hhp", "w")
-    hhp.write("[OPTIONS]\n")
-    hhp.write(OPTIONBLOCK % (base + ".chm", base, urldecode(os.path.join(dirname, "index.html")), base, title))
-    hhp.write("\n[FILES]\n")
-    # Create the TOC file and Index file
-    hhk = open(base + ".hhk", "w")
-    hhc = open(base + ".hhc", "w")
-    hhk.write(HTMLBLOCK)
-    hhc.write(HTMLBLOCK)
-    # The manual should be treated as a special case.
-    if manual:
-        hhc.write("      <li><object type=\"text/sitemap\">\n")
-        hhc.write("        <param name=\"Name\" value=\"Main Page\">\n")
-        hhc.write("        <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, "index.html")))
-        hhc.write("      </object>\n")
-        for item in parseManualTOC(dirname + "/index.html"):
-            hhc.write(treeToHTML(item, dirname, "      "))
-        for i in os.listdir(dirname):
-            hhp.write(os.path.join(dirname, i) + "\n")
-            if i != "index.html":
-                hhk.write("      <li><object type=\"text/sitemap\">\n")
-                hhk.write("        <param name=\"Name\" value=\"%s\">\n" % ireplace(urldecode(i).replace(".1", "").replace("_", " ").replace("CXX", "C++"), ".html", "").replace("\"", "&quot;"))
-                hhk.write("        <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, i)))
-                hhk.write("      </object>\n")
-    else:
-        idt = "      "
-        # If we are writing out the reference, write some extra stuff.
-        if reference:
-            idt = "        "
-            for i, desc in REFERENCEITEMS:
-                hhk.write("      <li><object type=\"text/sitemap\">\n")
-                hhk.write("        <param name=\"Name\" value=\"%s\">\n" % desc.replace("\"", "&quot;"))
-                hhk.write("        <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, i)))
-                hhk.write("      </object>\n")
-                hhc.write("      <li><object type=\"text/sitemap\">\n")
-                hhc.write("        <param name=\"Name\" value=\"%s\">\n" % desc.replace("\"", "&quot;"))
-                hhc.write("        <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, i)))
-                hhc.write("      </object>\n")
-            hhc.write("      <ul>\n")
-        # Loop through the directories and write out relevant data.
-        for i in os.listdir(dirname):
-            hhp.write(os.path.join(dirname, i) + "\n")
-            if i != "index.html" and ((not reference) or (not i  in ["classes.html", "methods.html", "functions.html"])):
-                hhk.write("      <li><object type=\"text/sitemap\">\n")
-                hhk.write("        <param name=\"Name\" value=\"%s\">\n" % ireplace(urldecode(i).replace(".1", ""), ".html", "").replace("\"", "&quot;"))
-                hhk.write("        <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, i)))
-                hhk.write("      </object>\n")
-                hhc.write(idt + "<li><object type=\"text/sitemap\">\n")
-                hhc.write(idt + "  <param name=\"Name\" value=\"%s\">\n" % ireplace(urldecode(i).replace(".1", ""), ".html", "").replace("\"", "&quot;"))
-                hhc.write(idt + "  <param name=\"Local\" value=\"%s\">\n" % urldecode(os.path.join(dirname, i)))
-                hhc.write(idt + "</object>\n")
-    # Close the files.
-    if reference: hhc.write("      </ul>\n")
-    hhk.write("    </ul>\n  </body>\n</html>")
-    hhc.write("    </ul>\n  </body>\n</html>")
-    hhk.close()
-    hhc.close()
-    hhp.close()
-    # Now, execute the command to compile the files.
-    if "PROGRAMFILES" in os.environ and os.path.isdir("%s\\HTML Help Workshop" % os.environ["PROGRAMFILES"]):
-        cmd = "\"%s\\HTML Help Workshop\\hhc.exe\" %s.hhp" % (os.environ["PROGRAMFILES"], base)
-    elif os.path.isdir("C:\\Program Files\\HTML Help Workshop"):
-        cmd = "\"C:\\Program Files\\HTML Help Workshop\\hhc.exe\" %s.hhp" % base
-    else:
-        cmd = "hhc \"%s.hhp\"" % base
-    print(cmd)
-    os.system(cmd)
-    if not KEEPTEMP:
-        if os.path.isfile("%s.hhp" % base): os.remove("%s.hhp" % base)
-        if os.path.isfile("%s.hhc" % base): os.remove("%s.hhc" % base)
-        if os.path.isfile("%s.hhk" % base): os.remove("%s.hhk" % base)
-        if os.path.isfile("%s.chw" % base): os.remove("%s.chw" % base)
-    if not os.path.isfile(base + ".chm"):
-        print("An error has occurred!")
-        if __name__ == "__main__":
-            exit(1)
-        else:
-            return False
-    if __name__ != "__main__":
-        return True
-
-def makeManualCHM(outputfile, dirname, title):
-    """Same as makeCHM, but suitable for converting the Panda3D manual."""
-    return makeCHM(outputfile, dirname, title, special = "manual")
-
-def makeReferenceCHM(outputfile, dirname, title):
-    """Same as makeCHM, but converts a structure resembling that of the Panda3D reference."""
-    return makeCHM(outputfile, dirname, title, special = "reference")
-
-if __name__ == "__main__":
-    # Extract a version number, if we have one.
-    VERSION = None
-    try:
-        f = file("built/include/pandaVersion.h","r")
-        pattern = re.compile('^\\s*[#]\\s*define\\s+PANDA_VERSION_STR\\s+["]([0-9.]+)["]')
-        for line in f:
-            match = pattern.match(line,0)
-            if (match):
-                VERSION = match.group(1)
-                break
-        f.close()
-    except:
-        # If not, we don't care at all.
-        pass
-
-    # Now, make CHM's for both the manual and reference, if we have them.
-    for lang in ["python", "cxx"]:
-        if not os.path.isdir("manual-" + lang):
-            print("No directory named 'manual-%s' found" % lang)
-        else:
-            print("Making CHM file for manual-%s..." % lang)
-            if VERSION == None:
-                makeManualCHM("manual-%s.chm" % lang, "manual-" + lang, "Panda3D Manual")
-            else:
-                makeManualCHM("manual-%s-%s.chm" % (VERSION, lang), "manual-" + lang, "Panda3D %s Manual" % VERSION)
-
-        if not os.path.isdir("reference-" + lang):
-            print("No directory named 'reference-%s' found" % lang)
-        else:
-            print("Making CHM file for reference-%s..." % lang)
-            if VERSION == None:
-                makeReferenceCHM("reference-%s.chm" % lang, "reference-" + lang, "Panda3D Reference")
-            else:
-                makeReferenceCHM("reference-%s-%s.chm" % (VERSION, lang), "reference-" + lang, "Panda3D %s Reference" % VERSION)
-
-    print("Done!")
-

makepanda/makedocs.bat

@@ -1,29 +0,0 @@
-@echo off
-
-REM
-REM Verify that we can find the 'makedocs' python script
-REM and the python interpreter.  If we can find both, then
-REM run 'makedocs'.
-REM
-
-set thirdparty=thirdparty
-if defined MAKEPANDA_THIRDPARTY set thirdparty=%MAKEPANDA_THIRDPARTY%
-
-if not exist makepanda\makedocs.py goto :missing1
-if not exist %thirdparty%\win-python\python.exe goto :missing2
-%thirdparty%\win-python\python.exe makepanda\makedocs.py %*
-goto done
-
-:missing1
-  echo You need to change directory to the root of the panda source tree
-  echo before invoking makedocs.
-  goto done
-
-:missing2
-  echo You seem to be missing the 'thirdparty' directory.  You probably checked
-  echo the source code out from GitHub.  The GitHub repository is
-  echo missing the 'thirdparty' directory.  You will need to supplement the
-  echo code by downloading the 'thirdparty' directory from www.panda3d.org
-  goto done
-
-:done

makepanda/makedocs.py

@@ -1,77 +0,0 @@
-########################################################################
-##
-## Win32 Usage: makepanda\makedocs.bat
-## Linux Usage: makepanda/makedocs.py
-##
-########################################################################
-
-import sys,os,re
-sys.path = ["direct/src/directscripts"] + sys.path
-import gendocs
-
-########################################################################
-##
-## Some handy utility functions.
-##
-########################################################################
-
-def MakeDirectory(path):
-    if os.path.isdir(path): return 0
-    os.mkdir(path)
-
-########################################################################
-##
-## Read the version number from built/include/pandaVersion.h
-##
-########################################################################
-
-VERSION="0.0.0"
-try:
-    f = file("built/include/pandaVersion.h","r")
-    pattern = re.compile('^\s*[#]\s*define\s+PANDA_VERSION_STR\s+["]([0-9.]+)["]')
-    for line in f:
-        match = pattern.match(line,0)
-        if (match):
-            VERSION = match.group(1)
-            break
-    f.close()
-except: sys.exit("Cannot read version number from built/include/pandaVersion.h")
-
-print "Generating docs for "+VERSION
-
-########################################################################
-##
-## Make sure panda has been built.
-##
-########################################################################
-
-if (os.path.isfile("built/pandac/input/libpgraph.in")==0) or (os.path.isfile("built/pandac/input/libputil.in")==0):
-    sys.exit("Cannot read the interrogate-output files in built/pandac/input")
-
-########################################################################
-##
-## Generate the PHP version.
-##
-## The manual is in the form of a bunch of HTML files that can be
-## included by a PHP script called "/apiref.php".
-##
-########################################################################
-
-MakeDirectory("referphp")
-gendocs.generate(VERSION, "built/pandac/input", "direct", "referphp", "", "", "/apiref.php?page=", "")
-
-########################################################################
-##
-## Generate the HTML version.
-##
-## The manual is in the form of a bunch of standalone HTML files
-## that contain links to each other.
-##
-########################################################################
-
-HEADER = "<html><head></head><body>\n"
-FOOTER = "</body></html>\n"
-
-MakeDirectory("reference")
-gendocs.generate(VERSION, "built/pandac/input", "direct", "reference", HEADER, FOOTER, "", ".html")
-