Commits

camlspotter committed d38d5cb

merge

Comments (0)

Files changed (5)

 module Index = Index
 module Import = Import
 module Iter = Iter
-module Int = Int
 module Callable = Callable
 module Sequence = Sequence
 module Eval = Eval
     tpl
 
 end
+
+module Err = struct
+  include Err
+    
+  external reraise : unit -> unit = "pyerror"
+    (** reraise the current exception. 
+	Err.Occured() must be return Some. Otherwise Failwith is raised instead. *)
+end
+
+module Int = struct
+  include Int
+
+  let asLong t =
+    let res = asLong t in
+    if res <> -1 then res
+    else match Err.occurred () with
+    | None -> -1
+    | Some _ -> Err.clear (); raise (Error_by_string "Int.asLong: failed")
+end
 type size_t = int
 
 exception Error of t
+exception Error_by_string of string
 #define PyObject_noincr_c2ml(c) (Val_PyObject_noincr_exc_at_null(*c))
 #define PyObject_incr_ml2c(value,c) (*c = PyObject_val(value), Py_INCREF(*c))
 #define PyObject_option_ml2c(value,c) (*c = PyObject_opt_val(value))
-// #define PyObject_option_c2ml(c) (Val_PyObject_opt(*c))
+#define PyObject_option_c2ml(c) (Val_PyObject_opt(*c, 0))
 #define unit_or_fail_c2ml(p) (Plus_or_fail(*p))
 #define bool_or_fail_c2ml(p) (Plus_or_fail(*p))
 #define size_or_fail_c2ml(p) (Plus_or_fail(*p))
 typedef int Py_ssize_t; // not sure
 typedef int size_t; // not sure
 
