Clean up tools: remove "world" and "framer", move single SSL script to scripts/.
diff --git a/Tools/framer/README.txt b/Tools/framer/README.txt
deleted file mode 100644
index 4a93a4d..0000000
--- a/Tools/framer/README.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-framer is a tool to generate boilerplate code for C extension types.
-
-The boilerplate is generated from a specification object written in
-Python. The specification uses the class statement to describe the
-extension module and any extension types it contains. From the
-specification, framer can generate all the boilerplate C code,
-including function definitions, argument handling code, and type
-objects.
diff --git a/Tools/framer/TODO.txt b/Tools/framer/TODO.txt
deleted file mode 100644
index 8586c8e..0000000
--- a/Tools/framer/TODO.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-Add spec for getsets.
-Generate a distutils setup script.
-Handle operator overloading.
-Generate traverse and clear methods for GC.
-Handle mapping, sequence, buffer protocols.
-Finish the todo list.
diff --git a/Tools/framer/example.py b/Tools/framer/example.py
deleted file mode 100644
index 8a267e9..0000000
--- a/Tools/framer/example.py
+++ /dev/null
@@ -1,126 +0,0 @@
-"""Generate the skeleton for cStringIO as an example of framer."""
-
-from framer.bases import Module, Type
-from framer.member import member
-
-class cStringIO(Module):
- """A simple fast partial StringIO replacement.
-
- This module provides a simple useful replacement for the StringIO
- module that is written in C. It does not provide the full
- generality of StringIO, but it provides enough for most
- applications and is especially useful in conjunction with the
- pickle module.
-
- Usage:
-
- from io import StringIO
-
- an_output_stream = StringIO()
- an_output_stream.write(some_stuff)
- ...
- value = an_output_stream.getvalue()
-
- an_input_stream = StringIO(a_string)
- spam = an_input_stream.readline()
- spam = an_input_stream.read(5)
- an_input_stream.seek(0) # OK, start over
- spam = an_input_stream.read() # and read it all
- """
-
- __file__ = "cStringIO.c"
-
- def StringIO(o):
- """Return a StringIO-like stream for reading or writing"""
- StringIO.pyarg = "|O"
-
- class InputType(Type):
- "Simple type for treating strings as input file streams"
-
- abbrev = "input"
-
- struct = """\
- typedef struct {
- PyObject_HEAD
- char *buf;
- int pos;
- int size;
- PyObject *pbuf;
- } InputObject;
- """
-
- def flush(self):
- """Does nothing"""
-
- def getvalue(self):
- """Get the string value.
-
- If use_pos is specified and is a true value, then the
- string returned will include only the text up to the
- current file position.
- """
-
- def isatty(self):
- """Always returns False"""
-
- def read(self, s):
- """Return s characters or the rest of the string."""
- read.pyarg = "|i"
-
- def readline(self):
- """Read one line."""
-
- def readlines(self, hint):
- """Read all lines."""
- readlines.pyarg = "|i"
-
- def reset(self):
- """Reset the file position to the beginning."""
-
- def tell(self):
- """Get the current position."""
-
- def truncate(self, pos):
- """Truncate the file at the current position."""
- truncate.pyarg = "|i"
-
- def seek(self, position, mode=0):
- """Set the current position.
-
- The optional mode argument can be 0 for absolute, 1 for relative,
- and 2 for relative to EOF. The default is absolute.
- """
- seek.pyarg = "i|i"
-
- def close(self):
- pass
-
- class OutputType(InputType):
- "Simple type for output strings."
-
- abbrev = "output"
-
- struct = """\
- typedef struct {
- PyObject_HEAD
- char *buf;
- int pos;
- int size;
- int softspace;
- } OutputObject;
- """
-
- softspace = member()
-
- def close(self):
- """Explicitly release resources."""
-
- def write(self, s):
- """Write a string to the file."""
- # XXX Hack: writing None resets the buffer
-
- def writelines(self, lines):
- """Write each string in lines."""
-
-
-cStringIO.gen()
diff --git a/Tools/framer/framer/__init__.py b/Tools/framer/framer/__init__.py
deleted file mode 100644
index d8f9058..0000000
--- a/Tools/framer/framer/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""A tool to generate basic framework for C extension types.
-
-The basic ideas is the same as modulator, but the code generates code
-using many of the new features introduced in Python 2.2. It also
-takes a more declarative approach to generating code.
-"""
diff --git a/Tools/framer/framer/bases.py b/Tools/framer/framer/bases.py
deleted file mode 100644
index d19b5c9..0000000
--- a/Tools/framer/framer/bases.py
+++ /dev/null
@@ -1,215 +0,0 @@
-"""Provides the Module and Type base classes that user code inherits from."""
-
-__all__ = ["Module", "Type", "member"]
-
-from framer import struct, template
-from framer.function import Function, Method
-from framer.member import member
-from framer.slots import *
-from framer.util import cstring, unindent
-
-from types import FunctionType
-
-# The Module and Type classes are implemented using metaclasses,
-# because most of the methods are class methods. It is easier to use
-# metaclasses than the cumbersome classmethod() builtin. They have
-# class methods because they are exposed to user code as base classes.
-
-class BaseMetaclass(type):
- """Shared infrastructure for generating modules and types."""
-
- # just methoddef so far
-
- def dump_methoddef(self, f, functions, vars):
- def p(templ, vars=vars): # helper function to generate output
- print(templ % vars, file=f)
-
- if not functions:
- return
- p(template.methoddef_start)
- for name, func in sorted(functions.items()):
- if func.__doc__:
- p(template.methoddef_def_doc, func.vars)
- else:
- p(template.methoddef_def, func.vars)
- p(template.methoddef_end)
-
-class ModuleMetaclass(BaseMetaclass):
- """Provides methods for Module class."""
-
- def gen(self):
- self.analyze()
- self.initvars()
- f = open(self.__filename, "w")
- self.dump(f)
- f.close()
-
- def analyze(self):
- self.name = getattr(self, "abbrev", self.__name__)
- self.__functions = {}
- self.__types = {}
- self.__members = False
-
- for name, obj in self.__dict__.items():
- if isinstance(obj, FunctionType):
- self.__functions[name] = Function(obj, self)
- elif isinstance(obj, TypeMetaclass):
- obj._TypeMetaclass__module = self.name
- obj.analyze()
- self.__types[name] = obj
- if obj.has_members():
- self.__members = True
-
- def initvars(self):
- v = self.__vars = {}
- filename = getattr(self, "__file__", None)
- if filename is None:
- filename = self.__name__ + "module.c"
- self.__filename = v["FileName"] = filename
- name = v["ModuleName"] = self.__name__
- v["MethodDefName"] = "%s_methods" % name
- v["ModuleDocstring"] = cstring(unindent(self.__doc__))
-
- def dump(self, f):
- def p(templ, vars=self.__vars): # helper function to generate output
- print(templ % vars, file=f)
-
- p(template.module_start)
- if self.__members:
- p(template.member_include)
- print(file=f)
-
- if self.__doc__:
- p(template.module_doc)
-
- for name, type in sorted(self.__types.items()):
- type.dump(f)
-
- for name, func in sorted(self.__functions.items()):
- func.dump(f)
-
- self.dump_methoddef(f, self.__functions, self.__vars)
-
- p(template.module_init_start)
- for name, type in sorted(self.__types.items()):
- type.dump_init(f)
-
- p("}")
-
-class Module(metaclass=ModuleMetaclass):
- pass
-
-class TypeMetaclass(BaseMetaclass):
-
- def dump(self, f):
- self.initvars()
-
- # defined after initvars() so that __vars is defined
- def p(templ, vars=self.__vars):
- print(templ % vars, file=f)
-
- if self.struct is not None:
- print(unindent(self.struct, False), file=f)
-
- if self.__doc__:
- p(template.docstring)
-
- for name, func in sorted(self.__methods.items()):
- func.dump(f)
-
- self.dump_methoddef(f, self.__methods, self.__vars)
- self.dump_memberdef(f)
- self.dump_slots(f)
-
- def has_members(self):
- if self.__members:
- return True
- else:
- return False
-
- def analyze(self):
- # called by ModuleMetaclass analyze()
- self.name = getattr(self, "abbrev", self.__name__)
- src = getattr(self, "struct", None)
- if src is not None:
- self.__struct = struct.parse(src)
- else:
- self.__struct = None
- self.__methods = {}
- self.__members = {}
- for cls in self.__mro__:
- for k, v in cls.__dict__.items():
- if isinstance(v, FunctionType):
- self.__methods[k] = Method(v, self)
- if isinstance(v, member):
- self.__members[k] = v
- assert self.__struct is not None
- v.register(k, self.__struct)
- self.analyze_slots()
-
- def analyze_slots(self):
- self.__slots = {}
- for s in Slots:
- if s.special is not None:
- meth = self.__methods.get(s.special)
- if meth is not None:
- self.__slots[s] = meth
- self.__slots[TP_NAME] = '"%s.%s"' % (self.__module, self.__name__)
- if self.__doc__:
- self.__slots[TP_DOC] = "%s_doc" % self.name
- if self.__struct is not None:
- self.__slots[TP_BASICSIZE] = "sizeof(%s)" % self.__struct.name
- self.__slots[TP_DEALLOC] = "%s_dealloc" % self.name
- if self.__methods:
- self.__slots[TP_METHODS] = "%s_methods" % self.name
- if self.__members:
- self.__slots[TP_MEMBERS] = "%s_members" % self.name
-
- def initvars(self):
- v = self.__vars = {}
- v["TypeName"] = self.__name__
- v["CTypeName"] = "Py%s_Type" % self.__name__
- v["MethodDefName"] = self.__slots[TP_METHODS]
- if self.__doc__:
- v["DocstringVar"] = self.__slots[TP_DOC]
- v["Docstring"] = cstring(unindent(self.__doc__))
- if self.__struct is not None:
- v["StructName"] = self.__struct.name
- if self.__members:
- v["MemberDefName"] = self.__slots[TP_MEMBERS]
-
- def dump_memberdef(self, f):
- def p(templ, vars=self.__vars):
- print(templ % vars, file=f)
-
- if not self.__members:
- return
- p(template.memberdef_start)
- for name, slot in sorted(self.__members.items()):
- slot.dump(f)
- p(template.memberdef_end)
-
- def dump_slots(self, f):
- def p(templ, vars=self.__vars):
- print(templ % vars, file=f)
-
- if self.struct:
- p(template.dealloc_func, {"name" : self.__slots[TP_DEALLOC]})
-
- p(template.type_struct_start)
- for s in Slots[:-5]: # XXX
- val = self.__slots.get(s, s.default)
- ntabs = 4 - (4 + len(val)) // 8
- line = " %s,%s/* %s */" % (val, "\t" * ntabs, s.name)
- print(line, file=f)
- p(template.type_struct_end)
-
- def dump_init(self, f):
- def p(templ):
- print(templ % self.__vars, file=f)
-
- p(template.type_init_type)
- p(template.module_add_type)
-
-class Type(metaclass=TypeMetaclass):
- pass
diff --git a/Tools/framer/framer/function.py b/Tools/framer/framer/function.py
deleted file mode 100644
index f95ea20..0000000
--- a/Tools/framer/framer/function.py
+++ /dev/null
@@ -1,173 +0,0 @@
-"""Functions."""
-
-from framer import template
-from framer.util import cstring, unindent
-
-METH_O = "METH_O"
-METH_NOARGS = "METH_NOARGS"
-METH_VARARGS = "METH_VARARGS"
-
-def parsefmt(fmt):
- for c in fmt:
- if c == '|':
- continue
- yield c
-
-class Argument:
-
- def __init__(self, name):
- self.name = name
- self.ctype = "PyObject *"
- self.default = None
-
- def __str__(self):
- return "%s%s" % (self.ctype, self.name)
-
- def setfmt(self, code):
- self.ctype = self._codes[code]
- if self.ctype[-1] != "*":
- self.ctype += " "
-
- _codes = {"O": "PyObject *",
- "i": "int",
- }
-
- def decl(self):
- if self.default is None:
- return str(self) + ";"
- else:
- return "%s = %s;" % (self, self.default)
-
-class _ArgumentList(object):
-
- # these instance variables should be initialized by subclasses
- ml_meth = None
- fmt = None
-
- def __init__(self, args):
- self.args = list(map(Argument, args))
-
- def __len__(self):
- return len(self.args)
-
- def __getitem__(self, i):
- return self.args[i]
-
- def dump_decls(self, f):
- pass
-
-class NoArgs(_ArgumentList):
-
- def __init__(self, args):
- assert len(args) == 0
- super(NoArgs, self).__init__(args)
- self.ml_meth = METH_NOARGS
-
- def c_args(self):
- return "PyObject *self"
-
-class OneArg(_ArgumentList):
-
- def __init__(self, args):
- assert len(args) == 1
- super(OneArg, self).__init__(args)
- self.ml_meth = METH_O
-
- def c_args(self):
- return "PyObject *self, %s" % self.args[0]
-
-class VarArgs(_ArgumentList):
-
- def __init__(self, args, fmt=None):
- super(VarArgs, self).__init__(args)
- self.ml_meth = METH_VARARGS
- if fmt is not None:
- self.fmt = fmt
- i = 0
- for code in parsefmt(fmt):
- self.args[i].setfmt(code)
- i += 1
-
- def c_args(self):
- return "PyObject *self, PyObject *args"
-
- def targets(self):
- return ", ".join(["&%s" % a.name for a in self.args])
-
- def dump_decls(self, f):
- for a in self.args:
- print(" %s" % a.decl(), file=f)
-
-def ArgumentList(func, method):
- code = func.__code__
- args = code.co_varnames[:code.co_argcount]
- if method:
- args = args[1:]
- pyarg = getattr(func, "pyarg", None)
- if pyarg is not None:
- args = VarArgs(args, pyarg)
- if func.__defaults__:
- L = list(func.__defaults__)
- ndefault = len(L)
- i = len(args) - ndefault
- while L:
- args[i].default = L.pop(0)
- return args
- else:
- if len(args) == 0:
- return NoArgs(args)
- elif len(args) == 1:
- return OneArg(args)
- else:
- return VarArgs(args)
-
-class Function:
-
- method = False
-
- def __init__(self, func, parent):
- self._func = func
- self._parent = parent
- self.analyze()
- self.initvars()
-
- def dump(self, f):
- def p(templ, vars=None): # helper function to generate output
- if vars is None:
- vars = self.vars
- print(templ % vars, file=f)
-
- if self.__doc__:
- p(template.docstring)
-
- d = {"name" : self.vars["CName"],
- "args" : self.args.c_args(),
- }
- p(template.funcdef_start, d)
-
- self.args.dump_decls(f)
-
- if self.args.ml_meth == METH_VARARGS:
- p(template.varargs)
-
- p(template.funcdef_end)
-
- def analyze(self):
- self.__doc__ = self._func.__doc__
- self.args = ArgumentList(self._func, self.method)
-
- def initvars(self):
- v = self.vars = {}
- v["PythonName"] = self._func.__name__
- s = v["CName"] = "%s_%s" % (self._parent.name, self._func.__name__)
- v["DocstringVar"] = s + "_doc"
- v["MethType"] = self.args.ml_meth
- if self.__doc__:
- v["Docstring"] = cstring(unindent(self.__doc__))
- if self.args.fmt is not None:
- v["ArgParse"] = self.args.fmt
- v["ArgTargets"] = self.args.targets()
-
-class Method(Function):
-
- method = True
diff --git a/Tools/framer/framer/member.py b/Tools/framer/framer/member.py
deleted file mode 100644
index 4838c1f..0000000
--- a/Tools/framer/framer/member.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from framer import template
-from framer.util import cstring, unindent
-
-T_SHORT = "T_SHORT"
-T_INT = "T_INT"
-T_LONG = "T_LONG"
-T_FLOAT = "T_FLOAT"
-T_DOUBLE = "T_DOUBLE"
-T_STRING = "T_STRING"
-T_OBJECT = "T_OBJECT"
-T_CHAR = "T_CHAR"
-T_BYTE = "T_BYTE"
-T_UBYTE = "T_UBYTE"
-T_UINT = "T_UINT"
-T_ULONG = "T_ULONG"
-T_STRING_INPLACE = "T_STRING_INPLACE"
-T_OBJECT_EX = "T_OBJECT_EX"
-
-RO = READONLY = "READONLY"
-READ_RESTRICTED = "READ_RESTRICTED"
-WRITE_RESTRICTED = "WRITE_RESTRICTED"
-RESTRICT = "RESTRICTED"
-
-c2t = {"int" : T_INT,
- "unsigned int" : T_UINT,
- "long" : T_LONG,
- "unsigned long" : T_LONG,
- "float" : T_FLOAT,
- "double" : T_DOUBLE,
- "char *" : T_CHAR,
- "PyObject *" : T_OBJECT,
- }
-
-class member(object):
-
- def __init__(self, cname=None, type=None, flags=None, doc=None):
- self.type = type
- self.flags = flags
- self.cname = cname
- self.doc = doc
- self.name = None
- self.struct = None
-
- def register(self, name, struct):
- self.name = name
- self.struct = struct
- self.initvars()
-
- def initvars(self):
- v = self.vars = {}
- v["PythonName"] = self.name
- if self.cname is not None:
- v["CName"] = self.cname
- else:
- v["CName"] = self.name
- v["Flags"] = self.flags or "0"
- v["Type"] = self.get_type()
- if self.doc is not None:
- v["Docstring"] = cstring(unindent(self.doc))
- v["StructName"] = self.struct.name
-
- def get_type(self):
- """Deduce type code from struct specification if not defined"""
- if self.type is not None:
- return self.type
- ctype = self.struct.get_type(self.name)
- return c2t[ctype]
-
- def dump(self, f):
- if self.doc is None:
- print(template.memberdef_def % self.vars, file=f)
- else:
- print(template.memberdef_def_doc % self.vars, file=f)
diff --git a/Tools/framer/framer/slots.py b/Tools/framer/framer/slots.py
deleted file mode 100644
index 0f6e6fe..0000000
--- a/Tools/framer/framer/slots.py
+++ /dev/null
@@ -1,64 +0,0 @@
-"""Descriptions of all the slots in Python's type objects."""
-
-class Slot(object):
- def __init__(self, name, cast=None, special=None, default="0"):
- self.name = name
- self.cast = cast
- self.special = special
- self.default = default
-
-Slots = (Slot("ob_size"),
- Slot("tp_name"),
- Slot("tp_basicsize"),
- Slot("tp_itemsize"),
- Slot("tp_dealloc", "destructor"),
- Slot("tp_print", "printfunc"),
- Slot("tp_getattr", "getattrfunc"),
- Slot("tp_setattr", "setattrfunc"),
- Slot("tp_reserved", "void*"),
- Slot("tp_repr", "reprfunc", "__repr__"),
- Slot("tp_as_number"),
- Slot("tp_as_sequence"),
- Slot("tp_as_mapping"),
- Slot("tp_hash", "hashfunc", "__hash__"),
- Slot("tp_call", "ternaryfunc", "__call__"),
- Slot("tp_str", "reprfunc", "__str__"),
- Slot("tp_getattro", "getattrofunc", "__getattr__", # XXX
- "PyObject_GenericGetAttr"),
- Slot("tp_setattro", "setattrofunc", "__setattr__"),
- Slot("tp_as_buffer"),
- Slot("tp_flags", default="Py_TPFLAGS_DEFAULT"),
- Slot("tp_doc"),
- Slot("tp_traverse", "traverseprox"),
- Slot("tp_clear", "inquiry"),
- Slot("tp_richcompare", "richcmpfunc"),
- Slot("tp_weaklistoffset"),
- Slot("tp_iter", "getiterfunc", "__iter__"),
- Slot("tp_iternext", "iternextfunc", "__next__"), # XXX
- Slot("tp_methods"),
- Slot("tp_members"),
- Slot("tp_getset"),
- Slot("tp_base"),
- Slot("tp_dict"),
- Slot("tp_descr_get", "descrgetfunc"),
- Slot("tp_descr_set", "descrsetfunc"),
- Slot("tp_dictoffset"),
- Slot("tp_init", "initproc", "__init__"),
- Slot("tp_alloc", "allocfunc"),
- Slot("tp_new", "newfunc"),
- Slot("tp_free", "freefunc"),
- Slot("tp_is_gc", "inquiry"),
- Slot("tp_bases"),
- Slot("tp_mro"),
- Slot("tp_cache"),
- Slot("tp_subclasses"),
- Slot("tp_weaklist"),
- )
-
-# give some slots symbolic names
-TP_NAME = Slots[1]
-TP_BASICSIZE = Slots[2]
-TP_DEALLOC = Slots[4]
-TP_DOC = Slots[20]
-TP_METHODS = Slots[27]
-TP_MEMBERS = Slots[28]
diff --git a/Tools/framer/framer/struct.py b/Tools/framer/framer/struct.py
deleted file mode 100644
index 8fc2aec..0000000
--- a/Tools/framer/framer/struct.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""Rudimentary parser for C struct definitions."""
-
-import re
-
-PyObject_HEAD = "PyObject_HEAD"
-PyObject_VAR_HEAD = "PyObject_VAR_HEAD"
-
-rx_name = re.compile("} (\w+);")
-
-class Struct:
- def __init__(self, name, head, members):
- self.name = name
- self.head = head
- self.members = members
-
- def get_type(self, name):
- for _name, type in self.members:
- if name == _name:
- return type
- raise ValueError("no member named %s" % name)
-
-def parse(s):
- """Parse a C struct definition.
-
- The parser is very restricted in what it will accept.
- """
-
- lines = [_f for _f in s.split("\n") if _f] # get non-empty lines
- assert lines[0].strip() == "typedef struct {"
- pyhead = lines[1].strip()
- assert (pyhead.startswith("PyObject") and
- pyhead.endswith("HEAD"))
- members = []
- for line in lines[2:]:
- line = line.strip()
- if line.startswith("}"):
- break
-
- assert line.endswith(";")
- line = line[:-1]
- words = line.split()
- name = words[-1]
- type = " ".join(words[:-1])
- if name[0] == "*":
- name = name[1:]
- type += " *"
- members.append((name, type))
- name = None
- mo = rx_name.search(line)
- assert mo is not None
- name = mo.group(1)
- return Struct(name, pyhead, members)
diff --git a/Tools/framer/framer/structparse.py b/Tools/framer/framer/structparse.py
deleted file mode 100644
index cf4224b..0000000
--- a/Tools/framer/framer/structparse.py
+++ /dev/null
@@ -1,46 +0,0 @@
-"""Rudimentary parser for C struct definitions."""
-
-import re
-
-PyObject_HEAD = "PyObject_HEAD"
-PyObject_VAR_HEAD = "PyObject_VAR_HEAD"
-
-rx_name = re.compile("} (\w+);")
-
-class Struct:
- def __init__(self, name, head, members):
- self.name = name
- self.head = head
- self.members = members
-
-def parse(s):
- """Parse a C struct definition.
-
- The parser is very restricted in what it will accept.
- """
-
- lines = [_f for _f in s.split("\n") if _f] # get non-empty lines
- assert lines[0].strip() == "typedef struct {"
- pyhead = lines[1].strip()
- assert (pyhead.startswith("PyObject") and
- pyhead.endswith("HEAD"))
- members = []
- for line in lines[2:]:
- line = line.strip()
- if line.startswith("}"):
- break
-
- assert line.endswith(";")
- line = line[:-1]
- words = line.split()
- name = words[-1]
- type = " ".join(words[:-1])
- if name[0] == "*":
- name = name[1:]
- type += " *"
- members.append((name, type))
- name = None
- mo = rx_name.search(line)
- assert mo is not None
- name = mo.group(1)
- return Struct(name, pyhead, members)
diff --git a/Tools/framer/framer/template.py b/Tools/framer/framer/template.py
deleted file mode 100644
index e596c1f..0000000
--- a/Tools/framer/framer/template.py
+++ /dev/null
@@ -1,102 +0,0 @@
-"""framer's C code templates.
-
-Templates use the following variables:
-
-FileName: name of the file that contains the C source code
-ModuleName: name of the module, as in "import ModuleName"
-ModuleDocstring: C string containing the module doc string
-"""
-
-module_start = '#include "Python.h"'
-member_include = '#include "structmember.h"'
-
-module_doc = """\
-PyDoc_STRVAR(%(ModuleName)s_doc,
-%(ModuleDocstring)s);
-"""
-
-methoddef_start = """\
-static struct PyMethodDef %(MethodDefName)s[] = {"""
-
-methoddef_def = """\
- {"%(PythonName)s", (PyCFunction)%(CName)s, %(MethType)s},"""
-
-methoddef_def_doc = """\
- {"%(PythonName)s", (PyCFunction)%(CName)s, %(MethType)s,
- %(DocstringVar)s},"""
-
-methoddef_end = """\
- {NULL, NULL}
-};
-"""
-
-memberdef_start = """\
-#define OFF(X) offsetof(%(StructName)s, X)
-
-static struct PyMemberDef %(MemberDefName)s[] = {"""
-
-memberdef_def_doc = """\
- {"%(PythonName)s", %(Type)s, OFF(%(CName)s), %(Flags)s,
- %(Docstring)s},"""
-
-memberdef_def = """\
- {"%(PythonName)s", %(Type)s, OFF(%(CName)s), %(Flags)s},"""
-
-memberdef_end = """\
- {NULL}
-};
-
-#undef OFF
-"""
-
-dealloc_func = """static void
-%(name)s(PyObject *ob)
-{
-}
-"""
-
-docstring = """\
-PyDoc_STRVAR(%(DocstringVar)s,
-%(Docstring)s);
-"""
-
-funcdef_start = """\
-static PyObject *
-%(name)s(%(args)s)
-{"""
-
-funcdef_end = """\
-}
-"""
-
-varargs = """\
- if (!PyArg_ParseTuple(args, \"%(ArgParse)s:%(PythonName)s\",
- %(ArgTargets)s))
- return NULL;"""
-
-module_init_start = """\
-PyMODINIT_FUNC
-PyInit_%(ModuleName)s(void)
-{
- PyObject *mod;
-
- mod = Py_InitModule3("%(ModuleName)s", %(MethodDefName)s,
- %(ModuleName)s_doc);
- if (mod == NULL)
- return;
-"""
-
-type_init_type = " %(CTypeName)s.ob_type = &PyType_Type;"
-module_add_type = """\
- if (!PyObject_SetAttrString(mod, "%(TypeName)s",
- (PyObject *)&%(CTypeName)s))
- return;
-"""
-
-type_struct_start = """\
-static PyTypeObject %(CTypeName)s = {
- PyObject_HEAD_INIT(0)"""
-
-type_struct_end = """\
-};
-"""
diff --git a/Tools/framer/framer/util.py b/Tools/framer/framer/util.py
deleted file mode 100644
index 73f3309..0000000
--- a/Tools/framer/framer/util.py
+++ /dev/null
@@ -1,35 +0,0 @@
-def cstring(s, width=70):
- """Return C string representation of a Python string.
-
- width specifies the maximum width of any line of the C string.
- """
- L = []
- for l in s.split("\n"):
- if len(l) < width:
- L.append(r'"%s\n"' % l)
-
- return "\n".join(L)
-
-def unindent(s, skipfirst=True):
- """Return an unindented version of a docstring.
-
- Removes indentation on lines following the first one, using the
- leading whitespace of the first indented line that is not blank
- to determine the indentation.
- """
-
- lines = s.split("\n")
- if skipfirst:
- first = lines.pop(0)
- L = [first]
- else:
- L = []
- indent = None
- for l in lines:
- ls = l.strip()
- if ls:
- indent = len(l) - len(ls)
- break
- L += [l[indent:] for l in lines]
-
- return "\n".join(L)
diff --git a/Tools/ssl/get-remote-certificate.py b/Tools/scripts/get-remote-certificate.py
similarity index 100%
rename from Tools/ssl/get-remote-certificate.py
rename to Tools/scripts/get-remote-certificate.py
diff --git a/Tools/world/README b/Tools/world/README
deleted file mode 100644
index f7bb610..0000000
--- a/Tools/world/README
+++ /dev/null
@@ -1,85 +0,0 @@
-world -- Print mappings between country names and DNS country codes.
-
-Contact: Barry Warsaw
-Email: bwarsaw@python.org
-
-This script will take a list of Internet addresses and print out where in the
-world those addresses originate from, based on the top-level domain country
-code found in the address. Addresses can be in any of the following forms:
-
- xx -- just the country code or top-level domain identifier
- host.domain.xx -- any Internet host or network name
- somebody@where.xx -- an Internet email address
-
-If no match is found, the address is interpreted as a regular expression [*]
-and a reverse lookup is attempted. This script will search the country names
-and print a list of matching entries. You can force reverse mappings with the
-`-r' flag (see below).
-
-For example:
-
- %% world tz us
- tz originated from Tanzania, United Republic of
- us originated from United States
-
- %% world united
- united matches 6 countries:
- ae: United Arab Emirates
- uk: United Kingdom (common practice)
- um: United States Minor Outlying Islands
- us: United States
- tz: Tanzania, United Republic of
- gb: United Kingdom
-
-
- [*] Note that regular expressions must conform to Python 1.5's re.py module
- syntax. The comparison is done with the search() method.
-
-Country codes are maintained by the RIPE Network Coordination Centre,
-in coordination with the ISO 3166 Maintenance Agency at DIN Berlin. The
-authoritative source of counry code mappings is:
-
- <url:ftp://info.ripe.net/iso3166-countrycodes>
-
-The latest known change to this information was:
-
- Thu Aug 7 17:59:51 MET DST 1997
-
-This script also knows about non-geographic top-level domains.
-
-Usage: world [-d] [-p file] [-o] [-h] addr [addr ...]
-
- --dump
- -d
- Print mapping of all top-level domains.
-
- --parse file
- -p file
- Parse an iso3166-countrycodes file extracting the two letter country
- code followed by the country name. Note that the three letter country
- codes and numbers, which are also provided in the standard format
- file, are ignored.
-
- --outputdict
- -o
- When used in conjunction with the `-p' option, output is in the form
- of a Python dictionary, and country names are normalized
- w.r.t. capitalization. This makes it appropriate for cutting and
- pasting back into this file.
-
- --reverse
- -r
- Force reverse lookup. In this mode the address can be any Python
- regular expression; this is matched against all country names and a
- list of matching mappings is printed. In normal mode (e.g. without
- this flag), reverse lookup is performed on addresses if no matching
- country code is found.
-
- -h
- --help
- Print this message.
-
-
-Local Variables:
-indent-tabs-mode: nil
-End:
diff --git a/Tools/world/world b/Tools/world/world
deleted file mode 100755
index 16452f3..0000000
--- a/Tools/world/world
+++ /dev/null
@@ -1,568 +0,0 @@
-#! /usr/bin/env python
-
-"""world -- Print mappings between country names and DNS country codes.
-
-Contact: Barry Warsaw
-Email: barry@python.org
-Version: %(__version__)s
-
-This script will take a list of Internet addresses and print out where in the
-world those addresses originate from, based on the top-level domain country
-code found in the address. Addresses can be in any of the following forms:
-
- xx -- just the country code or top-level domain identifier
- host.domain.xx -- any Internet host or network name
- somebody@where.xx -- an Internet email address
-
-If no match is found, the address is interpreted as a regular expression and a
-reverse lookup is attempted. This script will search the country names and
-print a list of matching entries. You can force reverse mappings with the
-`-r' flag (see below).
-
-For example:
-
- %% world tz us
- tz originated from Tanzania, United Republic of
- us originated from United States
-
- %% world united
- united matches 6 countries:
- ae: United Arab Emirates
- uk: United Kingdom (common practice)
- um: United States Minor Outlying Islands
- us: United States
- tz: Tanzania, United Republic of
- gb: United Kingdom
-
-Country codes are maintained by the RIPE Network Coordination Centre,
-in coordination with the ISO 3166 Maintenance Agency at DIN Berlin. The
-authoritative source of country code mappings is:
-
- <url:ftp://ftp.ripe.net/iso3166-countrycodes.txt>
-
-The latest known change to this information was:
-
- Monday, 10 October 2006, 17:59:51 UTC 2006
-
-This script also knows about non-geographic top-level domains, and the
-additional ccTLDs reserved by IANA.
-
-Usage: %(PROGRAM)s [-d] [-p file] [-o] [-h] addr [addr ...]
-
- --dump
- -d
- Print mapping of all top-level domains.
-
- --parse file
- -p file
- Parse an iso3166-countrycodes file extracting the two letter country
- code followed by the country name. Note that the three letter country
- codes and numbers, which are also provided in the standard format
- file, are ignored.
-
- --outputdict
- -o
- When used in conjunction with the `-p' option, output is in the form
- of a Python dictionary, and country names are normalized
- w.r.t. capitalization. This makes it appropriate for cutting and
- pasting back into this file. Output is always to standard out.
-
- --reverse
- -r
- Force reverse lookup. In this mode the address can be any Python
- regular expression; this is matched against all country names and a
- list of matching mappings is printed. In normal mode (e.g. without
- this flag), reverse lookup is performed on addresses if no matching
- country code is found.
-
- -h
- --help
- Print this message.
-"""
-__version__ = '$Revision$'
-
-
-import sys
-import getopt
-import re
-
-PROGRAM = sys.argv[0]
-
-
-
-def usage(code, msg=''):
- print(__doc__ % globals())
- if msg:
- print(msg)
- sys.exit(code)
-
-
-
-def resolve(rawaddr):
- parts = rawaddr.split('.')
- if not len(parts):
- # no top level domain found, bounce it to the next step
- return rawaddr
- addr = parts[-1]
- if addr in nameorgs:
- print(rawaddr, 'is in the', nameorgs[addr], 'top level domain')
- return None
- elif addr in countries:
- print(rawaddr, 'originated from', countries[addr])
- return None
- else:
- # Not resolved, bounce it to the next step
- return rawaddr
-
-
-
-def reverse(regexp):
- matches = []
- cre = re.compile(regexp, re.IGNORECASE)
- for code, country in all.items():
- mo = cre.search(country)
- if mo:
- matches.append(code)
- # print results
- if not matches:
- # not resolved, bounce it to the next step
- return regexp
- if len(matches) == 1:
- code = matches[0]
- print(regexp, "matches code `%s', %s" % (code, all[code]))
- else:
- print(regexp, 'matches %d countries:' % len(matches))
- for code in matches:
- print(" %s: %s" % (code, all[code]))
- return None
-
-
-
-def parse(file, normalize):
- try:
- fp = open(file)
- except IOError as err:
- errno, msg = err.args
- print(msg, ':', file)
- return
-
- cre = re.compile('(.*?)[ \t]+([A-Z]{2})[ \t]+[A-Z]{3}[ \t]+[0-9]{3}')
- scanning = 0
-
- if normalize:
- print('countries = {')
-
- while 1:
- line = fp.readline()
- if line == '':
- break # EOF
- if scanning:
- mo = cre.match(line)
- if not mo:
- line = line.strip()
- if not line:
- continue
- elif line[0] == '-':
- break
- else:
- print('Could not parse line:', line)
- continue
- country, code = mo.group(1, 2)
- if normalize:
- words = country.split()
- for i in range(len(words)):
- w = words[i]
- # XXX special cases
- if w in ('AND', 'OF', 'OF)', 'name:', 'METROPOLITAN'):
- words[i] = w.lower()
- elif w == 'THE' and i != 1:
- words[i] = w.lower()
- elif len(w) > 3 and w[1] == "'":
- words[i] = w[0:3].upper() + w[3:].lower()
- elif w in ('(U.S.)', 'U.S.'):
- pass
- elif w[0] == '(' and w != '(local':
- words[i] = '(' + w[1:].capitalize()
- elif w.find('-') != -1:
- words[i] = '-'.join(
- [s.capitalize() for s in w.split('-')])
- else:
- words[i] = w.capitalize()
- code = code.lower()
- country = ' '.join(words)
- print(' "%s": "%s",' % (code, country))
- else:
- print(code, country)
-
- elif line[0] == '-':
- scanning = 1
-
- if normalize:
- print(' }')
-
-
-def main():
- help = 0
- status = 0
- dump = 0
- parsefile = None
- normalize = 0
- forcerev = 0
-
- try:
- opts, args = getopt.getopt(
- sys.argv[1:],
- 'p:rohd',
- ['parse=', 'reverse', 'outputdict', 'help', 'dump'])
- except getopt.error as msg:
- usage(1, msg)
-
- for opt, arg in opts:
- if opt in ('-h', '--help'):
- help = 1
- elif opt in ('-d', '--dump'):
- dump = 1
- elif opt in ('-p', '--parse'):
- parsefile = arg
- elif opt in ('-o', '--outputdict'):
- normalize = 1
- elif opt in ('-r', '--reverse'):
- forcerev = 1
-
- if help:
- usage(status)
-
- if dump:
- print('Official country coded domains:')
- codes = sorted(countries)
- for code in codes:
- print(' %2s:' % code, countries[code])
-
- print('\nOther top-level domains:')
- codes = sorted(nameorgs)
- for code in codes:
- print(' %6s:' % code, nameorgs[code])
- elif parsefile:
- parse(parsefile, normalize)
- else:
- if not forcerev:
- args = filter(None, map(resolve, args))
- args = filter(None, map(reverse, args))
- for arg in args:
- print('Where in the world is %s?' % arg)
-
-
-
-# The mappings
-nameorgs = {
- # New top level domains as described by ICANN
- # http://www.icann.org/tlds/
- "aero": "air-transport industry",
- "asia": "from Asia/for Asia",
- "arpa": "Arpanet",
- "biz": "business",
- "cat": "Catalan community",
- "com": "commercial",
- "coop": "cooperatives",
- "edu": "educational",
- "gov": "government",
- "info": "unrestricted `info'",
- "int": "international",
- "jobs": "employment-related",
- "mil": "military",
- "mobi": "mobile specific",
- "museum": "museums",
- "name": "`name' (for registration by individuals)",
- "net": "networking",
- "org": "non-commercial",
- "pro": "professionals",
- "tel": "business telecommunications",
- "travel": "travel and tourism",
- # These additional ccTLDs are included here even though they are not part
- # of ISO 3166. IANA has a decoding table listing all reserved ccTLDs:
- #
- # http://www.iso.org/iso/iso-3166-1_decoding_table
- #
- # Note that `uk' is the common practice country code for the United
- # Kingdom. AFAICT, the official `gb' code is routinely ignored!
- #
- # <D.M.Pick@qmw.ac.uk> tells me that `uk' was long in use before ISO3166
- # was adopted for top-level DNS zone names (although in the reverse order
- # like uk.ac.qmw) and was carried forward (with the reversal) to avoid a
- # large-scale renaming process as the UK switched from their old `Coloured
- # Book' protocols over X.25 to Internet protocols over IP.
- #
- # See <url:ftp://ftp.ripe.net/ripe/docs/ripe-159.txt>
- #
- # Also, `su', while obsolete is still in limited use.
- "ac": "Ascension Island",
- "cp": "Clipperton Island",
- "dg": "Diego Garcia",
- "ea": "Ceuta, Melilla",
- "eu": "European Union",
- "fx": "Metropolitan France",
- "ic": "Canary Islands",
- "ta": "Tristan da Cunha",
- "uk": "United Kingdom (common practice)",
- "su": "Soviet Union (still in limited use)",
- }
-
-
-
-countries = {
- "af": "Afghanistan",
- "ax": "Aland Islands",
- "al": "Albania",
- "dz": "Algeria",
- "as": "American Samoa",
- "ad": "Andorra",
- "ao": "Angola",
- "ai": "Anguilla",
- "aq": "Antarctica",
- "ag": "Antigua and Barbuda",
- "ar": "Argentina",
- "am": "Armenia",
- "aw": "Aruba",
- "au": "Australia",
- "at": "Austria",
- "az": "Azerbaijan",
- "bs": "Bahamas",
- "bh": "Bahrain",
- "bd": "Bangladesh",
- "bb": "Barbados",
- "by": "Belarus",
- "be": "Belgium",
- "bz": "Belize",
- "bj": "Benin",
- "bm": "Bermuda",
- "bt": "Bhutan",
- "bo": "Bolivia",
- "ba": "Bosnia and Herzegovina",
- "bw": "Botswana",
- "bv": "Bouvet Island",
- "br": "Brazil",
- "io": "British Indian Ocean Territory",
- "bn": "Brunei Darussalam",
- "bg": "Bulgaria",
- "bf": "Burkina Faso",
- "bi": "Burundi",
- "kh": "Cambodia",
- "cm": "Cameroon",
- "ca": "Canada",
- "cv": "Cape Verde",
- "ky": "Cayman Islands",
- "cf": "Central African Republic",
- "td": "Chad",
- "cl": "Chile",
- "cn": "China",
- "cx": "Christmas Island",
- "cc": "Cocos (Keeling) Islands",
- "co": "Colombia",
- "km": "Comoros",
- "cg": "Congo",
- "cd": "Congo, The Democratic Republic of the",
- "ck": "Cook Islands",
- "cr": "Costa Rica",
- "ci": "Cote D'Ivoire",
- "hr": "Croatia",
- "cu": "Cuba",
- "cy": "Cyprus",
- "cz": "Czech Republic",
- "dk": "Denmark",
- "dj": "Djibouti",
- "dm": "Dominica",
- "do": "Dominican Republic",
- "ec": "Ecuador",
- "eg": "Egypt",
- "sv": "El Salvador",
- "gq": "Equatorial Guinea",
- "er": "Eritrea",
- "ee": "Estonia",
- "et": "Ethiopia",
- "fk": "Falkland Islands (Malvinas)",
- "fo": "Faroe Islands",
- "fj": "Fiji",
- "fi": "Finland",
- "fr": "France",
- "gf": "French Guiana",
- "pf": "French Polynesia",
- "tf": "French Southern Territories",
- "ga": "Gabon",
- "gm": "Gambia",
- "ge": "Georgia",
- "de": "Germany",
- "gh": "Ghana",
- "gi": "Gibraltar",
- "gr": "Greece",
- "gl": "Greenland",
- "gd": "Grenada",
- "gp": "Guadeloupe",
- "gu": "Guam",
- "gt": "Guatemala",
- "gg": "Guernsey",
- "gn": "Guinea",
- "gw": "Guinea-Bissau",
- "gy": "Guyana",
- "ht": "Haiti",
- "hm": "Heard Island and Mcdonald Islands",
- "va": "Holy See (Vatican City State)",
- "hn": "Honduras",
- "hk": "Hong Kong",
- "hu": "Hungary",
- "is": "Iceland",
- "in": "India",
- "id": "Indonesia",
- "ir": "Iran (Islamic Republic of)",
- "iq": "Iraq",
- "ie": "Ireland",
- "im": "Isle of Man",
- "il": "Israel",
- "it": "Italy",
- "jm": "Jamaica",
- "jp": "Japan",
- "je": "Jersey",
- "jo": "Jordan",
- "kz": "Kazakhstan",
- "ke": "Kenya",
- "ki": "Kiribati",
- "kp": "Korea, Democratic People's Republic of",
- "kr": "Korea, Republic of",
- "kw": "Kuwait",
- "kg": "Kyrgyzstan",
- "la": "Lao People's Democratic Republic",
- "lv": "Latvia",
- "lb": "Lebanon",
- "ls": "Lesotho",
- "lr": "Liberia",
- "ly": "Libyan Arab Jamahiriya",
- "li": "Liechtenstein",
- "lt": "Lithuania",
- "lu": "Luxembourg",
- "mo": "Macao",
- "mk": "Macedonia, The Former Yugoslav Republic of",
- "mg": "Madagascar",
- "mw": "Malawi",
- "my": "Malaysia",
- "mv": "Maldives",
- "ml": "Mali",
- "mt": "Malta",
- "mh": "Marshall Islands",
- "mq": "Martinique",
- "mr": "Mauritania",
- "mu": "Mauritius",
- "yt": "Mayotte",
- "mx": "Mexico",
- "fm": "Micronesia, Federated States of",
- "md": "Moldova, Republic of",
- "mc": "Monaco",
- "mn": "Mongolia",
- "me": "Montenegro",
- "ms": "Montserrat",
- "ma": "Morocco",
- "mz": "Mozambique",
- "mm": "Myanmar",
- "na": "Namibia",
- "nr": "Nauru",
- "np": "Nepal",
- "nl": "Netherlands",
- "an": "Netherlands Antilles",
- "nc": "New Caledonia",
- "nz": "New Zealand",
- "ni": "Nicaragua",
- "ne": "Niger",
- "ng": "Nigeria",
- "nu": "Niue",
- "nf": "Norfolk Island",
- "mp": "Northern Mariana Islands",
- "no": "Norway",
- "om": "Oman",
- "pk": "Pakistan",
- "pw": "Palau",
- "ps": "Palestinian Territory, Occupied",
- "pa": "Panama",
- "pg": "Papua New Guinea",
- "py": "Paraguay",
- "pe": "Peru",
- "ph": "Philippines",
- "pn": "Pitcairn",
- "pl": "Poland",
- "pt": "Portugal",
- "pr": "Puerto Rico",
- "qa": "Qatar",
- "re": "Reunion",
- "ro": "Romania",
- "ru": "Russian Federation",
- "rw": "Rwanda",
- "sh": "Saint Helena",
- "kn": "Saint Kitts and Nevis",
- "lc": "Saint Lucia",
- "pm": "Saint Pierre and Miquelon",
- "vc": "Saint Vincent and the Grenadines",
- "ws": "Samoa",
- "sm": "San Marino",
- "st": "Sao Tome and Principe",
- "sa": "Saudi Arabia",
- "sn": "Senegal",
- "rs": "Serbia",
- "sc": "Seychelles",
- "sl": "Sierra Leone",
- "sg": "Singapore",
- "sk": "Slovakia",
- "si": "Slovenia",
- "sb": "Solomon Islands",
- "so": "Somalia",
- "za": "South Africa",
- "gs": "South Georgia and the South Sandwich Islands",
- "es": "Spain",
- "lk": "Sri Lanka",
- "sd": "Sudan",
- "sr": "Suriname",
- "sj": "Svalbard and Jan Mayen",
- "sh": "St. Helena",
- "pm": "St. Pierre and Miquelon",
- "sz": "Swaziland",
- "se": "Sweden",
- "ch": "Switzerland",
- "sy": "Syrian Arab Republic",
- "tw": "Taiwan, Province of China",
- "tj": "Tajikistan",
- "tz": "Tanzania, United Republic of",
- "th": "Thailand",
- "tl": "Timor-Leste",
- "tg": "Togo",
- "tk": "Tokelau",
- "to": "Tonga",
- "tt": "Trinidad and Tobago",
- "tn": "Tunisia",
- "tr": "Turkey",
- "tm": "Turkmenistan",
- "tc": "Turks and Caicos Islands",
- "tv": "Tuvalu",
- "ug": "Uganda",
- "ua": "Ukraine",
- "ae": "United Arab Emirates",
- "gb": "United Kingdom",
- "us": "United States",
- "um": "United States Minor Outlying Islands",
- "uy": "Uruguay",
- "uz": "Uzbekistan",
- "vu": "Vanuatu",
- "va": "Vatican City State (Holy See)",
- "ve": "Venezuela",
- "vn": "Viet Nam",
- "vg": "Virgin Islands (British)",
- "vi": "Virgin Islands (U.S.)",
- "wf": "Wallis and Futuna",
- "eh": "Western Sahara",
- "ye": "Yemen",
- "yu": "Yugoslavia",
- "zm": "Zambia",
- "zw": "Zimbabwe",
- }
-
-all = nameorgs.copy()
-all.update(countries)
-
-
-if __name__ == '__main__':
- main()