diff options
Diffstat (limited to 'lib/python2.7/py_compile.py')
| -rw-r--r-- | lib/python2.7/py_compile.py | 170 |
1 files changed, 170 insertions, 0 deletions
diff --git a/lib/python2.7/py_compile.py b/lib/python2.7/py_compile.py new file mode 100644 index 0000000..c0bc1e4 --- /dev/null +++ b/lib/python2.7/py_compile.py @@ -0,0 +1,170 @@ +"""Routine to "compile" a .py file to a .pyc (or .pyo) file. + +This module has intimate knowledge of the format of .pyc files. +""" + +import __builtin__ +import imp +import marshal +import os +import sys +import traceback + +MAGIC = imp.get_magic() + +__all__ = ["compile", "main", "PyCompileError"] + + +class PyCompileError(Exception): + """Exception raised when an error occurs while attempting to + compile the file. + + To raise this exception, use + + raise PyCompileError(exc_type,exc_value,file[,msg]) + + where + + exc_type: exception type to be used in error message + type name can be accesses as class variable + 'exc_type_name' + + exc_value: exception value to be used in error message + can be accesses as class variable 'exc_value' + + file: name of file being compiled to be used in error message + can be accesses as class variable 'file' + + msg: string message to be written as error message + If no value is given, a default exception message will be given, + consistent with 'standard' py_compile output. + message (or default) can be accesses as class variable 'msg' + + """ + + def __init__(self, exc_type, exc_value, file, msg=''): + exc_type_name = exc_type.__name__ + if exc_type is SyntaxError: + tbtext = ''.join(traceback.format_exception_only(exc_type, exc_value)) + errmsg = tbtext.replace('File "<string>"', 'File "%s"' % file) + else: + errmsg = "Sorry: %s: %s" % (exc_type_name,exc_value) + + Exception.__init__(self,msg or errmsg,exc_type_name,exc_value,file) + + self.exc_type_name = exc_type_name + self.exc_value = exc_value + self.file = file + self.msg = msg or errmsg + + def __str__(self): + return self.msg + + +def wr_long(f, x): + """Internal; write a 32-bit int to a file in little-endian order.""" + f.write(chr( x & 0xff)) + f.write(chr((x >> 8) & 0xff)) + f.write(chr((x >> 16) & 0xff)) + f.write(chr((x >> 24) & 0xff)) + +def compile(file, cfile=None, dfile=None, doraise=False): + """Byte-compile one Python source file to Python bytecode. + + Arguments: + + file: source filename + cfile: target filename; defaults to source with 'c' or 'o' appended + ('c' normally, 'o' in optimizing mode, giving .pyc or .pyo) + dfile: purported filename; defaults to source (this is the filename + that will show up in error messages) + doraise: flag indicating whether or not an exception should be + raised when a compile error is found. If an exception + occurs and this flag is set to False, a string + indicating the nature of the exception will be printed, + and the function will return to the caller. If an + exception occurs and this flag is set to True, a + PyCompileError exception will be raised. + + Note that it isn't necessary to byte-compile Python modules for + execution efficiency -- Python itself byte-compiles a module when + it is loaded, and if it can, writes out the bytecode to the + corresponding .pyc (or .pyo) file. + + However, if a Python installation is shared between users, it is a + good idea to byte-compile all modules upon installation, since + other users may not be able to write in the source directories, + and thus they won't be able to write the .pyc/.pyo file, and then + they would be byte-compiling every module each time it is loaded. + This can slow down program start-up considerably. + + See compileall.py for a script/module that uses this module to + byte-compile all installed files (or all files in selected + directories). + + """ + with open(file, 'U') as f: + try: + timestamp = long(os.fstat(f.fileno()).st_mtime) + except AttributeError: + timestamp = long(os.stat(file).st_mtime) + codestring = f.read() + try: + codeobject = __builtin__.compile(codestring, dfile or file,'exec') + except Exception,err: + py_exc = PyCompileError(err.__class__, err, dfile or file) + if doraise: + raise py_exc + else: + sys.stderr.write(py_exc.msg + '\n') + return + if cfile is None: + cfile = file + (__debug__ and 'c' or 'o') + with open(cfile, 'wb') as fc: + fc.write('\0\0\0\0') + wr_long(fc, timestamp) + marshal.dump(codeobject, fc) + fc.flush() + fc.seek(0, 0) + fc.write(MAGIC) + +def main(args=None): + """Compile several source files. + + The files named in 'args' (or on the command line, if 'args' is + not specified) are compiled and the resulting bytecode is cached + in the normal manner. This function does not search a directory + structure to locate source files; it only compiles files named + explicitly. If '-' is the only parameter in args, the list of + files is taken from standard input. + + """ + if args is None: + args = sys.argv[1:] + rv = 0 + if args == ['-']: + while True: + filename = sys.stdin.readline() + if not filename: + break + filename = filename.rstrip('\n') + try: + compile(filename, doraise=True) + except PyCompileError as error: + rv = 1 + sys.stderr.write("%s\n" % error.msg) + except IOError as error: + rv = 1 + sys.stderr.write("%s\n" % error) + else: + for filename in args: + try: + compile(filename, doraise=True) + except PyCompileError as error: + # return value to indicate at least one failure + rv = 1 + sys.stderr.write(error.msg) + return rv + +if __name__ == "__main__": + sys.exit(main()) |