add hg and python

1 files changed, 706 insertions, 0 deletions

diff --git a/sys/src/cmd/python/Doc/lib/libdis.tex b/sys/src/cmd/python/Doc/lib/libdis.tex
new file mode 100644
index 000000000..560cc27b4
--- /dev/null
+++ b/sys/src/cmd/python/Doc/lib/libdis.tex
@@ -0,0 +1,706 @@
+\section{\module{dis} ---
+         Disassembler for Python byte code}
+
+\declaremodule{standard}{dis}
+\modulesynopsis{Disassembler for Python byte code.}
+
+
+The \module{dis} module supports the analysis of Python byte code by
+disassembling it.  Since there is no Python assembler, this module
+defines the Python assembly language.  The Python byte code which
+this module takes as an input is defined in the file 
+\file{Include/opcode.h} and used by the compiler and the interpreter.
+
+Example: Given the function \function{myfunc}:
+
+\begin{verbatim}
+def myfunc(alist):
+    return len(alist)
+\end{verbatim}
+
+the following command can be used to get the disassembly of
+\function{myfunc()}:
+
+\begin{verbatim}
+>>> dis.dis(myfunc)
+  2           0 LOAD_GLOBAL              0 (len)
+              3 LOAD_FAST                0 (alist)
+              6 CALL_FUNCTION            1
+              9 RETURN_VALUE
+\end{verbatim}
+
+(The ``2'' is a line number).
+
+The \module{dis} module defines the following functions and constants:
+
+\begin{funcdesc}{dis}{\optional{bytesource}}
+Disassemble the \var{bytesource} object. \var{bytesource} can denote
+either a module, a class, a method, a function, or a code object.  
+For a module, it disassembles all functions.  For a class,
+it disassembles all methods.  For a single code sequence, it prints
+one line per byte code instruction.  If no object is provided, it
+disassembles the last traceback.
+\end{funcdesc}
+
+\begin{funcdesc}{distb}{\optional{tb}}
+Disassembles the top-of-stack function of a traceback, using the last
+traceback if none was passed.  The instruction causing the exception
+is indicated.
+\end{funcdesc}
+
+\begin{funcdesc}{disassemble}{code\optional{, lasti}}
+Disassembles a code object, indicating the last instruction if \var{lasti}
+was provided.  The output is divided in the following columns:
+
+\begin{enumerate}
+\item the line number, for the first instruction of each line
+\item the current instruction, indicated as \samp{-->},
+\item a labelled instruction, indicated with \samp{>>},
+\item the address of the instruction,
+\item the operation code name,
+\item operation parameters, and
+\item interpretation of the parameters in parentheses.
+\end{enumerate}
+
+The parameter interpretation recognizes local and global
+variable names, constant values, branch targets, and compare
+operators.
+\end{funcdesc}
+
+\begin{funcdesc}{disco}{code\optional{, lasti}}
+A synonym for disassemble.  It is more convenient to type, and kept
+for compatibility with earlier Python releases.
+\end{funcdesc}
+
+\begin{datadesc}{opname}
+Sequence of operation names, indexable using the byte code.
+\end{datadesc}
+
+\begin{datadesc}{opmap}
+Dictionary mapping byte codes to operation names.
+\end{datadesc}
+
+\begin{datadesc}{cmp_op}
+Sequence of all compare operation names.
+\end{datadesc}
+
+\begin{datadesc}{hasconst}
+Sequence of byte codes that have a constant parameter.
+\end{datadesc}
+
+\begin{datadesc}{hasfree}
+Sequence of byte codes that access a free variable.
+\end{datadesc}
+
+\begin{datadesc}{hasname}
+Sequence of byte codes that access an attribute by name.
+\end{datadesc}
+
+\begin{datadesc}{hasjrel}
+Sequence of byte codes that have a relative jump target.
+\end{datadesc}
+
+\begin{datadesc}{hasjabs}
+Sequence of byte codes that have an absolute jump target.
+\end{datadesc}
+
+\begin{datadesc}{haslocal}
+Sequence of byte codes that access a local variable.
+\end{datadesc}
+
+\begin{datadesc}{hascompare}
+Sequence of byte codes of Boolean operations.
+\end{datadesc}
+
+\subsection{Python Byte Code Instructions}
+\label{bytecodes}
+
+The Python compiler currently generates the following byte code
+instructions.
+
+\setindexsubitem{(byte code insns)}
+
+\begin{opcodedesc}{STOP_CODE}{}
+Indicates end-of-code to the compiler, not used by the interpreter.
+\end{opcodedesc}
+
+\begin{opcodedesc}{NOP}{}
+Do nothing code.  Used as a placeholder by the bytecode optimizer.
+\end{opcodedesc}
+
+\begin{opcodedesc}{POP_TOP}{}
+Removes the top-of-stack (TOS) item.
+\end{opcodedesc}
+
+\begin{opcodedesc}{ROT_TWO}{}
+Swaps the two top-most stack items.
+\end{opcodedesc}
+
+\begin{opcodedesc}{ROT_THREE}{}
+Lifts second and third stack item one position up, moves top down
+to position three.
+\end{opcodedesc}
+
+\begin{opcodedesc}{ROT_FOUR}{}
+Lifts second, third and forth stack item one position up, moves top down to
+position four.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DUP_TOP}{}
+Duplicates the reference on top of the stack.
+\end{opcodedesc}
+
+Unary Operations take the top of the stack, apply the operation, and
+push the result back on the stack.
+
+\begin{opcodedesc}{UNARY_POSITIVE}{}
+Implements \code{TOS = +TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{UNARY_NEGATIVE}{}
+Implements \code{TOS = -TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{UNARY_NOT}{}
+Implements \code{TOS = not TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{UNARY_CONVERT}{}
+Implements \code{TOS = `TOS`}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{UNARY_INVERT}{}
+Implements \code{TOS = \~{}TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{GET_ITER}{}
+Implements \code{TOS = iter(TOS)}.
+\end{opcodedesc}
+
+Binary operations remove the top of the stack (TOS) and the second top-most
+stack item (TOS1) from the stack.  They perform the operation, and put the
+result back on the stack.
+
+\begin{opcodedesc}{BINARY_POWER}{}
+Implements \code{TOS = TOS1 ** TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_MULTIPLY}{}
+Implements \code{TOS = TOS1 * TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_DIVIDE}{}
+Implements \code{TOS = TOS1 / TOS} when
+\code{from __future__ import division} is not in effect.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_FLOOR_DIVIDE}{}
+Implements \code{TOS = TOS1 // TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_TRUE_DIVIDE}{}
+Implements \code{TOS = TOS1 / TOS} when
+\code{from __future__ import division} is in effect.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_MODULO}{}
+Implements \code{TOS = TOS1 \%{} TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_ADD}{}
+Implements \code{TOS = TOS1 + TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_SUBTRACT}{}
+Implements \code{TOS = TOS1 - TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_SUBSCR}{}
+Implements \code{TOS = TOS1[TOS]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_LSHIFT}{}
+Implements \code{TOS = TOS1 <\code{}< TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_RSHIFT}{}
+Implements \code{TOS = TOS1 >\code{}> TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_AND}{}
+Implements \code{TOS = TOS1 \&\ TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_XOR}{}
+Implements \code{TOS = TOS1 \^\ TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BINARY_OR}{}
+Implements \code{TOS = TOS1 | TOS}.
+\end{opcodedesc}
+
+In-place operations are like binary operations, in that they remove TOS and
+TOS1, and push the result back on the stack, but the operation is done
+in-place when TOS1 supports it, and the resulting TOS may be (but does not
+have to be) the original TOS1.
+
+\begin{opcodedesc}{INPLACE_POWER}{}
+Implements in-place \code{TOS = TOS1 ** TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_MULTIPLY}{}
+Implements in-place \code{TOS = TOS1 * TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_DIVIDE}{}
+Implements in-place \code{TOS = TOS1 / TOS} when
+\code{from __future__ import division} is not in effect.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_FLOOR_DIVIDE}{}
+Implements in-place \code{TOS = TOS1 // TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_TRUE_DIVIDE}{}
+Implements in-place \code{TOS = TOS1 / TOS} when
+\code{from __future__ import division} is in effect.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_MODULO}{}
+Implements in-place \code{TOS = TOS1 \%{} TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_ADD}{}
+Implements in-place \code{TOS = TOS1 + TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_SUBTRACT}{}
+Implements in-place \code{TOS = TOS1 - TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_LSHIFT}{}
+Implements in-place \code{TOS = TOS1 <\code{}< TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_RSHIFT}{}
+Implements in-place \code{TOS = TOS1 >\code{}> TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_AND}{}
+Implements in-place \code{TOS = TOS1 \&\ TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_XOR}{}
+Implements in-place \code{TOS = TOS1 \^\ TOS}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{INPLACE_OR}{}
+Implements in-place \code{TOS = TOS1 | TOS}.
+\end{opcodedesc}
+
+The slice opcodes take up to three parameters.
+
+\begin{opcodedesc}{SLICE+0}{}
+Implements \code{TOS = TOS[:]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SLICE+1}{}
+Implements \code{TOS = TOS1[TOS:]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SLICE+2}{}
+Implements \code{TOS = TOS1[:TOS]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SLICE+3}{}
+Implements \code{TOS = TOS2[TOS1:TOS]}.
+\end{opcodedesc}
+
+Slice assignment needs even an additional parameter.  As any statement,
+they put nothing on the stack.
+
+\begin{opcodedesc}{STORE_SLICE+0}{}
+Implements \code{TOS[:] = TOS1}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_SLICE+1}{}
+Implements \code{TOS1[TOS:] = TOS2}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_SLICE+2}{}
+Implements \code{TOS1[:TOS] = TOS2}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_SLICE+3}{}
+Implements \code{TOS2[TOS1:TOS] = TOS3}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_SLICE+0}{}
+Implements \code{del TOS[:]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_SLICE+1}{}
+Implements \code{del TOS1[TOS:]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_SLICE+2}{}
+Implements \code{del TOS1[:TOS]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_SLICE+3}{}
+Implements \code{del TOS2[TOS1:TOS]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_SUBSCR}{}
+Implements \code{TOS1[TOS] = TOS2}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_SUBSCR}{}
+Implements \code{del TOS1[TOS]}.
+\end{opcodedesc}
+
+Miscellaneous opcodes.
+
+\begin{opcodedesc}{PRINT_EXPR}{}
+Implements the expression statement for the interactive mode.  TOS is
+removed from the stack and printed.  In non-interactive mode, an
+expression statement is terminated with \code{POP_STACK}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{PRINT_ITEM}{}
+Prints TOS to the file-like object bound to \code{sys.stdout}.  There
+is one such instruction for each item in the \keyword{print} statement.
+\end{opcodedesc}
+
+\begin{opcodedesc}{PRINT_ITEM_TO}{}
+Like \code{PRINT_ITEM}, but prints the item second from TOS to the
+file-like object at TOS.  This is used by the extended print statement.
+\end{opcodedesc}
+
+\begin{opcodedesc}{PRINT_NEWLINE}{}
+Prints a new line on \code{sys.stdout}.  This is generated as the
+last operation of a \keyword{print} statement, unless the statement
+ends with a comma.
+\end{opcodedesc}
+
+\begin{opcodedesc}{PRINT_NEWLINE_TO}{}
+Like \code{PRINT_NEWLINE}, but prints the new line on the file-like
+object on the TOS.  This is used by the extended print statement.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BREAK_LOOP}{}
+Terminates a loop due to a \keyword{break} statement.
+\end{opcodedesc}
+
+\begin{opcodedesc}{CONTINUE_LOOP}{target}
+Continues a loop due to a \keyword{continue} statement.  \var{target}
+is the address to jump to (which should be a \code{FOR_ITER}
+instruction).
+\end{opcodedesc}
+
+\begin{opcodedesc}{LIST_APPEND}{}
+Calls \code{list.append(TOS1, TOS)}.  Used to implement list comprehensions.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_LOCALS}{}
+Pushes a reference to the locals of the current scope on the stack.
+This is used in the code for a class definition: After the class body
+is evaluated, the locals are passed to the class definition.
+\end{opcodedesc}
+
+\begin{opcodedesc}{RETURN_VALUE}{}
+Returns with TOS to the caller of the function.
+\end{opcodedesc}
+
+\begin{opcodedesc}{YIELD_VALUE}{}
+Pops \code{TOS} and yields it from a generator.
+\end{opcodedesc}
+
+\begin{opcodedesc}{IMPORT_STAR}{}
+Loads all symbols not starting with \character{_} directly from the module TOS
+to the local namespace. The module is popped after loading all names.
+This opcode implements \code{from module import *}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{EXEC_STMT}{}
+Implements \code{exec TOS2,TOS1,TOS}.  The compiler fills
+missing optional parameters with \code{None}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{POP_BLOCK}{}
+Removes one block from the block stack.  Per frame, there is a 
+stack of blocks, denoting nested loops, try statements, and such.
+\end{opcodedesc}
+
+\begin{opcodedesc}{END_FINALLY}{}
+Terminates a \keyword{finally} clause.  The interpreter recalls
+whether the exception has to be re-raised, or whether the function
+returns, and continues with the outer-next block.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BUILD_CLASS}{}
+Creates a new class object.  TOS is the methods dictionary, TOS1
+the tuple of the names of the base classes, and TOS2 the class name.
+\end{opcodedesc}
+
+All of the following opcodes expect arguments.  An argument is two
+bytes, with the more significant byte last.
+
+\begin{opcodedesc}{STORE_NAME}{namei}
+Implements \code{name = TOS}. \var{namei} is the index of \var{name}
+in the attribute \member{co_names} of the code object.
+The compiler tries to use \code{STORE_LOCAL} or \code{STORE_GLOBAL}
+if possible.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_NAME}{namei}
+Implements \code{del name}, where \var{namei} is the index into
+\member{co_names} attribute of the code object.
+\end{opcodedesc}
+
+\begin{opcodedesc}{UNPACK_SEQUENCE}{count}
+Unpacks TOS into \var{count} individual values, which are put onto
+the stack right-to-left.
+\end{opcodedesc}
+
+%\begin{opcodedesc}{UNPACK_LIST}{count}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+%\begin{opcodedesc}{UNPACK_ARG}{count}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+\begin{opcodedesc}{DUP_TOPX}{count}
+Duplicate \var{count} items, keeping them in the same order. Due to
+implementation limits, \var{count} should be between 1 and 5 inclusive.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_ATTR}{namei}
+Implements \code{TOS.name = TOS1}, where \var{namei} is the index
+of name in \member{co_names}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_ATTR}{namei}
+Implements \code{del TOS.name}, using \var{namei} as index into
+\member{co_names}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_GLOBAL}{namei}
+Works as \code{STORE_NAME}, but stores the name as a global.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_GLOBAL}{namei}
+Works as \code{DELETE_NAME}, but deletes a global name.
+\end{opcodedesc}
+
+%\begin{opcodedesc}{UNPACK_VARARG}{argc}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_CONST}{consti}
+Pushes \samp{co_consts[\var{consti}]} onto the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_NAME}{namei}
+Pushes the value associated with \samp{co_names[\var{namei}]} onto the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BUILD_TUPLE}{count}
+Creates a tuple consuming \var{count} items from the stack, and pushes
+the resulting tuple onto the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BUILD_LIST}{count}
+Works as \code{BUILD_TUPLE}, but creates a list.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BUILD_MAP}{zero}
+Pushes a new empty dictionary object onto the stack.  The argument is
+ignored and set to zero by the compiler.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_ATTR}{namei}
+Replaces TOS with \code{getattr(TOS, co_names[\var{namei}])}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{COMPARE_OP}{opname}
+Performs a Boolean operation.  The operation name can be found
+in \code{cmp_op[\var{opname}]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{IMPORT_NAME}{namei}
+Imports the module \code{co_names[\var{namei}]}.  The module object is
+pushed onto the stack.  The current namespace is not affected: for a
+proper import statement, a subsequent \code{STORE_FAST} instruction
+modifies the namespace.
+\end{opcodedesc}
+
+\begin{opcodedesc}{IMPORT_FROM}{namei}
+Loads the attribute \code{co_names[\var{namei}]} from the module found in
+TOS. The resulting object is pushed onto the stack, to be subsequently
+stored by a \code{STORE_FAST} instruction.
+\end{opcodedesc}
+
+\begin{opcodedesc}{JUMP_FORWARD}{delta}
+Increments byte code counter by \var{delta}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{JUMP_IF_TRUE}{delta}
+If TOS is true, increment the byte code counter by \var{delta}.  TOS is
+left on the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{JUMP_IF_FALSE}{delta}
+If TOS is false, increment the byte code counter by \var{delta}.  TOS
+is not changed. 
+\end{opcodedesc}
+
+\begin{opcodedesc}{JUMP_ABSOLUTE}{target}
+Set byte code counter to \var{target}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{FOR_ITER}{delta}
+\code{TOS} is an iterator.  Call its \method{next()} method.  If this
+yields a new value, push it on the stack (leaving the iterator below
+it).  If the iterator indicates it is exhausted  \code{TOS} is
+popped, and the byte code counter is incremented by \var{delta}.
+\end{opcodedesc}
+
+%\begin{opcodedesc}{FOR_LOOP}{delta}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+%\begin{opcodedesc}{LOAD_LOCAL}{namei}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_GLOBAL}{namei}
+Loads the global named \code{co_names[\var{namei}]} onto the stack.
+\end{opcodedesc}
+
+%\begin{opcodedesc}{SET_FUNC_ARGS}{argc}
+%This opcode is obsolete.
+%\end{opcodedesc}
+
+\begin{opcodedesc}{SETUP_LOOP}{delta}
+Pushes a block for a loop onto the block stack.  The block spans
+from the current instruction with a size of \var{delta} bytes.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SETUP_EXCEPT}{delta}
+Pushes a try block from a try-except clause onto the block stack.
+\var{delta} points to the first except block.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SETUP_FINALLY}{delta}
+Pushes a try block from a try-except clause onto the block stack.
+\var{delta} points to the finally block.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_FAST}{var_num}
+Pushes a reference to the local \code{co_varnames[\var{var_num}]} onto
+the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_FAST}{var_num}
+Stores TOS into the local \code{co_varnames[\var{var_num}]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{DELETE_FAST}{var_num}
+Deletes local \code{co_varnames[\var{var_num}]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_CLOSURE}{i}
+Pushes a reference to the cell contained in slot \var{i} of the
+cell and free variable storage.  The name of the variable is 
+\code{co_cellvars[\var{i}]} if \var{i} is less than the length of
+\var{co_cellvars}.  Otherwise it is 
+\code{co_freevars[\var{i} - len(co_cellvars)]}.
+\end{opcodedesc}
+
+\begin{opcodedesc}{LOAD_DEREF}{i}
+Loads the cell contained in slot \var{i} of the cell and free variable
+storage.  Pushes a reference to the object the cell contains on the
+stack. 
+\end{opcodedesc}
+
+\begin{opcodedesc}{STORE_DEREF}{i}
+Stores TOS into the cell contained in slot \var{i} of the cell and
+free variable storage.
+\end{opcodedesc}
+
+\begin{opcodedesc}{SET_LINENO}{lineno}
+This opcode is obsolete.
+\end{opcodedesc}
+
+\begin{opcodedesc}{RAISE_VARARGS}{argc}
+Raises an exception. \var{argc} indicates the number of parameters
+to the raise statement, ranging from 0 to 3.  The handler will find
+the traceback as TOS2, the parameter as TOS1, and the exception
+as TOS.
+\end{opcodedesc}
+
+\begin{opcodedesc}{CALL_FUNCTION}{argc}
+Calls a function.  The low byte of \var{argc} indicates the number of
+positional parameters, the high byte the number of keyword parameters.
+On the stack, the opcode finds the keyword parameters first.  For each
+keyword argument, the value is on top of the key.  Below the keyword
+parameters, the positional parameters are on the stack, with the
+right-most parameter on top.  Below the parameters, the function object
+to call is on the stack.
+\end{opcodedesc}
+
+\begin{opcodedesc}{MAKE_FUNCTION}{argc}
+Pushes a new function object on the stack.  TOS is the code associated
+with the function.  The function object is defined to have \var{argc}
+default parameters, which are found below TOS.
+\end{opcodedesc}
+
+\begin{opcodedesc}{MAKE_CLOSURE}{argc}
+Creates a new function object, sets its \var{func_closure} slot, and
+pushes it on the stack.  TOS is the code associated with the function.
+If the code object has N free variables, the next N items on the stack
+are the cells for these variables.  The function also has \var{argc}
+default parameters, where are found before the cells.
+\end{opcodedesc}
+
+\begin{opcodedesc}{BUILD_SLICE}{argc}
+Pushes a slice object on the stack.  \var{argc} must be 2 or 3.  If it
+is 2, \code{slice(TOS1, TOS)} is pushed; if it is 3,
+\code{slice(TOS2, TOS1, TOS)} is pushed.
+See the \code{slice()}\bifuncindex{slice} built-in function for more
+information.
+\end{opcodedesc}
+
+\begin{opcodedesc}{EXTENDED_ARG}{ext}
+Prefixes any opcode which has an argument too big to fit into the
+default two bytes.  \var{ext} holds two additional bytes which, taken
+together with the subsequent opcode's argument, comprise a four-byte
+argument, \var{ext} being the two most-significant bytes.
+\end{opcodedesc}
+
+\begin{opcodedesc}{CALL_FUNCTION_VAR}{argc}
+Calls a function. \var{argc} is interpreted as in \code{CALL_FUNCTION}.
+The top element on the stack contains the variable argument list, followed
+by keyword and positional arguments.
+\end{opcodedesc}
+
+\begin{opcodedesc}{CALL_FUNCTION_KW}{argc}
+Calls a function. \var{argc} is interpreted as in \code{CALL_FUNCTION}.
+The top element on the stack contains the keyword arguments dictionary, 
+followed by explicit keyword and positional arguments.
+\end{opcodedesc}
+
+\begin{opcodedesc}{CALL_FUNCTION_VAR_KW}{argc}
+Calls a function. \var{argc} is interpreted as in
+\code{CALL_FUNCTION}.  The top element on the stack contains the
+keyword arguments dictionary, followed by the variable-arguments
+tuple, followed by explicit keyword and positional arguments.
+\end{opcodedesc}
+
+\begin{opcodedesc}{HAVE_ARGUMENT}{}
+This is not really an opcode.  It identifies the dividing line between
+opcodes which don't take arguments \code{< HAVE_ARGUMENT} and those which do
+\code{>= HAVE_ARGUMENT}.
+\end{opcodedesc}