Added docstrings.

Added an optional third parameter giving the purported filename for
error messages from the module.

Append a newline to the code string if needed.

Lib/py_compile.py

@@ -1,37 +1,68 @@
-# Routine to "compile" a .py file to a .pyc file.
+"""Routine to "compile" a .py file to a .pyc (or .pyo) file.
-# This has intimate knowledge of how Python/import.c does it.
+
-# By Sjoerd Mullender (I forced him to write it :-).
+This module has intimate knowledge of the format of .pyc files.
+"""
 
 import imp
 MAGIC = imp.get_magic()
 
 def wr_long(f, x):
-	f.write(chr( x        & 0xff))
+    "Internal; write a 32-bit int to a file in little-endian order."
-	f.write(chr((x >> 8)  & 0xff))
+    f.write(chr( x        & 0xff))
-	f.write(chr((x >> 16) & 0xff))
+    f.write(chr((x >> 8)  & 0xff))
-	f.write(chr((x >> 24) & 0xff))
+    f.write(chr((x >> 16) & 0xff))
+    f.write(chr((x >> 24) & 0xff))
 
-def compile(file, cfile = None):
+def compile(file, cfile=None, dfile=None):
-	import os, marshal, __builtin__
+    """Byte-compile one Python source file to Python bytecode.
-	f = open(file)
+
-	try:
+    Arguments:
-	    timestamp = os.fstat(file.fileno())
+
-	except AttributeError:
+    file:  source filename
-	    timestamp = long(os.stat(file)[8])
+    cfile: target filename; defaults to source with 'c' or 'o' appended
-	codestring = f.read()
+	   ('c' normally, 'o' in optimizing mode, giving .pyc or .pyo)
-	f.close()
+    dfile: purported filename; defaults to source (this is the filename
-	codeobject = __builtin__.compile(codestring, file, 'exec')
+	   that will show up in error messages)
-	if not cfile:
+
-		cfile = file + (__debug__ and 'c' or 'o')
+    Note that it isn't necessary to byte-compile Python modules for
-	fc = open(cfile, 'wb')
+    execution efficiency -- Python itself byte-compiles a module when
-	fc.write('\0\0\0\0')
+    it is loaded, and if it can, writes out the bytecode to the
-	wr_long(fc, timestamp)
+    corresponding .pyc (or .pyo) file.
-	marshal.dump(codeobject, fc)
+
-	fc.flush()
+    However, if a Python installation is shared between users, it is a
-	fc.seek(0, 0)
+    good idea to byte-compile all modules upon installation, since
-	fc.write(MAGIC)
+    other users may not be able to write in the source directories,
-	fc.close()
+    and thus they won't be able to write the .pyc/.pyo file, and then
-	if os.name == 'mac':
+    they would be byte-compiling every module each time it is loaded.
-		import macfs
+    This can slow down program start-up considerably.
-		macfs.FSSpec(cfile).SetCreatorType('Pyth', 'PYC ')
+
-		macfs.FSSpec(file).SetCreatorType('Pyth', 'TEXT')
+    See compileall.py for a script/module that uses this module to
+    byte-compile all installed files (or all files in selected
+    directories).
+
+    """
+    import os, marshal, __builtin__
+    f = open(file)
+    try:
+	timestamp = os.fstat(file.fileno())
+    except AttributeError:
+	timestamp = long(os.stat(file)[8])
+    codestring = f.read()
+    f.close()
+    if codestring and codestring[-1] != '\n':
+	coestring = codestring + '\n'
+    codeobject = __builtin__.compile(codestring, dfile or file, 'exec')
+    if not cfile:
+	cfile = file + (__debug__ and 'c' or 'o')
+    fc = open(cfile, 'wb')
+    fc.write('\0\0\0\0')
+    wr_long(fc, timestamp)
+    marshal.dump(codeobject, fc)
+    fc.flush()
+    fc.seek(0, 0)
+    fc.write(MAGIC)
+    fc.close()
+    if os.name == 'mac':
+	import macfs
+	macfs.FSSpec(cfile).SetCreatorType('Pyth', 'PYC ')
+	macfs.FSSpec(file).SetCreatorType('Pyth', 'TEXT')