+#include "example.h"
+
+int ivar = 0;
+short svar = 0;
+long lvar = 0;
+unsigned int uivar = 0;
+unsigned short usvar = 0;
+unsigned long ulvar = 0;
+signed char scvar = 0;
+unsigned char ucvar = 0;
+char cvar = 0;
+float fvar = 0;
+double dvar = 0;
+char *strvar = 0;
+const char *cstrvar = 0;
+int *iptrvar = 0;
+char name[256] = "Dave";
+char path[256] = "/home/beazley";
+
+
+/* Global variables involving a structure */
+Point *ptptr = 0;
+Point pt = { 10, 20 };
+
+/* A variable that we will make read-only in the interface */
+int status = 1;
+
+/* A debugging function to print out their values */
+
+void print_vars() {
+ printf("ivar = %d\n", ivar);
+ printf("svar = %d\n", svar);
+ printf("lvar = %ld\n", lvar);
+ printf("uivar = %u\n", uivar);
+ printf("usvar = %u\n", usvar);
+ printf("ulvar = %lu\n", ulvar);
+ printf("scvar = %d\n", scvar);
+ printf("ucvar = %u\n", ucvar);
+ printf("fvar = %g\n", fvar);
+ printf("dvar = %g\n", dvar);
+ printf("cvar = %c\n", cvar);
+ printf("strvar = %s\n", strvar ? strvar : "(null)");
+ printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
+ printf("iptrvar = %x\n", iptrvar);
+ printf("name = %s\n", name);
+ printf("ptptr = %x (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("pt = (%d, %d)\n", pt.x, pt.y);
+ printf("status = %d\n", status);
+}
+
+/* A function to create an integer (to test iptrvar) */
+
+int *new_int(int value) {
+ int *ip = (int *) malloc(sizeof(int));
+ *ip = value;
+ return ip;
+}
+
+/* A function to create a point */
+
+Point *new_Point(int x, int y) {
+ Point *p = (Point *) malloc(sizeof(Point));
+ p->x = x;
+ p->y = y;
+ return p;
+}
+
+char * Point_print(Point *p) {
+ static char buffer[256];
+ if (p) {
+ sprintf(buffer,"(%d,%d)", p->x,p->y);
+ } else {
+ sprintf(buffer,"null");
+ }
+ return buffer;
+}
+
+void pt_print() {
+ printf("(%d, %d)\n", pt.x, pt.y);
+}
diff --git a/SWIG/Examples/python/variables/example.h b/SWIG/Examples/python/variables/example.h
new file mode 100644
index 000000000..0f7e89594
--- /dev/null
+++ b/SWIG/Examples/python/variables/example.h
@@ -0,0 +1,6 @@
+/* File: example.h */
+
+typedef struct {
+ int x,y;
+} Point;
+
diff --git a/SWIG/Examples/python/variables/example.i b/SWIG/Examples/python/variables/example.i
new file mode 100644
index 000000000..d62f973da
--- /dev/null
+++ b/SWIG/Examples/python/variables/example.i
@@ -0,0 +1,44 @@
+/* File : example.i */
+%module example
+%{
+#include "example.h"
+%}
+
+/* Some global variable declarations */
+extern int ivar;
+extern short svar;
+extern long lvar;
+extern unsigned int uivar;
+extern unsigned short usvar;
+extern unsigned long ulvar;
+extern signed char scvar;
+extern unsigned char ucvar;
+extern char cvar;
+extern float fvar;
+extern double dvar;
+extern char *strvar;
+extern const char *cstrvar;
+extern int *iptrvar;
+extern char name[256];
+
+extern Point *ptptr;
+extern Point pt;
+
+
+/* Some read-only variables */
+
+%readonly
+extern int status;
+extern char path[256];
+%readwrite
+
+/* Some helper functions to make it easier to test */
+extern void print_vars();
+extern int *new_int(int value);
+extern Point *new_Point(int x, int y);
+extern char *Point_print(Point *p);
+extern void pt_print();
+
+
+
+
diff --git a/SWIG/Examples/python/variables/example.py b/SWIG/Examples/python/variables/example.py
new file mode 100644
index 000000000..7aab7a38f
--- /dev/null
+++ b/SWIG/Examples/python/variables/example.py
@@ -0,0 +1,76 @@
+# file: example.py
+
+import example
+
+# Try to set the values of some global variables
+
+example.cvar.ivar = 42
+example.cvar.svar = -31000
+example.cvar.lvar = 65537
+example.cvar.uivar = 123456
+example.cvar.usvar = 61000
+example.cvar.ulvar = 654321
+example.cvar.scvar = -13
+example.cvar.ucvar = 251
+example.cvar.cvar = "S"
+example.cvar.fvar = 3.14159
+example.cvar.dvar = 2.1828
+example.cvar.strvar = "Hello World"
+example.cvar.cstrvar = "Goodbye"
+example.cvar.iptrvar= example.new_int(37)
+example.cvar.ptptr = example.new_Point(37,42)
+example.cvar.name = "Bill"
+
+# Now print out the values of the variables
+
+print "Variables (values printed from Python)"
+
+print "ivar =", example.cvar.ivar
+print "svar =", example.cvar.svar
+print "lvar =", example.cvar.lvar
+print "uivar =", example.cvar.uivar
+print "usvar =", example.cvar.usvar
+print "ulvar =", example.cvar.ulvar
+print "scvar =", example.cvar.scvar
+print "ucvar =", example.cvar.ucvar
+print "fvar =", example.cvar.fvar
+print "dvar =", example.cvar.dvar
+print "cvar =", example.cvar.cvar
+print "strvar =", example.cvar.strvar
+print "cstrvar =", example.cvar.cstrvar
+print "iptrvar =", example.cvar.iptrvar
+print "name =", example.cvar.name
+print "ptptr =", example.cvar.ptptr, example.Point_print(example.cvar.ptptr)
+print "pt =", example.cvar.pt, example.Point_print(example.cvar.pt)
+
+print "\nVariables (values printed from C)"
+
+example.print_vars()
+
+print "\nNow I'm going to try and modify some read only variables";
+
+print " Tring to set 'path'";
+try:
+ example.cvar.path = "Whoa!"
+ print "Hey, what's going on?!?! This shouldn't work"
+except:
+ print "Good."
+
+print " Trying to set 'status'";
+try:
+ example.cvar.status = 0
+ print "Hey, what's going on?!?! This shouldn't work"
+except:
+ print "Good."
+
+
+print "\nI'm going to try and update a structure variable.\n"
+
+example.cvar.pt = example.cvar.ptptr
+
+print "The new value is"
+example.pt_print()
+print "You should see the value", example.Point_print(example.cvar.ptptr)
+
+
+
diff --git a/SWIG/Examples/python/variables/index.html b/SWIG/Examples/python/variables/index.html
new file mode 100644
index 000000000..12cacbf64
--- /dev/null
+++ b/SWIG/Examples/python/variables/index.html
@@ -0,0 +1,102 @@
+
+
+SWIG:Examples:python:variables
+
+
+
+
+SWIG/Examples/python/variables/
+
+
+Wrapping C Global Variables
+
+$Header$
+
+
+When a C global variable appears in an interface file, SWIG tries to
+wrap it using a technique known as "variable linking." The idea is
+pretty simple---we try to create a Python variable that magically
+retrieves or updates the value of the underlying C variable when it is
+accessed. Click here to see a SWIG interface with some variable
+declarations in it.
+
+
Manipulating Variables from Python
+
+Before going any further, it is important to understand some important
+differences between C and Python variables. In C, a variable is
+simply a name that refers to a specific location in memory. For
+example, when you declare a global variable 'double a' you
+know that somewhere in memory, 8 bytes have been set aside to hold a
+double and that a is bound to this location for the
+life of the program. In Python, variable creation is nothing more
+than a naming operation. For example, when you say 'a = 3',
+'a' becomes a name that refers to some object '3'. Later on, if you say
+'a = 7.5, the name 'a' is bound to an entirely different object
+containing the value '7.5' (the contents of the original object are not
+changed). The end result of this is that a variable in Python can refer
+to a virtually unlimited number of different objects (memory locations)
+over the lifetime of a program.
+
+
+Because of Python's somewhat unusual variable assignment semantics, it is not
+possible to directly link a C global variable into an equivalent Python variable.
+Instead, all C global variables are accessed as attributes of a special object
+called 'cvar'. For example, if you had a global variable
+
+
+
+double foo;
+
+
+
+it will be accessed in the Python module as cvar.foo. Click
+here to see a script that updates and prints
+out the values of the variables using this technique.
+
+Key points
+
+
+- When a global variable has the type "char *", SWIG manages it as a character
+string. However, whenever the value of such a variable is set from Python, the old
+value is destroyed using free() or delete (the choice of which depends
+on whether or not SWIG was run with the -c++ option).
+
- signed char and unsigned char are handled as small 8-bit integers.
+
- String array variables such as 'char name[256]' are managed as Python strings, but
+when setting the value, the result is truncated to the maximum length of the array. Furthermore, the string is assumed to be null-terminated.
+
- When structures and classes are used as global variables, they are mapped into pointers.
+Getting the "value" returns a pointer to the global variable. Setting the value of a structure results in a memory copy from a pointer to the global.
+
+
+Creating read-only variables
+
+The %readonly and %readwrite directives can be used to
+specify a collection of read-only variables. For example:
+
+
+
+%readonly
+int status;
+double blah;
+...
+%readwrite
+
+
+
+The %readonly directive remains in effect until it is explicitly disabled
+using the %readwrite directive.
+
+Comments
+
+- Management of global variables is one of the most problematic aspects
+of C/C++ wrapping because the scripting interface and resulting memory management
+is much trickier than simply creating a wrapper function.
+
+
- Because of the potential for a namespace conflict, you should not use
+the from module import * statement for a SWIG module with global
+variables. Doing so will cause a collision on the 'cvar' object should
+more than one module be loaded in this manner.
+
+
+
+
+
\ No newline at end of file