+// Exceptions
+
+void PyErr_PrintEx(boolean set_sys_last_vars);
+// Print a standard traceback to sys.stderr and clear the error indicator. Call this function only when the error indicator is set. (Otherwise it will cause a fatal error!)
+// If set_sys_last_vars is nonzero, the variables sys.last_type, sys.last_value and sys.last_traceback will be set to the type, value and traceback of the printed exception, respectively.
+
+void PyErr_Print();
+// Alias for PyErr_PrintEx(1).
+
+[option] PyObject* PyErr_Occurred();
+// Return value: Borrowed reference.
+// Test whether the error indicator is set. If set, return the exception type (the first argument to the last call to one of the PyErr_Set*() functions or to PyErr_Restore()). If not set, return NULL. You do not own a reference to the return value, so you do not need to Py_DECREF() it.
+//
+// Note Do not compare the return value to a specific exception; use PyErr_ExceptionMatches() instead, shown below. (The comparison could easily fail since the exception may be an instance instead of a class, in the case of a class exception, or it may the a subclass of the expected exception.)
+
+int PyErr_ExceptionMatches(PyObject *exc);
+// Equivalent to PyErr_GivenExceptionMatches(PyErr_Occurred(), exc). This should only be called when an exception is actually set; a memory access violation will occur if no exception has been raised.;
+
+boolean PyErr_GivenExceptionMatches(PyObject *given, PyObject *exc);
+// Return true if the given exception matches the exception in exc. If exc is a class object, this also returns true when given is an instance of a subclass. If exc is a tuple, all exceptions in the tuple (and recursively in subtuples) are searched for a match.
+
+// void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb)
+// Under certain circumstances, the values returned by PyErr_Fetch() below can be “unnormalized”, meaning that *exc is a class object but *val is not an instance of the same class. This function can be used to instantiate the class in that case. If the values are already normalized, nothing happens. The delayed normalization is implemented to improve performance.
+
+void PyErr_Clear();
+// Clear the error indicator. If the error indicator is not set, there is no effect.
+
+// void PyErr_Fetch(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback)
+// Retrieve the error indicator into three variables whose addresses are passed. If the error indicator is not set, set all three variables to NULL. If it is set, it will be cleared and you own a reference to each object retrieved. The value and traceback object may be NULL even when the type object is not.
+// Note This function is normally only used by code that needs to handle exceptions or by code that needs to save and restore the error indicator temporarily.
+
+// void PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
+// Set the error indicator from the three objects. If the error indicator is already set, it is cleared first. If the objects are NULL, the error indicator is cleared. Do not pass a NULL type and non-NULL value or traceback. The exception type should be a class. Do not pass an invalid exception type or value. (Violating these rules will cause subtle problems later.) This call takes away a reference to each object: you must own a reference to each object before the call and after the call you no longer own these references. (If you don’t understand this, don’t use this function. I warned you.)
+// Note This function is normally only used by code that needs to save and restore the error indicator temporarily; use PyErr_Fetch() to save the current exception state.
+
+void PyErr_SetString(PyObject *type, [string] const char *message);
+// This is the most common way to set the error indicator. The first argument specifies the exception type; it is normally one of the standard exceptions, e.g. PyExc_RuntimeError. You need not increment its reference count. The second argument is an error message; it is converted to a string object.
+
+void PyErr_SetObject(PyObject *type, PyObject *value);
+// This function is similar to PyErr_SetString() but lets you specify an arbitrary Python object for the “value” of the exception.
+
+// PyObject* PyErr_Format(PyObject *exception, const char *format, ...)
+// Return value: Always NULL.
+// This function sets the error indicator and returns NULL. exception should be a Python exception (class, not an instance). format should be a string, containing format codes, similar to printf(). The width.precision before a format code is parsed, but the width part is ignored.
+
+void PyErr_SetNone(PyObject *type);
+// This is a shorthand for PyErr_SetObject(type, Py_None).
+
+int PyErr_BadArgument();
+// This is a shorthand for PyErr_SetString(PyExc_TypeError, message), where message indicates that a built-in operation was invoked with an illegal argument. It is mostly for internal use.
+
+// [null] PyObject* PyErr_NoMemory();
+// Return value: Always NULL.
+// This is a shorthand for PyErr_SetNone(PyExc_MemoryError); it returns NULL so an object allocation function can write return PyErr_NoMemory(); when it runs out of memory.
+
+// [null] PyObject* PyErr_SetFromErrno(PyObject *type);
+// Return value: Always NULL.
+// This is a convenience function to raise an exception when a C library function has returned an error and set the C variable errno. It constructs a tuple object whose first item is the integer errno value and whose second item is the corresponding error message (gotten from strerror()), and then calls PyErr_SetObject(type, object). On Unix, when the errno value is EINTR, indicating an interrupted system call, this calls PyErr_CheckSignals(), and if that set the error indicator, leaves it set to that. The function always returns NULL, so a wrapper function around a system call can write return PyErr_SetFromErrno(type); when the system call returns an error.
+
+// [null] PyObject* PyErr_SetFromErrnoWithFilename(PyObject *type, const char *filename)
+// Return value: Always NULL.
+// Similar to PyErr_SetFromErrno(), with the additional behavior that if filename is not NULL, it is passed to the constructor of type as a third parameter. In the case of exceptions such as IOError and OSError, this is used to define the filename attribute of the exception instance.
+
+// [null] PyObject* PyErr_SetFromWindowsErr(int ierr);
+// Return value: Always NULL.
+// This is a convenience function to raise WindowsError. If called with ierr of 0, the error code returned by a call to GetLastError() is used instead. It calls the Win32 function FormatMessage() to retrieve the Windows description of error code given by ierr or GetLastError(), then it constructs a tuple object whose first item is the ierr value and whose second item is the corresponding error message (gotten from FormatMessage()), and then calls PyErr_SetObject(PyExc_WindowsError, object). This function always returns NULL. Availability: Windows.
+
+// [null] PyObject* PyErr_SetExcFromWindowsErr(PyObject *type, int ierr)
+// Return value: Always NULL.
+// Similar to PyErr_SetFromWindowsErr(), with an additional parameter specifying the exception type to be raised. Availability: Windows.
+
+// [null] PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, [string] const char *filename)
+// Return value: Always NULL.
+// Similar to PyErr_SetFromWindowsErr(), with the additional behavior that if filename is not NULL, it is passed to the constructor of WindowsError as a third parameter. Availability: Windows.
+
+// [null] PyObject* PyErr_SetExcFromWindowsErrWithFilename(PyObject *type, int ierr, char *filename)
+// Return value: Always NULL.
+// Similar to PyErr_SetFromWindowsErrWithFilename(), with an additional parameter specifying the exception type to be raised. Availability: Windows.
+
+void PyErr_BadInternalCall();
+// This is a shorthand for PyErr_SetString(PyExc_SystemError, message), where message indicates that an internal operation (e.g. a Python/C API function) was invoked with an illegal argument. It is mostly for internal use.
+
+// int PyErr_WarnEx(PyObject *category, [string] char *message, int stacklevel);
+// Issue a warning message. The category argument is a warning category (see below) or NULL; the message argument is a message string. stacklevel is a positive number giving a number of stack frames; the warning will be issued from the currently executing line of code in that stack frame. A stacklevel of 1 is the function calling PyErr_WarnEx(), 2 is the function above that, and so forth.
+// This function normally prints a warning message to sys.stderr; however, it is also possible that the user has specified that warnings are to be turned into errors, and in that case this will raise an exception. It is also possible that the function raises an exception because of a problem with the warning machinery (the implementation imports the warnings module to do the heavy lifting). The return value is 0 if no exception is raised, or -1 if an exception is raised. (It is not possible to determine whether a warning message is actually printed, nor what the reason is for the exception; this is intentional.) If an exception is raised, the caller should do its normal exception handling (for example, Py_DECREF() owned references and return an error value).
+// Warning categories must be subclasses of Warning; the default warning category is RuntimeWarning. The standard Python warning categories are available as global variables whose names are PyExc_ followed by the Python exception name. These have the type PyObject*; they are all class objects. Their names are PyExc_Warning, PyExc_UserWarning, PyExc_UnicodeWarning, PyExc_DeprecationWarning, PyExc_SyntaxWarning, PyExc_RuntimeWarning, and PyExc_FutureWarning. PyExc_Warning is a subclass of PyExc_Exception; the other warning categories are subclasses of PyExc_Warning.
+// For information about warning control, see the documentation for the warnings module and the -W option in the command line documentation. There is no C API for warning control.
+
+// int PyErr_Warn(PyObject *category, [string] char *message);
+// Issue a warning message. The category argument is a warning category (see below) or NULL; the message argument is a message string. The warning will appear to be issued from the function calling PyErr_Warn(), equivalent to calling PyErr_WarnEx() with a stacklevel of 1.
+// 
+// Deprecated; use PyErr_WarnEx() instead.
+
+// int PyErr_WarnExplicit(PyObject *category, const char *message, const char *filename, int lineno, const char *module, PyObject *registry)
+// Issue a warning message with explicit control over all warning attributes. This is a straightforward wrapper around the Python function warnings.warn_explicit(), see there for more information. The module and registry arguments may be set to NULL to get the default effect described there.
+
+// int PyErr_WarnPy3k(char *message, int stacklevel)
+// Issue a DeprecationWarning with the given message and stacklevel if the Py_Py3kWarningFlag flag is enabled.
+
+// int PyErr_CheckSignals()
+// This function interacts with Python’s signal handling. It checks whether a signal has been sent to the processes and if so, invokes the corresponding signal handler. If the signal module is supported, this can invoke a signal handler written in Python. In all cases, the default effect for SIGINT is to raise the KeyboardInterrupt exception. If an exception is raised the error indicator is set and the function returns -1; otherwise the function returns 0. The error indicator may or may not be cleared if it was previously set.
+
+// void PyErr_SetInterrupt()
+// aThis function simulates the effect of a SIGINT signal arriving  the next time PyErr_CheckSignals() is called, KeyboardInterrupt will be raised. It may be called without holding the interpreter lock.
+
+// int PySignal_SetWakeupFd(int fd)
+// This utility function specifies a file descriptor to which a '\0' byte will be written whenever a signal is received. It returns the previous such file descriptor. The value -1 disables the feature; this is the initial state. This is equivalent to signal.set_wakeup_fd() in Python, but without any error checking. fd should be a valid file descriptor. The function should only be called from the main thread.
+
+[new] PyObject* PyErr_NewException([string] char *name, PyObject *base, PyObject *dict);
+// Return value: New reference.
+// This utility function creates and returns a new exception object. The name argument must be the name of the new exception, a C string of the form module.class. The base and dict arguments are normally NULL. This creates a class object derived from Exception (accessible in C as PyExc_Exception).
+// The __module__ attribute of the new class is set to the first part (up to the last dot) of the name argument, and the class name is set to the last part (after the last dot). The base argument can be used to specify alternate base classes; it can either be only one class or a tuple of classes. The dict argument can be used to specify a dictionary of class variables and methods.
+
+// [new] PyObject* PyErr_NewExceptionWithDoc([string] char *name, [string] char *doc, PyObject *base, PyObject *dict);
+// Return value: New reference.
+// Same as PyErr_NewException(), except that the new exception class can easily be given a docstring: If doc is non-NULL, it will be used as the docstring for the exception class.
+// New in version 2.7.
+
+void PyErr_WriteUnraisable(PyObject *obj);
+// This utility function prints a warning message to sys.stderr when an exception has been set but it is impossible for the interpreter to actually raise the exception. It is used, for example, when an exception occurs in an __del__() method.
+// The function is called with a single argument obj that identifies the context in which the unraisable exception occurred. The repr of obj will be printed in the warning message.
+
+// Recursion Control
+// These two functions provide a way to perform safe recursive calls at the C level, both in the core and in extension modules. They are needed if the recursive code does not necessarily invoke Python code (which tracks its recursion depth automatically).
+// 
+// int Py_EnterRecursiveCall(char *where)
+// Marks a point where a recursive C-level call is about to be performed.
+// 
+// If USE_STACKCHECK is defined, this function checks if the the OS stack overflowed using PyOS_CheckStack(). In this is the case, it sets a MemoryError and returns a nonzero value.
+// 
+// The function then checks if the recursion limit is reached. If this is the case, a RuntimeError is set and a nonzero value is returned. Otherwise, zero is returned.
+// 
+// where should be a string such as " in instance check" to be concatenated to the RuntimeError message caused by the recursion depth limit.
+// 
+// void Py_LeaveRecursiveCall()
+// Ends a Py_EnterRecursiveCall(). Must be called once for each successful invocation of Py_EnterRecursiveCall().
+// 
+
 // ------------------- Object Protocol http://docs.python.org/c-api/object.html
 
 // int PyObject_Print(PyObject *o, FILE *fp, int flags)
 [new] PyObject* PyInt_FromSize_t(size_t ival);
 //    Create a new integer object with a value of ival. If the value exceeds LONG_MAX, a long integer object is returned.
 
