public static final String LIBRARY_URL = "http://docs.python.org/library/";

public static final String TUTORIAL_URL = "http://docs.python.org/tutorial/";

public static final String REFERENCE_URL = "http://docs.python.org/reference/";

public static final String DATAMODEL_URL = "http://docs.python.org/reference/datamodel#";

public static NUrl newLibUrl(String module, String name) {

return newLibUrl(module + ".html#" + name);

}

public static NUrl newLibUrl(String path) {

if (!path.endsWith(".html")) {

path += ".html";

}

return new NUrl(LIBRARY_URL + path);

}

public static NUrl newRefUrl(String path) {

return new NUrl(REFERENCE_URL + path);

}

public static NUrl newDataModelUrl(String path) {

return new NUrl(DATAMODEL_URL + path);

}

public static NUrl newTutUrl(String path) {

return new NUrl(TUTORIAL_URL + path);

}

// XXX: need to model "types" module and reconcile with these types

public NModuleType Builtin;

public NClassType Object;

public NClassType Type;

public NClassType None;

public NClassType BaseNum; // BaseNum models int, float and long

public NClassType BaseComplex;

public NClassType BaseBool;

public NClassType BaseStr;

public NClassType BaseList;

public NClassType BaseArray;

public NClassType BaseDict;

public NClassType BaseTuple;

public NClassType BaseModule;

public NClassType BaseFile;

public NClassType BaseException;

public NClassType BaseStruct;

public NClassType BaseFunction; // models functions, lambas and methods

public NClassType BaseClass; // models classes and instances

public NClassType Datetime_datetime;

public NClassType Datetime_date;

public NClassType Datetime_time;

public NClassType Datetime_timedelta;

public NClassType Datetime_tzinfo;

public NClassType Time_struct_time;

Scope globaltable;

Scope moduleTable;

String[] builtin_exception_types = {

"ArithmeticError", "AssertionError", "AttributeError", "BaseException",

"BytesWarning", "Exception", "DeprecationWarning", "EOFError",

"EnvironmentError", "FloatingPointError", "FutureWarning",

"GeneratorExit", "IOError", "ImportError", "ImportWarning",

"IndentationError", "IndexError", "KeyError", "KeyboardInterrupt",

"LookupError", "MemoryError", "NameError", "NotImplemented",

"NotImplementedError", "OSError", "OverflowError",

"PendingDeprecationWarning", "ReferenceError", "RuntimeError",

"RuntimeWarning", "StandardError", "StopIteration", "SyntaxError",

"SyntaxWarning", "SystemError", "SystemExit", "TabError", "TypeError",

"UnboundLocalError", "UnicodeDecodeError", "UnicodeEncodeError",

"UnicodeError", "UnicodeTranslateError", "UnicodeWarning",

"UserWarning", "ValueError", "Warning", "ZeroDivisionError"

};

Set<NType> nativeTypes = new HashSet<NType>();

NClassType newClass(String name, Scope table) {

return newClass(name, table, null);

}

NClassType newClass(String name, Scope table,

NClassType superClass, NClassType... moreSupers) {

NClassType t = new NClassType(name, table, superClass);

for (NClassType c : moreSupers) {

t.addSuper(c);

}

nativeTypes.add(t);

return t;

}

NModuleType newModule(String name) {

NModuleType mt = new NModuleType(name, null, globaltable);

nativeTypes.add(mt);

return mt;

}

NUnknownType unknown() {

NUnknownType t = new NUnknownType();

nativeTypes.add(t);

return t;

}

NClassType newException(String name, Scope t) {

return newClass(name, t, BaseException);

}

NFuncType newFunc() {

NFuncType t = new NFuncType();

nativeTypes.add(t);

return t;

}

NFuncType newFunc(NType type) {

NFuncType t = new NFuncType(type);

nativeTypes.add(t);

return t;

}

NListType newList() {

return newList(unknown());

}

NListType newList(NType type) {

NListType t = new NListType(type);

nativeTypes.add(t);

return t;

}

NDictType newDict(NType ktype, NType vtype) {

NDictType t = new NDictType(ktype, vtype);

nativeTypes.add(t);

return t;

}

NTupleType newTuple(NType... types) {

NTupleType t = new NTupleType(types);

nativeTypes.add(t);

return t;

}