-// long PyInt_AsLong(PyObject *io);
+long PyInt_AsLong(PyObject *io);
 //    Will first attempt to cast the object to a PyIntObject, if it is not already one, and then return its value. If there is an error, -1 is returned, and the caller should check PyErr_Occurred() to find out whether there was an error, or whether the value just happened to be -1.
 
 // long PyInt_AS_LONG(PyObject *io);
 
 int PyTuple_ClearFreeList();
 // Clear the free list. Return the total number of freed items.
+
+// very high level layer ----------------- 
+// int Py_Main(int argc, char **argv);
+// The main program for the standard interpreter. This is made available for programs which embed Python. The argc and argv parameters should be prepared exactly as those which are passed to a C program’s main() function. It is important to note that the argument list may be modified (but the contents of the strings pointed to by the argument list are not). The return value will be the integer passed to the sys.exit() function, 1 if the interpreter exits due to an exception, or 2 if the parameter list does not represent a valid Python command line.
+// 
+// Note that if an otherwise unhandled SystemError is raised, this function will not return 1, but exit the process, as long as Py_InspectFlag is not set.
+
+// int PyRun_AnyFile(FILE *fp, const char *filename);
+// This is a simplified interface to PyRun_AnyFileExFlags() below, leaving closeit set to 0 and flags set to NULL.
+
+// int PyRun_AnyFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags);
+// This is a simplified interface to PyRun_AnyFileExFlags() below, leaving the closeit argument set to 0.
+
+// int PyRun_AnyFileEx(FILE *fp, const char *filename, int closeit);
+// This is a simplified interface to PyRun_AnyFileExFlags() below, leaving the flags argument set to NULL.
+
+// int PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags);
+// If fp refers to a file associated with an interactive device (console or terminal input or Unix pseudo-terminal), return the value of PyRun_InteractiveLoop(), otherwise return the result of PyRun_SimpleFile(). If filename is NULL, this function uses "???" as the filename.
+
+unit_or_fail PyRun_SimpleString([string] const char *command); // CR jfuruse: We cannot get exception.
+// This is a simplified interface to PyRun_SimpleStringFlags() below, leaving the PyCompilerFlags* argument set to NULL.
+
+// int PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags);
+// Executes the Python source code from command in the __main__ module according to the flags argument. If __main__ does not already exist, it is created. Returns 0 on success or -1 if an exception was raised. If there was an error, there is no way to get the exception information. For the meaning of flags, see below.
+// 
+// Note that if an otherwise unhandled SystemError is raised, this function will not return -1, but exit the process, as long as Py_InspectFlag is not set.
+
+// int PyRun_SimpleFile(FILE *fp, const char *filename);
+// This is a simplified interface to PyRun_SimpleFileExFlags() below, leaving closeit set to 0 and flags set to NULL.
+
+// int PyRun_SimpleFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags);
+// This is a simplified interface to PyRun_SimpleFileExFlags() below, leaving closeit set to 0.
+
+// int PyRun_SimpleFileEx(FILE *fp, const char *filename, int closeit);
+// This is a simplified interface to PyRun_SimpleFileExFlags() below, leaving flags set to NULL.
+
+// int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags);
+// Similar to PyRun_SimpleStringFlags(), but the Python source code is read from fp instead of an in-memory string. filename should be the name of the file. If closeit is true, the file is closed before PyRun_SimpleFileExFlags returns.
+
+// int PyRun_InteractiveOne(FILE *fp, const char *filename);
+// This is a simplified interface to PyRun_InteractiveOneFlags() below, leaving flags set to NULL.
+
+// int PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags);
+// Read and execute a single statement from a file associated with an interactive device according to the flags argument. If filename is NULL, "???" is used instead. The user will be prompted using sys.ps1 and sys.ps2. Returns 0 when the input was executed successfully, -1 if there was an exception, or an error code from the errcode.h include file distributed as part of Python if there was a parse error. (Note that errcode.h is not included by Python.h, so must be included specifically if needed.)
+
+// int PyRun_InteractiveLoop(FILE *fp, const char *filename);
+// This is a simplified interface to PyRun_InteractiveLoopFlags() below, leaving flags set to NULL.
+
+// int PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags);
+// Read and execute statements from a file associated with an interactive device until EOF is reached. If filename is NULL, "???" is used instead. The user will be prompted using sys.ps1 and sys.ps2. Returns 0 at EOF.
+
+// struct _node* PyParser_SimpleParseString(const char *str, int start);
+// This is a simplified interface to PyParser_SimpleParseStringFlagsFilename() below, leaving filename set to NULL and flags set to 0.
+
+// struct _node* PyParser_SimpleParseStringFlags(const char *str, int start, int flags);
+// This is a simplified interface to PyParser_SimpleParseStringFlagsFilename() below, leaving filename set to NULL.
+
+// struct _node* PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename, int start, int flags);
+// Parse Python source code from str using the start token start according to the flags argument. The result can be used to create a code object which can be evaluated efficiently. This is useful if a code fragment must be evaluated many times.
+
+// struct _node* PyParser_SimpleParseFile(FILE *fp, const char *filename, int start);
+// This is a simplified interface to PyParser_SimpleParseFileFlags() below, leaving flags set to 0
+
+// struct _node* PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags);
+// Similar to PyParser_SimpleParseStringFlagsFilename(), but the Python source code is read from fp instead of an in-memory string.
+
+// PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals);
+// Return value: New reference.
+// This is a simplified interface to PyRun_StringFlags() below, leaving flags set to NULL.
+
+// PyObject* PyRun_StringFlags([string] const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags);
+// Return value: New reference.
+// Execute Python source code from str in the context specified by the dictionaries globals and locals with the compiler flags specified by flags. The parameter start specifies the start token that should be used to parse the source code.
+//
+// Returns the result of executing the code as a Python object, or NULL if an exception was raised.
+
+// PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals);
+// Return value: New reference.
+// This is a simplified interface to PyRun_FileExFlags() below, leaving closeit set to 0 and flags set to NULL.
+
+// PyObject* PyRun_FileEx(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit);
+// Return value: New reference.
+// This is a simplified interface to PyRun_FileExFlags() below, leaving flags set to NULL.
+
+// PyObject* PyRun_FileFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags);
+// Return value: New reference.
+// This is a simplified interface to PyRun_FileExFlags() below, leaving closeit set to 0.
+
+// aPyObject* PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit, PyCompilerFlags *flags);
+// Return value: New reference.
+// Similar to PyRun_StringFlags(), but the Python source code is read from fp instead of an in-memory string. filename should be the name of the file. If closeit is true, the file is closed before PyRun_FileExFlags() returns.
+
+// PyObject* Py_CompileString(const char *str, const char *filename, int start);
+// Return value: New reference.
+// This is a simplified interface to Py_CompileStringFlags() below, leaving flags set to NULL.
+
+// PyObject* Py_CompileStringFlags(const char *str, const char *filename, int start, PyCompilerFlags *flags);
+// Return value: New reference.
+// Parse and compile the Python source code in str, returning the resulting code object. The start token is given by start; this can be used to constrain the code which can be compiled and should be Py_eval_input, Py_file_input, or Py_single_input. The filename specified by filename is used to construct the code object and may appear in tracebacks or SyntaxError exception messages. This returns NULL if the code cannot be parsed or compiled.
+
+// PyObject* PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals);
+// Return value: New reference.
+// This is a simplified interface to PyEval_EvalCodeEx(), with just the code object, and the dictionaries of global and local variables. The other arguments are set to NULL.
+
+// PyObject* PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, PyObject **defs, int defcount, PyObject *closure);
+// Evaluate a precompiled code object, given a particular environment for its evaluation. This environment consists of dictionaries of global and local variables, arrays of arguments, keywords and defaults, and a closure tuple of cells.
+
+// PyObject* PyEval_EvalFrame(PyFrameObject *f);
+// Evaluate an execution frame. This is a simplified interface to PyEval_EvalFrameEx, for backward compatibility.
+
+// PyObject* PyEval_EvalFrameEx(PyFrameObject *f, int throwflag);
+// This is the main, unvarnished function of Python interpretation. It is literally 2000 lines long. The code object associated with the execution frame f is executed, interpreting bytecode and executing calls as needed. The additional throwflag parameter can mostly be ignored - if true, then it causes an exception to immediately be thrown; this is used for the throw() methods of generator objects.
+
+// int PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
+// This function changes the flags of the current evaluation frame, and returns true on success, false on failure.
+
+// int Py_eval_input
+// The start symbol from the Python grammar for isolated expressions; for use with Py_CompileString().
+
+// int Py_file_input
+// The start symbol from the Python grammar for sequences of statements as read from a file or other source; for use with Py_CompileString(). This is the symbol to use when compiling arbitrarily long Python source code.
+
+// int Py_single_input
+// The start symbol from the Python grammar for a single statement; for use with Py_CompileString(). This is the symbol used for the interactive interpreter loop.
+
+// struct PyCompilerFlags
+// This is the structure used to hold compiler flags. In cases where code is only being compiled, it is passed as int flags, and in cases where code is being executed, it is passed as PyCompilerFlags *flags. In this case, from __future__ import can modify flags.
+//
+// Whenever PyCompilerFlags *flags is NULL, cf_flags is treated as equal to 0, and any modification due to from __future__ import is discarded.
+// 
+// struct PyCompilerFlags {
+//     int cf_flags;
+// }
+
+// int CO_FUTURE_DIVISION
+// This bit can be set in flags to cause division operator / to be interpreted as “true division” according to PEP 238.
     prerr_endline (String.asString res);
     prerr_endline (String.asString o);
 
+    let minus_1 = Int.fromLong (-1) in
+    assert (Int.asLong minus_1 = -1); 
+
     Base.finalize ()
   with
   | Error e -> Printf.eprintf "Error: %s\n%!" (String.asString (Object.repr e))