NUnionType newUnion(NType... types) {

NUnionType t = new NUnionType(types);

nativeTypes.add(t);

return t;

}

String[] list(String... names) {

return names;

}

private abstract class NativeModule {

protected String name;

protected NModuleType module;

protected Scope table; // the module's symbol table

NativeModule(String name) {

this.name = name;

modules.put(name, this);

}

/** Lazily load the module. */

NModuleType getModule() {

if (module == null) {

createModuleType();

initBindings();

}

return module;

}

protected abstract void initBindings();

protected void createModuleType() {

if (module == null) {

module = newModule(name);

table = module.getTable();

moduleTable.put(name, liburl(), module, MODULE);

}

}

protected NBinding update(String name, NUrl url, NType type, NBinding.Kind kind) {

return table.update(name, url, type, kind);

}

protected NBinding addClass(String name, NUrl url, NType type) {

return table.update(name, url, type, CLASS);

}

protected NBinding addMethod(String name, NUrl url, NType type) {

return table.update(name, url, type, METHOD);

}

protected NBinding addFunction(String name, NUrl url, NType type) {

return table.update(name, url, newFunc(type), FUNCTION);

}

// don't use this unless you're sure it's OK to share the type object

protected void addFunctions_beCareful(NType type, String... names) {

for (String name : names) {

addFunction(name, liburl(), type);

}

}

protected void addNoneFuncs(String... names) {

addFunctions_beCareful(None, names);

}

protected void addNumFuncs(String... names) {

addFunctions_beCareful(BaseNum, names);

}

protected void addStrFuncs(String... names) {

addFunctions_beCareful(BaseStr, names);

}

protected void addUnknownFuncs(String... names) {

for (String name : names) {

addFunction(name, liburl(), unknown());

}

}

protected NBinding addAttr(String name, NUrl url, NType type) {

return table.update(name, url, type, ATTRIBUTE);

}

// don't use this unless you're sure it's OK to share the type object

protected void addAttributes_beCareful(NType type, String... names) {

for (String name : names) {

addAttr(name, liburl(), type);

}

}

protected void addNumAttrs(String... names) {

addAttributes_beCareful(BaseNum, names);

}

protected void addStrAttrs(String... names) {

addAttributes_beCareful(BaseStr, names);

}

protected void addUnknownAttrs(String... names) {

for (String name : names) {

addAttr(name, liburl(), unknown());

}

}

protected NUrl liburl() {

return newLibUrl(name);

}

protected NUrl liburl(String anchor) {

return newLibUrl(name, anchor);

}

@Override

public String toString() {

return module == null

? "<Non-loaded builtin module '" + name + "'>"

: "<NativeModule:" + module + ">";

}

}

/**

private Map<String, NativeModule> modules = new HashMap<String, NativeModule>();

public Builtins(Scope globals, Scope modules) {

globaltable = globals;

moduleTable = modules;

buildTypes();

}

private void buildTypes() {

new BuiltinsModule();

Scope bt = Builtin.getTable();

Object = newClass("object", bt);

None = newClass("None", bt);

Type = newClass("type", bt, Object);

BaseTuple = newClass("tuple", bt, Object);

BaseList = newClass("list", bt, Object);

BaseArray = newClass("array", bt);

BaseDict = newClass("dict", bt, Object);

BaseNum = newClass("float", bt, Object);

BaseComplex = newClass("complex", bt, Object);

BaseBool = newClass("bool", bt, BaseNum); // XXX: useful?

BaseStr = newClass("str", bt, Object);

BaseModule = newClass("module", bt);

BaseFile = newClass("file", bt, Object);

BaseFunction = newClass("function", bt, Object);

BaseClass = newClass("classobj", bt, Object);

}

void init() {

buildObjectType();

buildTupleType();

buildArrayType();

buildListType();

buildDictType();

buildNumTypes();

buildStrType();

buildModuleType();

buildFileType();

buildFunctionType();

buildClassType();

modules.get("__builtin__").initBindings(); // eagerly load these bindings

new ArrayModule();

new AudioopModule();

new BinasciiModule();

new Bz2Module();

new CPickleModule();

new CStringIOModule();

new CMathModule();

new CollectionsModule();

new CryptModule();

new CTypesModule();

new DatetimeModule();

new DbmModule();

new ErrnoModule();

new ExceptionsModule();

new FcntlModule();

new FpectlModule();

new GcModule();

new GdbmModule();

new GrpModule();

new ImpModule();

new ItertoolsModule();

new MarshalModule();

new MathModule();

new Md5Module();

new MmapModule();

new NisModule();

new OperatorModule();

new OsModule();

new ParserModule();

new PosixModule();

new PwdModule();

new PyexpatModule();

new ReadlineModule();

new ResourceModule();

new SelectModule();

new SignalModule();

new ShaModule();

new SpwdModule();

new StropModule();

new StructModule();

new SysModule();

new SyslogModule();

new TermiosModule();

new ThreadModule();

new TimeModule();

new UnicodedataModule();

new ZipimportModule();

new ZlibModule();

}

/**

public NModuleType get(String name) {

if (name.indexOf(".") == -1) { // unqualified

return getModule(name);

}

String[] mods = name.split("\\.");

NType type = getModule(mods[0]);

if (type == null) {

return null;

}

for (int i = 1; i < mods.length; i++) {

type = type.getTable().lookupType(mods[i]);

if (!(type instanceof NModuleType)) {

return null;

}

}

return (NModuleType)type;

}

private NModuleType getModule(String name) {

NativeModule wrap = modules.get(name);

return wrap == null ? null : wrap.getModule();

}

public boolean isNative(NType type) {

return nativeTypes.contains(type);

}

void buildObjectType() {

String[] obj_methods = {

"__delattr__", "__format__", "__getattribute__", "__hash__",

"__init__", "__new__", "__reduce__", "__reduce_ex__",

"__repr__", "__setattr__", "__sizeof__", "__str__", "__subclasshook__"

};

for (String m : obj_methods) {

Object.getTable().update(m, newLibUrl("stdtypes"), newFunc(), METHOD);

}

Object.getTable().update("__doc__", newLibUrl("stdtypes"), BaseStr, CLASS);

Object.getTable().update("__class__", newLibUrl("stdtypes"), unknown(), CLASS);

}

void buildTupleType() {

Scope bt = BaseTuple.getTable();

String[] tuple_methods = {

"__add__", "__contains__", "__eq__", "__ge__", "__getnewargs__",

"__gt__", "__iter__", "__le__", "__len__", "__lt__", "__mul__",

"__ne__", "__new__", "__rmul__", "count", "index"

};

for (String m : tuple_methods) {

bt.update(m, newLibUrl("stdtypes"), newFunc(), METHOD);

}

NBinding b = bt.update("__getslice__", newDataModelUrl("object.__getslice__"),

newFunc(), METHOD);

b.markDeprecated();

bt.update("__getitem__", newDataModelUrl("object.__getitem__"), newFunc(), METHOD);

bt.update("__iter__", newDataModelUrl("object.__iter__"), newFunc(), METHOD);

}

void buildArrayType() {

String[] array_methods_none = {

"append", "buffer_info", "byteswap", "extend", "fromfile",

"fromlist", "fromstring", "fromunicode", "index", "insert", "pop",

"read", "remove", "reverse", "tofile", "tolist", "typecode", "write"

};

for (String m : array_methods_none) {

BaseArray.getTable().update(m, newLibUrl("array"), newFunc(None), METHOD);

}

String[] array_methods_num = { "count", "itemsize", };

for (String m : array_methods_num) {

BaseArray.getTable().update(m, newLibUrl("array"), newFunc(BaseNum), METHOD);

}

String[] array_methods_str = { "tostring", "tounicode", };

for (String m : array_methods_str) {

BaseArray.getTable().update(m, newLibUrl("array"), newFunc(BaseStr), METHOD);

}

}

void buildListType() {

BaseList.getTable().update("__getslice__", newDataModelUrl("object.__getslice__"),

newFunc(BaseList), METHOD);

BaseList.getTable().update("__getitem__", newDataModelUrl("object.__getitem__"),

newFunc(BaseList), METHOD);

BaseList.getTable().update("__iter__", newDataModelUrl("object.__iter__"),

newFunc(BaseList), METHOD);

String[] list_methods_none = {

"append", "extend", "index", "insert", "pop", "remove", "reverse", "sort"

};

for (String m : list_methods_none) {

BaseList.getTable().update(m, newLibUrl("stdtypes"), newFunc(None), METHOD);

}

String[] list_methods_num = { "count" };

for (String m : list_methods_num) {

BaseList.getTable().update(m, newLibUrl("stdtypes"), newFunc(BaseNum), METHOD);

}

}

NUrl numUrl() {

return newLibUrl("stdtypes", "typesnumeric");

}

void buildNumTypes() {

Scope bnt = BaseNum.getTable();

String[] num_methods_num = {

"__abs__", "__add__", "__coerce__", "__div__", "__divmod__",

"__eq__", "__float__", "__floordiv__", "__format__",

"__ge__", "__getformat__", "__gt__", "__int__",

"__le__", "__long__", "__lt__", "__mod__", "__mul__", "__ne__",

"__neg__", "__new__", "__nonzero__", "__pos__", "__pow__",

"__radd__", "__rdiv__", "__rdivmod__", "__rfloordiv__", "__rmod__",

"__rmul__", "__rpow__", "__rsub__", "__rtruediv__", "__setformat__",

"__sub__", "__truediv__", "__trunc__", "as_integer_ratio",

"fromhex", "is_integer"

};

for (String m : num_methods_num) {

bnt.update(m, numUrl(), newFunc(BaseNum), METHOD);

}

bnt.update("__getnewargs__", numUrl(), newFunc(newTuple(BaseNum)), METHOD);

bnt.update("hex", numUrl(), newFunc(BaseStr), METHOD);

bnt.update("conjugate", numUrl(), newFunc(BaseComplex), METHOD);

Scope bct = BaseComplex.getTable();

String[] complex_methods = {

"__abs__", "__add__", "__div__", "__divmod__",

"__float__", "__floordiv__", "__format__", "__getformat__", "__int__",

"__long__", "__mod__", "__mul__", "__neg__", "__new__",

"__pos__", "__pow__", "__radd__", "__rdiv__", "__rdivmod__",

"__rfloordiv__", "__rmod__", "__rmul__", "__rpow__", "__rsub__",

"__rtruediv__", "__sub__", "__truediv__", "conjugate"

};

for (String c : complex_methods) {

bct.update(c, numUrl(), newFunc(BaseComplex), METHOD);

}

String[] complex_methods_num = {

"__eq__", "__ge__", "__gt__", "__le__","__lt__", "__ne__",

"__nonzero__", "__coerce__"

};

for (String cn : complex_methods_num) {

bct.update(cn, numUrl(), newFunc(BaseNum), METHOD);

}

bct.update("__getnewargs__", numUrl(), newFunc(newTuple(BaseComplex)), METHOD);

bct.update("imag", numUrl(), BaseNum, ATTRIBUTE);

bct.update("real", numUrl(), BaseNum, ATTRIBUTE);

}

void buildStrType() {

BaseStr.getTable().update("__getslice__", newDataModelUrl("object.__getslice__"),

newFunc(BaseStr), METHOD);

BaseStr.getTable().update("__getitem__", newDataModelUrl("object.__getitem__"),

newFunc(BaseStr), METHOD);

BaseStr.getTable().update("__iter__", newDataModelUrl("object.__iter__"),

newFunc(BaseStr), METHOD);

String[] str_methods_str = {

"capitalize", "center", "decode", "encode", "expandtabs", "format",

"index", "join", "ljust", "lower", "lstrip", "partition", "replace",

"rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip",

"strip", "swapcase", "title", "translate", "upper", "zfill"

};

for (String m : str_methods_str) {

BaseStr.getTable().update(m, newLibUrl("stdtypes.html#str." + m),

newFunc(BaseStr), METHOD);

}

String[] str_methods_num = {

"count", "isalnum", "isalpha", "isdigit", "islower", "isspace",

"istitle", "isupper", "find", "startswith", "endswith"

};

for (String m : str_methods_num) {

BaseStr.getTable().update(m, newLibUrl("stdtypes.html#str." + m),

newFunc(BaseNum), METHOD);

}

String[] str_methods_list = { "split", "splitlines" };

for (String m : str_methods_list) {

BaseStr.getTable().update(m, newLibUrl("stdtypes.html#str." + m),

newFunc(newList(BaseStr)), METHOD);

}

BaseStr.getTable().update("partition", newLibUrl("stdtypes"),

newFunc(newTuple(BaseStr)), METHOD);

}

void buildModuleType() {

String[] attrs = { "__doc__", "__file__", "__name__", "__package__" };

for (String m : attrs) {

BaseModule.getTable().update(m, newTutUrl("modules.html"), BaseStr, ATTRIBUTE);

}

BaseModule.getTable().update("__dict__", newLibUrl("stdtypes", "modules"),

newDict(BaseStr, unknown()), ATTRIBUTE);

}

void buildDictType() {

String url = "datastructures.html#dictionaries";

Scope bt = BaseDict.getTable();

bt.update("__getitem__", newTutUrl(url), newFunc(), METHOD);

bt.update("__iter__", newTutUrl(url), newFunc(), METHOD);

bt.update("get", newTutUrl(url), newFunc(), METHOD);

bt.update("items", newTutUrl(url),

newFunc(newList(newTuple(unknown(), unknown()))), METHOD);

bt.update("keys", newTutUrl(url), newFunc(BaseList), METHOD);

bt.update("values", newTutUrl(url), newFunc(BaseList), METHOD);

String[] dict_method_unknown = {

"clear", "copy", "fromkeys", "get", "iteritems", "iterkeys",

"itervalues", "pop", "popitem", "setdefault", "update"

};

for (String m : dict_method_unknown) {

bt.update(m, newTutUrl(url), newFunc(), METHOD);

}

String[] dict_method_num = { "has_key" };

for (String m : dict_method_num) {

bt.update(m, newTutUrl(url), newFunc(BaseNum), METHOD);

}

}

void buildFileType() {

String url = "stdtypes.html#bltin-file-objects";

Scope table = BaseFile.getTable();

String[] methods_unknown = {

"__enter__", "__exit__", "__iter__", "flush", "readinto", "truncate"

};

for (String m : methods_unknown) {

table.update(m, newLibUrl(url), newFunc(), METHOD);

}

String[] methods_str = { "next", "read", "readline" };

for (String m : methods_str) {

table.update(m, newLibUrl(url), newFunc(BaseStr), METHOD);

}

String[] num = { "fileno", "isatty", "tell" };

for (String m : num) {

table.update(m, newLibUrl(url), newFunc(BaseNum), METHOD);

}

String[] methods_none = { "close", "seek", "write", "writelines" };

for (String m : methods_none) {

table.update(m, newLibUrl(url), newFunc(None), METHOD);

}

table.update("readlines", newLibUrl(url), newFunc(newList(BaseStr)), METHOD);

table.update("xreadlines", newLibUrl(url), newFunc(BaseFile), METHOD);

table.update("closed", newLibUrl(url), BaseNum, ATTRIBUTE);

table.update("encoding", newLibUrl(url), BaseStr, ATTRIBUTE);

table.update("errors", newLibUrl(url), unknown(), ATTRIBUTE);

table.update("mode", newLibUrl(url), BaseNum, ATTRIBUTE);

table.update("name", newLibUrl(url), BaseStr, ATTRIBUTE);

table.update("softspace", newLibUrl(url), BaseNum, ATTRIBUTE);

table.update("newlines", newLibUrl(url), newUnion(BaseStr, newTuple(BaseStr)), ATTRIBUTE);

}

private NBinding synthetic(Scope table, String n, NUrl url, NType type, NBinding.Kind k) {

NBinding b = table.update(n, url, type, k);

b.markSynthetic();

return b;

}

void buildFunctionType() {

Scope t = BaseFunction.getTable();

for (String s : list("func_doc", "__doc__", "func_name", "__name__", "__module__")) {

t.update(s, new NUrl(DATAMODEL_URL), BaseStr, ATTRIBUTE);

}

NBinding b = synthetic(t, "func_closure", new NUrl(DATAMODEL_URL), newTuple(), ATTRIBUTE);

b.markReadOnly();

synthetic(t, "func_code", new NUrl(DATAMODEL_URL), unknown(), ATTRIBUTE);

synthetic(t, "func_defaults", new NUrl(DATAMODEL_URL), newTuple(), ATTRIBUTE);

synthetic(t, "func_globals", new NUrl(DATAMODEL_URL),

new NDictType(BaseStr, new NUnknownType()), ATTRIBUTE);

synthetic(t, "func_dict", new NUrl(DATAMODEL_URL),

new NDictType(BaseStr, new NUnknownType()), ATTRIBUTE);

// Assume any function can become a method, for simplicity.

for (String s : list("__func__", "im_func")) {

synthetic(t, s, new NUrl(DATAMODEL_URL), new NFuncType(), METHOD);

}

}

// XXX: finish wiring this up. NClassType needs to inherit from it somehow,

// so we can remove the per-instance attributes from NClassDef.

void buildClassType() {

Scope t = BaseClass.getTable();

for (String s : list("__name__", "__doc__", "__module__")) {

synthetic(t, s, new NUrl(DATAMODEL_URL), BaseStr, ATTRIBUTE);

}

synthetic(t, "__dict__", new NUrl(DATAMODEL_URL),

new NDictType(BaseStr, unknown()), ATTRIBUTE);

}

class BuiltinsModule extends NativeModule {

public BuiltinsModule() {

super("__builtin__");

Builtin = module = newModule(name);

table = module.getTable();

}

@Override

public void initBindings() {

moduleTable.put(name, liburl(), module, MODULE);

table.addSuper(BaseModule.getTable());

addClass("None", newLibUrl("constants"), None);

addClass("bool", newLibUrl("functions", "bool"), BaseBool);

addClass("complex", newLibUrl("functions", "complex"), BaseComplex);

addClass("dict", newLibUrl("stdtypes", "typesmapping"), BaseDict);

addClass("file", newLibUrl("functions", "file"), BaseFile);

addClass("float", newLibUrl("functions", "float"), BaseNum);

addClass("int", newLibUrl("functions", "int"), BaseNum);

addClass("list", newLibUrl("functions", "list"), BaseList);

addClass("long", newLibUrl("functions", "long"), BaseNum);

addClass("object", newLibUrl("functions", "object"), Object);

addClass("str", newLibUrl("functions", "str"), BaseStr);

addClass("tuple", newLibUrl("functions", "tuple"), BaseTuple);

addClass("type", newLibUrl("functions", "type"), Type);

// XXX: need to model the following as built-in class types:

// basestring, bool, buffer, frozenset, property, set, slice,

// staticmethod, super and unicode

String[] builtin_func_unknown = {

"apply", "basestring", "callable", "classmethod",

"coerce", "compile", "copyright", "credits", "delattr", "enumerate",

"eval", "execfile", "exit", "filter", "frozenset", "getattr",

"help", "input", "int", "intern", "iter", "license", "long",

"property", "quit", "raw_input", "reduce", "reload", "reversed",

"set", "setattr", "slice", "sorted", "staticmethod", "super",

"type", "unichr", "unicode",

};

for (String f : builtin_func_unknown) {

addFunction(f, newLibUrl("functions.html#" + f), unknown());

}

String[] builtin_func_num = {

"abs", "all", "any", "cmp", "coerce", "divmod",

"hasattr", "hash", "id", "isinstance", "issubclass", "len", "max",

"min", "ord", "pow", "round", "sum"

};

for (String f : builtin_func_num) {

addFunction(f, newLibUrl("functions.html#" + f), BaseNum);

}

for (String f : list("hex", "oct", "repr", "chr")) {

addFunction(f, newLibUrl("functions.html#" + f), BaseStr);

}

addFunction("dir", newLibUrl("functions", "dir"), newList(BaseStr));

addFunction("map", newLibUrl("functions", "map"), newList(unknown()));

addFunction("range", newLibUrl("functions", "range"), newList(BaseNum));

addFunction("xrange", newLibUrl("functions", "range"), newList(BaseNum));

addFunction("buffer", newLibUrl("functions", "buffer"), newList(unknown()));

addFunction("zip", newLibUrl("functions", "zip"), newList(newTuple(unknown())));

for (String f : list("globals", "vars", "locals")) {

addFunction(f, newLibUrl("functions.html#" + f), newDict(BaseStr, unknown()));

}

for (String f : builtin_exception_types) {

addClass(f, newDataModelUrl("types"), newClass(f, globaltable, Object));

}

BaseException = (NClassType)table.lookup("BaseException").getType();

for (String f : list("True", "False", "None", "Ellipsis")) {

addAttr(f, newDataModelUrl("types"), unknown());

}

addFunction("open", newTutUrl("inputoutput.html#reading-and-writing-files"), BaseFile);

addFunction("__import__", newLibUrl("functions"), newModule("<?>"));

globaltable.put("__builtins__", liburl(), module, ATTRIBUTE);

globaltable.merge(table);

}

}

class ArrayModule extends NativeModule {

public ArrayModule() {

super("array");

}

@Override

public void initBindings() {

addClass("array", newLibUrl("array", "array"), BaseArray);

addClass("ArrayType", newLibUrl("array", "ArrayType"), BaseArray);

}

}

class AudioopModule extends NativeModule {

public AudioopModule() {

super("audioop");

}

@Override

public void initBindings() {

addClass("error", liburl(), newException("error", table));

addStrFuncs("add", "adpcm2lin", "alaw2lin", "bias", "lin2alaw", "lin2lin",

"lin2ulaw", "mul", "reverse", "tomono", "ulaw2lin");

addNumFuncs("avg", "avgpp", "cross", "findfactor", "findmax",

"getsample", "max", "maxpp", "rms");

for (String s : list("adpcm2lin", "findfit", "lin2adpcm", "minmax", "ratecv")) {

addFunction(s, liburl(), newTuple());

}

}

}

class BinasciiModule extends NativeModule {

public BinasciiModule() {

super("binascii");

}

@Override

public void initBindings() {

addStrFuncs(

"a2b_uu", "b2a_uu", "a2b_base64", "b2a_base64", "a2b_qp",

"b2a_qp", "a2b_hqx", "rledecode_hqx", "rlecode_hqx", "b2a_hqx",

"b2a_hex", "hexlify", "a2b_hex", "unhexlify");

addNumFuncs("crc_hqx", "crc32");

addClass("Error", liburl(), newException("Error", table));

addClass("Incomplete", liburl(), newException("Incomplete", table));

}

}

class Bz2Module extends NativeModule {

public Bz2Module() {

super("bz2");

}

@Override

public void initBindings() {

NClassType bz2 = newClass("BZ2File", table, BaseFile); // close enough.

addClass("BZ2File", liburl(), bz2);

NClassType bz2c = newClass("BZ2Compressor", table, Object);

bz2c.getTable().update("compress", newLibUrl("bz2", "sequential-de-compression"),

newFunc(BaseStr), METHOD);

bz2c.getTable().update("flush", newLibUrl("bz2", "sequential-de-compression"),

newFunc(None), METHOD);

addClass("BZ2Compressor", newLibUrl("bz2", "sequential-de-compression"), bz2c);

NClassType bz2d = newClass("BZ2Decompressor", table, Object);

bz2d.getTable().update("decompress", newLibUrl("bz2", "sequential-de-compression"),

newFunc(BaseStr), METHOD);

addClass("BZ2Decompressor", newLibUrl("bz2", "sequential-de-compression"), bz2d);

addFunction("compress", newLibUrl("bz2", "one-shot-de-compression"), BaseStr);

addFunction("decompress", newLibUrl("bz2", "one-shot-de-compression"), BaseStr);

}

}

class CPickleModule extends NativeModule {

public CPickleModule() {

super("cPickle");

}

@Override

protected NUrl liburl() {

return newLibUrl("pickle", "module-cPickle");

}

@Override

public void initBindings() {

addUnknownFuncs("dump", "load", "dumps", "loads");

addClass("PickleError", liburl(), newException("PickleError", table));

NClassType picklingError = newException("PicklingError", table);

addClass("PicklingError", liburl(), picklingError);

update("UnpickleableError", liburl(),

newClass("UnpickleableError", table, picklingError), CLASS);

NClassType unpicklingError = newException("UnpicklingError", table);

addClass("UnpicklingError", liburl(), unpicklingError);

update("BadPickleGet", liburl(),

newClass("BadPickleGet", table, unpicklingError), CLASS);

NClassType pickler = newClass("Pickler", table, Object);

pickler.getTable().update("dump", liburl(), newFunc(), METHOD);

pickler.getTable().update("clear_memo", liburl(), newFunc(), METHOD);

addClass("Pickler", liburl(), pickler);

NClassType unpickler = newClass("Unpickler", table, Object);

unpickler.getTable().update("load", liburl(), newFunc(), METHOD);

unpickler.getTable().update("noload", liburl(), newFunc(), METHOD);

addClass("Unpickler", liburl(), unpickler);

}

}

class CStringIOModule extends NativeModule {

public CStringIOModule() {

super("cStringIO");

}

@Override

protected NUrl liburl() {

return newLibUrl("stringio");

}

@Override

protected NUrl liburl(String anchor) {

return newLibUrl("stringio", anchor);

}

@Override

public void initBindings() {

NClassType StringIO = newClass("StringIO", table, BaseFile);

addFunction("StringIO", liburl(), StringIO);

addAttr("InputType", liburl(), Type);

addAttr("OutputType", liburl(), Type);

addAttr("cStringIO_CAPI", liburl(), unknown());

}

}

class CMathModule extends NativeModule {

public CMathModule() {

super("cmath");

}

@Override

public void initBindings() {

addFunction("phase", liburl("conversions-to-and-from-polar-coordinates"), BaseNum);

addFunction("polar", liburl("conversions-to-and-from-polar-coordinates"),

newTuple(BaseNum, BaseNum));

addFunction("rect", liburl("conversions-to-and-from-polar-coordinates"),

BaseComplex);

for (String plf : list("exp", "log", "log10", "sqrt")) {

addFunction(plf, liburl("power-and-logarithmic-functions"), BaseNum);

}

for (String tf : list("acos", "asin", "atan", "cos", "sin", "tan")) {

addFunction(tf, liburl("trigonometric-functions"), BaseNum);

}

for (String hf : list("acosh", "asinh", "atanh", "cosh", "sinh", "tanh")) {

addFunction(hf, liburl("hyperbolic-functions"), BaseComplex);

}

for (String cf : list("isinf", "isnan")) {

addFunction(cf, liburl("classification-functions"), BaseBool);

}

for (String c : list("pi", "e")) {

addAttr(c, liburl("constants"), BaseNum);

}

}

}

class CollectionsModule extends NativeModule {

public CollectionsModule() {

super("collections");

}

private NUrl abcUrl() {

return liburl("abcs-abstract-base-classes");

}

private NUrl dequeUrl() {

return liburl("deque-objects");

}

@Override

public void initBindings() {

NClassType Callable = newClass("Callable", table, Object);

Callable.getTable().update("__call__", abcUrl(), newFunc(), METHOD);

addClass("Callable", abcUrl(), Callable);

NClassType Iterable = newClass("Iterable", table, Object);

Iterable.getTable().update("__next__", abcUrl(), newFunc(), METHOD);

Iterable.getTable().update("__iter__", abcUrl(), newFunc(), METHOD);

addClass("Iterable", abcUrl(), Iterable);

NClassType Hashable = newClass("Hashable", table, Object);

Hashable.getTable().update("__hash__", abcUrl(), newFunc(BaseNum), METHOD);

addClass("Hashable", abcUrl(), Hashable);

NClassType Sized = newClass("Sized", table, Object);

Sized.getTable().update("__len__", abcUrl(), newFunc(BaseNum), METHOD);

addClass("Sized", abcUrl(), Sized);

NClassType Container = newClass("Container", table, Object);

Container.getTable().update("__contains__", abcUrl(), newFunc(BaseNum), METHOD);

addClass("Container", abcUrl(), Container);

NClassType Iterator = newClass("Iterator", table, Iterable);

addClass("Iterator", abcUrl(), Iterator);

NClassType Sequence = newClass("Sequence", table, Sized, Iterable, Container);

Sequence.getTable().update("__getitem__", abcUrl(), newFunc(), METHOD);

Sequence.getTable().update("reversed", abcUrl(), newFunc(Sequence), METHOD);

Sequence.getTable().update("index", abcUrl(), newFunc(BaseNum), METHOD);

Sequence.getTable().update("count", abcUrl(), newFunc(BaseNum), METHOD);

addClass("Sequence", abcUrl(), Sequence);

NClassType MutableSequence = newClass("MutableSequence", table, Sequence);

MutableSequence.getTable().update("__setitem__", abcUrl(), newFunc(), METHOD);

MutableSequence.getTable().update("__delitem__", abcUrl(), newFunc(), METHOD);

addClass("MutableSequence", abcUrl(), MutableSequence);