jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Major cleanup of comments

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@128 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-01-20 05:45:58 +00:00
commit fc2fb1ff98
25 changed files with 769 additions and 853 deletions
Download patch file Download diff file Expand all files Collapse all files

108
SWIG/Source/DOH/Doh/base.c
View file

@ -1,21 +1,17 @@
/****************************************************************************** /* -----------------------------------------------------------------------------
* DOH * base.c
*
* This file contains the function entry points for dispatching methods on
* DOH objects. A number of small utility functions are also included.
* *
* Author(s) : David Beazley (beazley@cs.uchicago.edu) * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Copyright (C) 1999-2000. The University of Chicago * Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution. * See the file LICENSE for information on usage and redistribution.
******************************************************************************/ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
/*******************************************************************************
* base.c
*
* This file contains the function entry points for dispatching methods on DOH
* objects.
*******************************************************************************/
#include "dohint.h" #include "dohint.h"
static DohObjInfo DohBaseType = { static DohObjInfo DohBaseType = {
@ -1096,6 +1092,54 @@ DohInit(DOH *b) {
bs->flags = 0; bs->flags = 0;
} }
/* -----------------------------------------------------------------------------
* DohXBase_setfile()
*
* Set file location (default method).
* ----------------------------------------------------------------------------- */
void
DohXBase_setfile(DOH *ho, DOH *file) {
DohXBase *h = (DohXBase *) ho;
if (!DohCheck(file)) file = NewString(file);
h->file = file;
Incref(h->file);
}
/* -----------------------------------------------------------------------------
* DohXBase_getfile()
* ----------------------------------------------------------------------------- */
DOH *
DohXBase_getfile(DOH *ho) {
DohXBase *h = (DohXBase *) ho;
return h->file;
}
/* -----------------------------------------------------------------------------
* DohXBase_setline()
* ----------------------------------------------------------------------------- */
void
DohXBase_setline(DOH *ho, int l) {
DohXBase *h = (DohXBase *) ho;
h->line = l;
}
/* -----------------------------------------------------------------------------
* DohXBase_getline()
* ----------------------------------------------------------------------------- */
int
DohXBase_getline(DOH *ho) {
DohXBase *h = (DohXBase *) ho;
return h->line;
}
static DohPositionalMethods XBasePositionalMethods = {
DohXBase_setfile,
DohXBase_getfile,
DohXBase_setline,
DohXBase_getline
};
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DohXInit() * DohXInit()
* *
@ -1106,47 +1150,9 @@ DohXInit(DOH *b) {
DohXBase *bs = (DohXBase *) b; DohXBase *bs = (DohXBase *) b;
bs->file = 0; bs->file = 0;
bs->line = 0; bs->line = 0;
} bs->objinfo->doh_position = &XBasePositionalMethods;
/* -----------------------------------------------------------------------------
* XBase_setfile()
*
* Set file location (default method).
* ----------------------------------------------------------------------------- */
void
XBase_setfile(DOH *ho, DOH *file) {
DohXBase *h = (DohXBase *) ho;
if (!DohCheck(file)) file = NewString(file);
h->file = file;
Incref(h->file);
}
/* -----------------------------------------------------------------------------
* XBase_getfile()
* ----------------------------------------------------------------------------- */
DOH *
XBase_getfile(DOH *ho) {
DohXBase *h = (DohXBase *) ho;
return h->file;
}
/* -----------------------------------------------------------------------------
* XBase_setline()
* ----------------------------------------------------------------------------- */
void
XBase_setline(DOH *ho, int l) {
DohXBase *h = (DohXBase *) ho;
h->line = l;
}
/* -----------------------------------------------------------------------------
* XBase_getline()
* ----------------------------------------------------------------------------- */
int
XBase_getline(DOH *ho) {
DohXBase *h = (DohXBase *) ho;
return h->line;
} }

15
SWIG/Source/DOH/Doh/callable.c
View file

@ -1,20 +1,17 @@
/****************************************************************************** /* -----------------------------------------------------------------------------
* DOH * callable.c
*
* This file implements a simple callable object supporting a function call
* operation.
* *
* Author(s) : David Beazley (beazley@cs.uchicago.edu) * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Copyright (C) 1999-2000. The University of Chicago * Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution. * See the file LICENSE for information on usage and redistribution.
******************************************************************************/ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
/* -----------------------------------------------------------------------------
* callable.c
*
* Implements a callable function-like object.
* ----------------------------------------------------------------------------- */
#include "dohint.h" #include "dohint.h"
typedef struct { typedef struct {

61
SWIG/Source/DOH/Doh/file.c
View file

@ -1,20 +1,17 @@
/****************************************************************************** /* -----------------------------------------------------------------------------
* DOH * file.c
*
* This file implements a file-like object that can be built around an
* ordinary FILE * or integer file descriptor.
* *
* Author(s) : David Beazley (beazley@cs.uchicago.edu) * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Copyright (C) 1999-2000. The University of Chicago * Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution. * See the file LICENSE for information on usage and redistribution.
******************************************************************************/ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
/* ---------------------------------------------------------------------------
* file.c
*
* This file implements a DOH file-like object.
* --------------------------------------------------------------------------- */
#include "dohint.h" #include "dohint.h"
#include <unistd.h> #include <unistd.h>
@ -26,7 +23,9 @@ typedef struct {
} DohFile; } DohFile;
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DelFile(DOH *s) - Delete a file * DelFile()
*
* Delete a file. Closes the file if the closeondel flag is set.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
@ -39,9 +38,9 @@ DelFile(DOH *so) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_read(DOH *so, void *buffer, int len) * File_read()
* *
* Read data from the File * Reads data from a file into a buffer.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
@ -54,10 +53,11 @@ File_read(DOH *so, void *buffer, int len) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_write(DOH *so, void *buffer, int len) * File_write()
* *
* Write data to the File * Write data from a buffer to a file.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
File_write(DOH *so, void *buffer, int len) { File_write(DOH *so, void *buffer, int len) {
DohFile *s = (DohFile *) so; DohFile *s = (DohFile *) so;
@ -68,10 +68,11 @@ File_write(DOH *so, void *buffer, int len) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_seek(DOH *so, long offset, int whence) * File_seek()
* *
* Seek to a new position * Seek to a new file position.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
File_seek(DOH *so, long offset, int whence) { File_seek(DOH *so, long offset, int whence) {
DohFile *s = (DohFile *) so; DohFile *s = (DohFile *) so;
@ -82,10 +83,11 @@ File_seek(DOH *so, long offset, int whence) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* long File_tell(DOH *so) * File_tell()
* *
* Return current position * Return current file pointer.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static long static long
File_tell(DOH *so) { File_tell(DOH *so) {
DohFile *s = (DohFile *) so; DohFile *s = (DohFile *) so;
@ -96,7 +98,7 @@ File_tell(DOH *so) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_putc(DOH *obj, int ch) * File_putc()
* *
* Put a character on the output * Put a character on the output
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -110,7 +112,7 @@ File_putc(DOH *obj, int ch) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_getc(DOH *obj) * File_getc()
* *
* Get a character * Get a character
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -124,7 +126,7 @@ File_getc(DOH *obj) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_ungetc(DOH *obj, int ch) * File_ungetc()
* *
* Put a character back onto the input * Put a character back onto the input
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -171,8 +173,11 @@ static DohObjInfo DohFileType = {
}; };
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* NewFile(DOH *filename, char *mode) * NewFile()
*
* Create a new file from a given filename and mode.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
NewFile(DOH *fn, char *mode) NewFile(DOH *fn, char *mode)
{ {
@ -197,7 +202,9 @@ NewFile(DOH *fn, char *mode)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* NewFileFromFile(FILE *f) * NewFileFromFile()
*
* Create a file object from an already open FILE *.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
@ -214,7 +221,9 @@ NewFileFromFile(FILE *file)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* NewFileFromFd(int fd) * NewFileFromFd()
*
* Create a file object from an already existing integer file descriptor.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
@ -232,7 +241,9 @@ NewFileFromFd(int fd)
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int File_check(DOH *f) - Check if f is a file * File_check()
*
* Check if an object is a file.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int int
File_check(DOH *f) File_check(DOH *f)

106
SWIG/Source/DOH/Doh/fio.c
View file

@ -1,31 +1,30 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH (Dynamic Object Hack)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header:";
/* -----------------------------------------------------------------------------
* fio.c * fio.c
* *
* This file provides support for formatted I/O via fprint style * This file implements a number of standard I/O operations included
* functions. * formatted output, readline, and splitting.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header:";
#include "dohint.h" #include "dohint.h"
#define OBUFLEN 512 #define OBUFLEN 512
static DOH *encodings = 0; /* Encoding hash */
/* -----------------------------------------------------------------------------
* Writen()
*
* Write's N characters of output and retries until all characters are
* written. This is useful should a write operation encounter a spurious signal.
* ----------------------------------------------------------------------------- */
static int Writen(DOH *out, void *buffer, int len) { static int Writen(DOH *out, void *buffer, int len) {
int nw = len, ret; int nw = len, ret;
char *cb = (char *) buffer; char *cb = (char *) buffer;
@ -39,18 +38,19 @@ static int Writen(DOH *out, void *buffer, int len) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void DohEncoding(char *name, DOH *(*fn)(DOH *s)) * DohEncoding()
* *
* Register a printf named encoding method. * Registers a new printf encoding method. An encoder function should accept
* two file-like objects and operate as a filter.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH *encodings = 0; void
void DohEncoding(char *name, DOH *(*fn)(DOH *s)) DohEncoding(char *name, DOH *(*fn)(DOH *s)) {
{
if (!encodings) encodings = NewHash(); if (!encodings) encodings = NewHash();
Setattr(encodings,(void *) name, NewVoid((void *)fn,0)); Setattr(encodings,(void *) name, NewVoid((void *)fn,0));
} }
/* internal function for processing an encoding */
static DOH *encode(char *name, DOH *s) { static DOH *encode(char *name, DOH *s) {
DOH *handle, *ns; DOH *handle, *ns;
DOH *(*fn)(DOH *); DOH *(*fn)(DOH *);
@ -67,9 +67,21 @@ static DOH *encode(char *name, DOH *s) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DohvPrintf(DOH *so, char *format, va_list ap) * DohvPrintf()
* *
* printf * DOH implementation of printf. Output can be directed to any file-like object
* including bare FILE * objects. The same formatting codes as printf are
* recognized with two extensions:
*
* %s - Prints a "char *" or the string representation of any
* DOH object. This will implicitly result in a call to
* Str(obj).
*
* %(encoder)* - Filters the output through an encoding function registered
* with DohEncoder().
*
* Note: This function is not particularly memory efficient with large strings.
* It's better to use Dump() or some other method instead.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int int
@ -357,8 +369,14 @@ DohvPrintf(DOH *so, char *format, va_list ap)
return nbytes; return nbytes;
} }
/* Printf */ /* -----------------------------------------------------------------------------
int DohPrintf(DOH *obj, char *format, ...) { * DohPrintf()
*
* Variable length argument entry point to Printf
* ----------------------------------------------------------------------------- */
int
DohPrintf(DOH *obj, char *format, ...) {
va_list ap; va_list ap;
int ret; int ret;
va_start(ap,format); va_start(ap,format);
@ -367,9 +385,15 @@ int DohPrintf(DOH *obj, char *format, ...) {
return ret; return ret;
} }
/* DohCopyto(DOH *in, DOH *out) */ /* -----------------------------------------------------------------------------
* DohCopyto()
*
* Copies all of the input from an input stream to an output stream. Returns the
* number of bytes copied.
* ----------------------------------------------------------------------------- */
int DohCopyto(DOH *in, DOH *out) { int
DohCopyto(DOH *in, DOH *out) {
int nbytes = 0, ret; int nbytes = 0, ret;
int nwrite = 0, wret; int nwrite = 0, wret;
char *cw; char *cw;
@ -394,9 +418,16 @@ int DohCopyto(DOH *in, DOH *out) {
} }
} }
/* Split by a character */
DOH *DohSplit(DOH *in, char *chs, int nsplits) { /* -----------------------------------------------------------------------------
* DohSplit()
*
* Split an input stream into a list of strings delimeted by characters in a
* string. Optionally accepts a maximum number of splits to perform.
* ----------------------------------------------------------------------------- */
DOH *
DohSplit(DOH *in, char *chs, int nsplits) {
DOH *list; DOH *list;
DOH *str; DOH *str;
int c; int c;
@ -425,9 +456,14 @@ DOH *DohSplit(DOH *in, char *chs, int nsplits) {
return list; return list;
} }
/* Read a single line of text */ /* -----------------------------------------------------------------------------
* DohReadline()
*
* Read a single input line and return it as a string.
* ----------------------------------------------------------------------------- */
DOH *DohReadline(DOH *in) { DOH *
DohReadline(DOH *in) {
char c; char c;
int n = 0; int n = 0;
DOH *s = NewString(""); DOH *s = NewString("");

173
SWIG/Source/DOH/Doh/hash.c
View file

@ -1,25 +1,15 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$";
/***********************************************************************
* hash.c * hash.c
* *
* Hash table implementation. * Implements a simple hash table object.
***********************************************************************/ *
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "dohint.h" #include "dohint.h"
@ -40,12 +30,7 @@ typedef struct Hash {
HashNode *current; HashNode *current;
} Hash; } Hash;
/* ----------------------------------------------------------------------------- /* Key interning structure */
Key interning. This is used for getattr,setattr functions.
The following structure maps raw char * entries to string objects.
----------------------------------------------------------------------------- */
typedef struct KeyValue { typedef struct KeyValue {
char *cstr; char *cstr;
DOH *sstr; DOH *sstr;
@ -55,6 +40,7 @@ typedef struct KeyValue {
static KeyValue *root = 0; static KeyValue *root = 0;
/* Find or create a key in the interned key table */
static DOH *find_key(char *c) { static DOH *find_key(char *c) {
KeyValue *r, *s; KeyValue *r, *s;
int d = 0; int d = 0;
@ -85,8 +71,8 @@ static DOH *find_key(char *c) {
#define HASH_INIT_SIZE 7 #define HASH_INIT_SIZE 7
static HashNode *NewNode(DOH *k, void *obj) /* Create a new hash node */
{ static HashNode *NewNode(DOH *k, void *obj) {
HashNode *hn = (HashNode *) DohMalloc(sizeof(HashNode)); HashNode *hn = (HashNode *) DohMalloc(sizeof(HashNode));
hn->key = k; hn->key = k;
Incref(hn->key); Incref(hn->key);
@ -96,22 +82,21 @@ static HashNode *NewNode(DOH *k, void *obj)
return hn; return hn;
} }
static void DelNode(HashNode *hn) /* Delete a hash node */
{ static void DelNode(HashNode *hn) {
Delete(hn->key); Delete(hn->key);
Delete(hn->object); Delete(hn->object);
DohFree(hn); DohFree(hn);
} }
int Hash_check(DOH *);
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DelHash() - Delete a hash table * DelHash()
*
* Delete a hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
DelHash(DOH *ho) DelHash(DOH *ho) {
{
Hash *h; Hash *h;
HashNode *n,*next; HashNode *n,*next;
int i; int i;
@ -134,12 +119,13 @@ DelHash(DOH *ho)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Hash_clear(DOH *ho) - Clear all entries in a hash table * Hash_clear()
*
* Clear all of the entries in the hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
Hash_clear(DOH *ho) Hash_clear(DOH *ho) {
{
Hash *h; Hash *h;
HashNode *n,*next; HashNode *n,*next;
int i; int i;
@ -159,12 +145,13 @@ Hash_clear(DOH *ho)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Hash_scope(DOH *ho, int s) - Clear all entries in a hash table * Hash_scope()
*
* Change the scope of the hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
Hash_scope(DOH *ho, int s) Hash_scope(DOH *ho, int s) {
{
Hash *h; Hash *h;
HashNode *n; HashNode *n;
int i; int i;
@ -184,10 +171,7 @@ Hash_scope(DOH *ho, int s)
h->flags = h->flags & ~DOH_FLAG_SETSCOPE; h->flags = h->flags & ~DOH_FLAG_SETSCOPE;
} }
/* ----------------------------------------------------------------------------- /* resize the hash table */
* static resize(Hash *h) - Resizes the hash table
* ----------------------------------------------------------------------------- */
static void resize(Hash *h) { static void resize(Hash *h) {
HashNode *n, *next, **table; HashNode *n, *next, **table;
int oldsize, newsize; int oldsize, newsize;
@ -233,7 +217,10 @@ static void resize(Hash *h) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int Hash_setattr(DOH *h, DOH *k, DOH *obj) - Adds an object to a hash * Hash_setattr()
*
* Set an attribute in the hash table. Deletes the existing entry if it already
* exists.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
@ -280,7 +267,9 @@ Hash_setattr(DOH *ho, DOH *k, DOH *obj) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *Hash_getattr(DOH *ho, DOH *k) - Get an item from the hash table * Hash_getattr()
*
* Get an attribute from the hash table. Returns 0 if it doesn't exist.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
@ -301,12 +290,13 @@ Hash_getattr(DOH *ho, DOH *k) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Hash_delattr(DOH *ho, DOH *k) - Delete an element from the table * Hash_delattr()
*
* Delete an object from the hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
Hash_delattr(DOH *ho, DOH *k) Hash_delattr(DOH *ho, DOH *k) {
{
HashNode *n, *prev; HashNode *n, *prev;
int hv; int hv;
Hash *h; Hash *h;
@ -334,10 +324,7 @@ Hash_delattr(DOH *ho, DOH *k)
return 0; return 0;
} }
/* ----------------------------------------------------------------------------- /* General purpose iterators */
* Iterators
* ----------------------------------------------------------------------------- */
static HashNode * static HashNode *
hash_first(DOH *ho) { hash_first(DOH *ho) {
Hash *h = (Hash *) ho; Hash *h = (Hash *) ho;
@ -367,41 +354,39 @@ hash_next(DOH *ho) {
h->current = h->hashtable[h->currentindex]; h->current = h->hashtable[h->currentindex];
return h->current; return h->current;
} }
static DOH * /* -----------------------------------------------------------------------------
Hash_first(DOH *ho) { * Hash_firstkey()
HashNode *hn = hash_first(ho); *
if (hn) return hn->object; * Return first hash-table key.
return 0; * ----------------------------------------------------------------------------- */
}
static DOH * static DOH *
Hash_next(DOH *ho) Hash_firstkey(DOH *ho) {
{
HashNode *hn = hash_next(ho);
if (hn) return hn->object;
return 0;
}
static DOH *
Hash_firstkey(DOH *ho)
{
HashNode *hn = hash_first(ho); HashNode *hn = hash_first(ho);
if (hn) return hn->key; if (hn) return hn->key;
return 0; return 0;
} }
/* -----------------------------------------------------------------------------
* Hash_nextkey()
*
* Return next hash table key.
* ----------------------------------------------------------------------------- */
static DOH * static DOH *
Hash_nextkey(DOH *ho) Hash_nextkey(DOH *ho) {
{
HashNode *hn = hash_next(ho); HashNode *hn = hash_next(ho);
if (hn) return hn->key; if (hn) return hn->key;
return 0; return 0;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* String *Hash_str(DOH *ho) - Create a string representation of a hash * Hash_str()
*
* Create a string representation of a hash table (mainly for debugging).
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
Hash_str(DOH *ho) { Hash_str(DOH *ho) {
int i; int i;
@ -430,7 +415,9 @@ Hash_str(DOH *ho) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Hash_len(DOH *) * Hash_len()
*
* Return number of entries in the hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
@ -444,7 +431,6 @@ Hash_len(DOH *ho) {
* *
* Return a list of keys * Return a list of keys
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
Hash_keys(DOH *so) { Hash_keys(DOH *so) {
DOH *keys; DOH *keys;
@ -461,7 +447,9 @@ Hash_keys(DOH *so) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *CopyHash(DOH *ho) - Copy a hash table * CopyHash()
*
* Make a copy of a hash table. Note: this is a shallow copy.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
@ -471,6 +459,7 @@ CopyHash(DOH *ho) {
int i; int i;
h = (Hash *) ho; h = (Hash *) ho;
nh = (Hash *) DohObjMalloc(sizeof(Hash)); nh = (Hash *) DohObjMalloc(sizeof(Hash));
nh->objinfo = h->objinfo;
DohXInit(h); DohXInit(h);
nh->hashsize = h->hashsize; nh->hashsize = h->hashsize;
nh->hashtable = (HashNode **) DohMalloc(nh->hashsize*sizeof(HashNode *)); nh->hashtable = (HashNode **) DohMalloc(nh->hashsize*sizeof(HashNode *));
@ -480,7 +469,6 @@ CopyHash(DOH *ho) {
nh->currentindex = -1; nh->currentindex = -1;
nh->current = 0; nh->current = 0;
nh->nitems = 0; nh->nitems = 0;
nh->objinfo = h->objinfo;
nh->line = h->line; nh->line = h->line;
nh->file = h->file; nh->file = h->file;
if (nh->file) Incref(nh->file); if (nh->file) Incref(nh->file);
@ -508,13 +496,6 @@ static DohMappingMethods HashMappingMethods = {
Hash_nextkey, Hash_nextkey,
}; };
static DohPositionalMethods HashPositionalMethods = {
XBase_setfile,
XBase_getfile,
XBase_setline,
XBase_getline
};
static DohObjInfo HashType = { static DohObjInfo HashType = {
"Hash", /* objname */ "Hash", /* objname */
sizeof(Hash), /* size */ sizeof(Hash), /* size */
@ -534,10 +515,17 @@ static DohObjInfo HashType = {
0, /* doh_file */ 0, /* doh_file */
0, /* doh_string */ 0, /* doh_string */
0, /* doh_callable */ 0, /* doh_callable */
&HashPositionalMethods, /* doh_positional */ 0, /* doh_positional */
}; };
int Hash_check(DOH *so) { /* -----------------------------------------------------------------------------
* Hash_check()
*
* Return 1 if an object is a hash table object.
* ----------------------------------------------------------------------------- */
int
Hash_check(DOH *so) {
Hash *h = (Hash *) so; Hash *h = (Hash *) so;
if (!h) return 0; if (!h) return 0;
if (!DohCheck(so)) return 0; if (!DohCheck(so)) return 0;
@ -546,13 +534,17 @@ int Hash_check(DOH *so) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* NewHash() - Create a new hash table * NewHash()
*
* Create a new hash table.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH *NewHash() { DOH *
NewHash() {
Hash *h; Hash *h;
int i; int i;
h = (Hash *) DohObjMalloc(sizeof(Hash)); h = (Hash *) DohObjMalloc(sizeof(Hash));
h->objinfo = &HashType;
DohXInit(h); DohXInit(h);
h->hashsize = HASH_INIT_SIZE; h->hashsize = HASH_INIT_SIZE;
h->hashtable = (HashNode **) DohMalloc(h->hashsize*sizeof(HashNode *)); h->hashtable = (HashNode **) DohMalloc(h->hashsize*sizeof(HashNode *));
@ -562,8 +554,9 @@ DOH *NewHash() {
h->currentindex = -1; h->currentindex = -1;
h->current = 0; h->current = 0;
h->nitems = 0; h->nitems = 0;
h->objinfo = &HashType;
return (DOH *) h; return (DOH *) h;
} }

177
SWIG/Source/DOH/Doh/list.c
View file

@ -1,26 +1,16 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH * list.c
*
* Implements a simple list object.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
/*******************************************************************************
* File : list.c
*
* General purpose structure for keeping a list of reference counted Swig objects.
*******************************************************************************/
#include "dohint.h" #include "dohint.h"
typedef struct List { typedef struct List {
@ -31,9 +21,7 @@ typedef struct List {
DOH **items; DOH **items;
} List; } List;
int List_check(DOH *); /* Doubles amount of memory in a list */
/* Internal function. Doubles amount of memory in a list */
static static
void more(List *l) { void more(List *l) {
int i; int i;
@ -52,7 +40,9 @@ void more(List *l) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *CopyList(DOH *l) - Copy a list * CopyList()
*
* Make a shallow copy of a list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
@ -61,8 +51,8 @@ CopyList(DOH *lo) {
int i; int i;
l = (List *) lo; l = (List *) lo;
nl = (List *) DohObjMalloc(sizeof(List)); nl = (List *) DohObjMalloc(sizeof(List));
DohXInit(nl);
nl->objinfo = l->objinfo; nl->objinfo = l->objinfo;
DohXInit(nl);
nl->nitems = l->nitems; nl->nitems = l->nitems;
nl->maxitems = l->maxitems; nl->maxitems = l->maxitems;
nl->items = (void **) DohMalloc(l->maxitems*sizeof(void *)); nl->items = (void **) DohMalloc(l->maxitems*sizeof(void *));
@ -80,7 +70,9 @@ CopyList(DOH *lo) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void DelList(DOH *l) - Delete a list * DelList()
*
* Delete a list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
@ -99,7 +91,9 @@ DelList(DOH *lo) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void List_clear(DOH *l) - Clear all elements in the list * List_clear()
*
* Remove all of the list entries, but keep the list object intact.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
@ -115,8 +109,11 @@ List_clear(DOH *lo) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void List_scope(DOH *lo, int s) * List_scope()
*
* Change the scope setting of the list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static void static void
List_scope(DOH *lo, int s) { List_scope(DOH *lo, int s) {
List *l; List *l;
@ -132,18 +129,19 @@ List_scope(DOH *lo, int s) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void List_insert(DOH *lo, int pos, DOH *item) - Insert an element * List_insert()
*
* Insert an item into the list. If the item is not a DOH object, it is assumed
* to be a 'char *' and is used to construct an equivalent string object.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
List_insert(DOH *lo, int pos, DOH *item) List_insert(DOH *lo, int pos, DOH *item) {
{
List *l; List *l;
DohBase *b; DohBase *b;
int i, no = 0; int i, no = 0;
if (!item) return -1; if (!item) return -1;
l = (List *) lo; l = (List *) lo;
if (!DohCheck(item)) { if (!DohCheck(item)) {
@ -168,12 +166,13 @@ List_insert(DOH *lo, int pos, DOH *item)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void List_remove(DOH *lo, int pos) - Remove an element * List_remove()
*
* Remove an item from a list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
List_remove(DOH *lo, int pos) List_remove(DOH *lo, int pos) {
{
List *l; List *l;
DOH *item; DOH *item;
int i; int i;
@ -192,22 +191,24 @@ List_remove(DOH *lo, int pos)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int List_len(DOH *l) - List length * List_len()
*
* Return the number of elements in the list
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
List_len(DOH *lo) List_len(DOH *lo) {
{
return ((List *) lo)->nitems; return ((List *) lo)->nitems;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *List_get(DOH *lo, int n) - Get an item * List_get()
*
* Get the nth item from the list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
List_get(DOH *lo, int n) List_get(DOH *lo, int n) {
{
List *l; List *l;
l = (List *) lo; l = (List *) lo;
if (n == DOH_END) n = l->nitems-1; if (n == DOH_END) n = l->nitems-1;
@ -219,12 +220,13 @@ List_get(DOH *lo, int n)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int List_set(DOH *lo, int n, DOH *val) - Set an item * List_set()
*
* Set the nth item in the list replacing any previous item.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
List_set(DOH *lo, int n, DOH *val) List_set(DOH *lo, int n, DOH *val) {
{
List *l; List *l;
int no = 0; int no = 0;
l = (List *) lo; l = (List *) lo;
@ -246,12 +248,13 @@ List_set(DOH *lo, int n, DOH *val)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Iterators * List_first()
*
* Return the first item in the list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
List_first(DOH *lo) List_first(DOH *lo) {
{
List *l; List *l;
l = (List *) lo; l = (List *) lo;
l->iter = 0; l->iter = 0;
@ -259,9 +262,14 @@ List_first(DOH *lo)
return l->items[l->iter]; return l->items[l->iter];
} }
/* -----------------------------------------------------------------------------
* List_next()
*
* Return the next item in the list.
* ----------------------------------------------------------------------------- */
static DOH * static DOH *
List_next(DOH *lo) List_next(DOH *lo) {
{
List *l; List *l;
l = (List *) lo; l = (List *) lo;
l->iter++; l->iter++;
@ -270,12 +278,12 @@ List_next(DOH *lo)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* String *List_str() - Create a string representation * List_str()
*
* Create a string representation of the list
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static DOH * static DOH *
List_str(DOH *lo) List_str(DOH *lo) {
{
DOH *s; DOH *s;
int i; int i;
@ -297,6 +305,12 @@ List_str(DOH *lo)
return s; return s;
} }
/* -----------------------------------------------------------------------------
* List_dump()
*
* Dump the items to an output stream.
* ----------------------------------------------------------------------------- */
static int static int
List_dump(DOH *lo, DOH *out) { List_dump(DOH *lo, DOH *out) {
int nsent = 0; int nsent = 0;
@ -310,26 +324,6 @@ List_dump(DOH *lo, DOH *out) {
return nsent; return nsent;
} }
/* -----------------------------------------------------------------------------
* void List_sort(DOH *DOH)
*
* Sorts a list
* ----------------------------------------------------------------------------- */
static int objcmp(const void *s1, const void *s2) {
DOH **so1, **so2;
so1 = (DOH **) s1;
so2 = (DOH **) s2;
return Cmp(*so1,*so2);
}
void List_sort(DOH *so) {
List *l;
if (!List_check(so)) return;
l = (List *) so;
qsort(l->items,l->nitems,sizeof(DOH *), objcmp);
}
#define MAXLISTITEMS 8 #define MAXLISTITEMS 8
static DohSequenceMethods ListSeqMethods = { static DohSequenceMethods ListSeqMethods = {
@ -341,13 +335,6 @@ static DohSequenceMethods ListSeqMethods = {
List_next, List_next,
}; };
static DohPositionalMethods ListPositionalMethods = {
XBase_setfile,
XBase_getfile,
XBase_setline,
XBase_getline
};
static DohObjInfo ListType = { static DohObjInfo ListType = {
"List", /* objname */ "List", /* objname */
sizeof(List), /* List size */ sizeof(List), /* List size */
@ -367,13 +354,14 @@ static DohObjInfo ListType = {
0, /* doh_file */ 0, /* doh_file */
0, /* doh_string */ 0, /* doh_string */
0, /* doh_callable */ 0, /* doh_callable */
&ListPositionalMethods, /* doh_position */ 0, /* doh_position */
}; };
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* List_check(DOH *lo) - Check to see if an object is a list * List_check()
*
* Return 1 if an object is a List object.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int int
List_check(DOH *lo) { List_check(DOH *lo) {
List *l = (List *) lo; List *l = (List *) lo;
@ -384,7 +372,9 @@ List_check(DOH *lo) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* NewList() - Create a new list * NewList()
*
* Create a new list.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
@ -392,8 +382,8 @@ NewList() {
List *l; List *l;
int i; int i;
l = (List *) DohObjMalloc(sizeof(List)); l = (List *) DohObjMalloc(sizeof(List));
DohXInit(l);
l->objinfo = &ListType; l->objinfo = &ListType;
DohXInit(l);
l->nitems = 0; l->nitems = 0;
l->maxitems = MAXLISTITEMS; l->maxitems = MAXLISTITEMS;
l->items = (void **) DohMalloc(l->maxitems*sizeof(void *)); l->items = (void **) DohMalloc(l->maxitems*sizeof(void *));
@ -403,3 +393,24 @@ NewList() {
l->iter = 0; l->iter = 0;
return (DOH *) l; return (DOH *) l;
} }
/* -----------------------------------------------------------------------------
* List_sort()
*
* Sorts a list
* ----------------------------------------------------------------------------- */
static int objcmp(const void *s1, const void *s2) {
DOH **so1, **so2;
so1 = (DOH **) s1;
so2 = (DOH **) s2;
return Cmp(*so1,*so2);
}
void
List_sort(DOH *so) {
List *l;
if (!List_check(so)) return;
l = (List *) so;
qsort(l->items,l->nitems,sizeof(DOH *), objcmp);
}

161
SWIG/Source/DOH/Doh/memory.c
View file

@ -1,17 +1,14 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH (Dynamic Object Hack) * memory.c
*
* This file implements all of DOH's memory management including allocation
* of objects, checking of objects, and garbage collection.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
@ -33,14 +30,7 @@ static int _DohMemoryCurrent = 0;
static int _DohMemoryHigh = 0; static int _DohMemoryHigh = 0;
static int _PoolSize = DOH_POOL_SIZE; static int _PoolSize = DOH_POOL_SIZE;
DOH *DohNone = 0; DOH *DohNone = 0; /* The DOH None object */
/* -----------------------------------------------------------------------------
* memory.c
*
* Doh memory manager. Keeps pools of memory around for allocating objects.
* Pools are used to determine if an object is really a Doh object or not.
* ----------------------------------------------------------------------------- */
typedef struct fragment { typedef struct fragment {
char *ptr; /* Pointer to fragment */ char *ptr; /* Pointer to fragment */
@ -64,13 +54,13 @@ static int nscopes = 0;
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Pool *CreatePool(int size) * CreatePool()
* *
* Create a new pool * Create a new memory pool
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
Pool *CreatePool(int size) static Pool *
{ CreatePool(int size) {
Pool *p = 0; Pool *p = 0;
char *c; char *c;
c = (char *) DohMalloc(size); c = (char *) DohMalloc(size);
@ -85,12 +75,13 @@ Pool *CreatePool(int size)
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void InitPools() * InitPools()
* *
* Initialize the memory allocator * Initialize the memory allocator
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
static void InitPools() { static void
InitPools() {
int i; int i;
if (pools_initialized) return; if (pools_initialized) return;
for (i = 0; i < DOH_MAX_FRAG; i++) { for (i = 0; i < DOH_MAX_FRAG; i++) {
@ -107,12 +98,14 @@ static void InitPools() {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* int DohCheck(DOH *ptr) * DohCheck()
* *
* Check if ptr is an object we created. * Returns 1 if an arbitrary pointer is a DOH object. This determination
* is made according to the pointer value only.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
int DohCheck(DOH *ptr) { int
DohCheck(DOH *ptr) {
Pool *p = Pools; Pool *p = Pools;
char *cptr = (char *) ptr; char *cptr = (char *) ptr;
while (p) { while (p) {
@ -123,12 +116,14 @@ int DohCheck(DOH *ptr) {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* int DohObjFreeCheck(DOH *ptr) * DohObjFreeCheck()
* *
* Check if ptr is an object that has been deleted. * Checks to see if an object was already deleted. Useful when tracking
* down nasty double-free problems.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
int DohObjFreeCheck(DOH *ptr) { int
DohObjFreeCheck(DOH *ptr) {
int i; int i;
Fragment *f; Fragment *f;
char *cptr = (char *) ptr; char *cptr = (char *) ptr;
@ -143,12 +138,13 @@ int DohObjFreeCheck(DOH *ptr) {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* int DohNewScope() * DohNewScope()
* *
* Create a new scope in which objects will be placed * Create a new scope in which objects will be placed. Returns a scope
* identifier.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
int DohNewScope() int
{ DohNewScope() {
assert(nscopes < DOH_MAX_SCOPES); assert(nscopes < DOH_MAX_SCOPES);
if (!pools_initialized) InitPools(); if (!pools_initialized) InitPools();
scopes[nscopes] = 0; scopes[nscopes] = 0;
@ -157,11 +153,13 @@ int DohNewScope()
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void DohDelScope(int s) - Delete scope s * DohDelScope()
*
* Deletes a scope.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
void DohDelScope(int s) void
{ DohDelScope(int s) {
int ns; int ns;
DohBase *b, *b1; DohBase *b, *b1;
ns = s; ns = s;
@ -193,9 +191,14 @@ void DohDelScope(int s)
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void real_objfree(DOH *ptr) - Free a DOH object for real. * real_objfree()
*
* This is the function that actually frees an object. Invoked by the
* garbage collector.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
static void real_objfree(DOH *ptr) {
static void
real_objfree(DOH *ptr) {
DohBase *b; DohBase *b;
Fragment *f; Fragment *f;
b = (DohBase *) ptr; b = (DohBase *) ptr;
@ -213,7 +216,7 @@ static void real_objfree(DOH *ptr) {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void DohGarbageCollect() * DohGarbageCollect()
* *
* This walks through all of the scopes and does garbage collection. * This walks through all of the scopes and does garbage collection.
* *
@ -259,12 +262,13 @@ DohGarbageCollect() {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void *DohObjMalloc(size_t size) * DohObjMalloc()
* *
* Allocate an object * Allocate memory for a new object.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
void *DohObjMalloc(size_t size) { void *
DohObjMalloc(size_t size) {
Pool *p; Pool *p;
Fragment *f; Fragment *f;
void *ptr = 0; void *ptr = 0;
@ -329,14 +333,14 @@ void *DohObjMalloc(size_t size) {
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* void DohObjFree(DOH *ptr) * DohObjFree()
* *
* Free a DOH object. This function doesn't do much of anything with GC. * Frees a DOH object. Doesn't do much with GC.
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
void DohObjFree(DOH *ptr) { void
DohObjFree(DOH *ptr) {
DohBase *b; DohBase *b;
if (!DohCheck(ptr)) { if (!DohCheck(ptr)) {
DohTrace(DOH_MEMORY,"DohObjFree. %x not a DOH object!\n", ptr); DohTrace(DOH_MEMORY,"DohObjFree. %x not a DOH object!\n", ptr);
return; /* Oh well. Guess we're leaky */ return; /* Oh well. Guess we're leaky */
@ -349,71 +353,46 @@ void DohObjFree(DOH *ptr) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void *DohMalloc(size_t nbytes) * DohMalloc()
* *
* Wrapper around malloc() function. Records memory usage. * Wrapper around malloc() function. Records memory usage.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void *DohMalloc(size_t nbytes) { void *
char *ptr; DohMalloc(size_t nbytes) {
ptr = (char *) malloc(nbytes+8); return (void *) malloc(nbytes);
if (!ptr) return 0;
_DohMemoryCurrent += (nbytes+8);
if (_DohMemoryCurrent > _DohMemoryHigh) _DohMemoryHigh = _DohMemoryCurrent;
*((int *) ptr) = nbytes;
return (void *) (ptr+8);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void *DohRealloc(void *ptr, size_t newsize) * DohRealloc()
* *
* Wrapper around realloc() function. * Wrapper around realloc() function.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void *DohRealloc(void *ptr, size_t newsize) { void *
char *cptr = (char *) ptr; DohRealloc(void *ptr, size_t newsize) {
char *nptr; return (void *) realloc(ptr,newsize);
int size;
size = *((int *) (cptr - 8));
nptr = (char *) realloc(cptr-8,newsize+8);
if (!nptr) return 0;
*((int *) nptr) = newsize;
_DohMemoryCurrent += (newsize - size);
if (_DohMemoryCurrent > _DohMemoryHigh) _DohMemoryHigh = _DohMemoryCurrent;
return (void *) (nptr+8);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void DohFree(void *ptr) * DohFree()
* *
* Wrapper around free() function. Records memory usage. * Wrapper around free() function.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void DohFree(void *ptr) { void
char *cptr = (char *) ptr; DohFree(void *ptr) {
int size; free(ptr);
if (!ptr) return;
size = *((int *) (cptr - 8));
free(cptr-8);
_DohMemoryCurrent = _DohMemoryCurrent - (size+8);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int DohMemoryUse() * DohPoolSize()
* *
* Return bytes currently in use by Doh * Change the size of the memory pools used by DOH
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int DohMemoryUse() { int
return _DohMemoryCurrent; DohPoolSize(int poolsize) {
}
int DohMemoryHigh() {
return _DohMemoryHigh;
}
int DohPoolSize(int poolsize) {
int ps; int ps;
ps = _PoolSize; ps = _PoolSize;
if (poolsize > 0) { if (poolsize > 0) {

41
SWIG/Source/DOH/Doh/string.c
View file

@ -1,25 +1,16 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH (Dynamic Object Hack)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$";
/* ---------------------------------------------------------------------------
* string.c * string.c
* *
* String object. * Implements a string object that supports both sequence operations and
* --------------------------------------------------------------------------- */ * file semantics.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "dohint.h" #include "dohint.h"
@ -69,13 +60,6 @@ static DohSequenceMethods StringSeqMethods = {
0, /* doh_next */ 0, /* doh_next */
}; };
static DohPositionalMethods StringPositionalMethods = {
XBase_setfile,
XBase_getfile,
XBase_setline,
XBase_getline
};
static DohFileMethods StringFileMethods = { static DohFileMethods StringFileMethods = {
String_read, String_read,
String_write, String_write,
@ -111,7 +95,7 @@ static DohObjInfo StringType = {
&StringFileMethods,/* doh_file */ &StringFileMethods,/* doh_file */
&StringStringMethods, /* doh_string */ &StringStringMethods, /* doh_string */
0, /* doh_callable */ 0, /* doh_callable */
&StringPositionalMethods, /* doh_position */ 0, /* doh_position */
}; };
#define INIT_MAXSIZE 16 #define INIT_MAXSIZE 16
@ -160,6 +144,7 @@ NewString(char *s)
String *str; String *str;
str = (String *) DohObjMalloc(sizeof(String)); str = (String *) DohObjMalloc(sizeof(String));
str->objinfo = &StringType; str->objinfo = &StringType;
DohXInit(str);
str->hashkey = -1; str->hashkey = -1;
str->sp = 0; str->sp = 0;
str->lsp = 0; str->lsp = 0;

103
SWIG/Source/DOH/Doh/void.c
View file

@ -1,27 +1,17 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* DOH (Dynamic Object Hack)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$";
/* -----------------------------------------------------------------------------
* void.c * void.c
* *
* Void Object * Implements a "void" object that is really just a DOH container around
* an arbitrary C/C++ object represented as a void *.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "dohint.h" #include "dohint.h"
typedef struct { typedef struct {
@ -30,9 +20,46 @@ typedef struct {
void (*del)(void *); void (*del)(void *);
} VoidObj; } VoidObj;
void Void_delete(DOH *); /* -----------------------------------------------------------------------------
DOH *Void_copy(DOH *); * Void_delete()
void *Void_data(DOH *); *
* Delete a void object. Invokes the destructor supplied at the time of creation.
* ----------------------------------------------------------------------------- */
static void
Void_delete(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
if (v->del) {
(*v->del)(v->ptr);
}
v->del = 0;
DohObjFree(v);
}
/* -----------------------------------------------------------------------------
* Void_copy()
*
* Copies a void object. This is only a shallow copy. The object destruction
* function is not copied in order to avoid potential double-free problems.
* ----------------------------------------------------------------------------- */
static DOH *
Void_copy(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
return NewVoid(v->ptr,0);
}
/* -----------------------------------------------------------------------------
* Void_data()
*
* Returns the void * stored in the object.
* ----------------------------------------------------------------------------- */
static void *
Void_data(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
return v->ptr;
}
static DohObjInfo DohVoidType = { static DohObjInfo DohVoidType = {
"VoidObj", /* objname */ "VoidObj", /* objname */
@ -63,7 +90,15 @@ static DohObjInfo DohVoidType = {
}; };
DOH *NewVoid(void *obj, void (*del)(void *)) { /* -----------------------------------------------------------------------------
* NewVoid()
*
* Creates a new Void object given a void * and a pointer to an optional
* destruction function.
* ----------------------------------------------------------------------------- */
DOH *
NewVoid(void *obj, void (*del)(void *)) {
VoidObj *v; VoidObj *v;
v = (VoidObj *) DohObjMalloc(sizeof(VoidObj)); v = (VoidObj *) DohObjMalloc(sizeof(VoidObj));
v->objinfo = &DohVoidType; v->objinfo = &DohVoidType;
@ -71,23 +106,3 @@ DOH *NewVoid(void *obj, void (*del)(void *)) {
v->del = del; v->del = del;
return (DOH *) v; return (DOH *) v;
} }
void Void_delete(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
if (v->del) {
(*v->del)(v->ptr);
}
v->del = 0;
DohObjFree(v);
}
DOH *Void_copy(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
return NewVoid(v->ptr,0);
}
void *Void_data(DOH *vo) {
VoidObj *v = (VoidObj *) vo;
return v->ptr;
}

33
SWIG/Source/DOH/Include/doh.h
View file

@ -1,26 +1,15 @@
/******************************************************************************* /* -----------------------------------------------------------------------------
* DOH (Dave's Object Hack)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which DOH
* can be used and distributed.
*******************************************************************************/
/***********************************************************************
* $Header$
*
* doh.h * doh.h
* *
* DOH is really not much more than an interface. This file describes * This file describes of the externally visible functions in DOH.
* the interface. *
***********************************************************************/ * Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
*
* $Header$
* ----------------------------------------------------------------------------- */
#ifndef _DOH_H #ifndef _DOH_H
#define _DOH_H #define _DOH_H
@ -151,8 +140,6 @@ typedef struct DohObjInfo {
extern void DohInit(DOH *obj); /* Initialize an object */ extern void DohInit(DOH *obj); /* Initialize an object */
extern void DohXInit(DOH *obj); /* Initialize extended object */ extern void DohXInit(DOH *obj); /* Initialize extended object */
extern int DohCheck(DOH *ptr); /* Check if a DOH object */ extern int DohCheck(DOH *ptr); /* Check if a DOH object */
extern int DohMemoryUse(); /* Return current memory */
extern int DohMemoryHigh(); /* High memory use */
extern int DohPoolSize(int); /* Set memory alloc size */ extern int DohPoolSize(int); /* Set memory alloc size */
extern int DohNewScope(); /* Create a new scope */ extern int DohNewScope(); /* Create a new scope */
extern void DohDelScope(int); /* Delete a scope */ extern void DohDelScope(int); /* Delete a scope */

5
SWIG/Source/DOH/Include/dohint.h
View file

@ -6,8 +6,3 @@
#include <stdarg.h> #include <stdarg.h>
#include "doh.h" #include "doh.h"
extern void XBase_setfile(DOH *, DOH *);
extern DOH *XBase_getfile(DOH *);
extern void XBase_setline(DOH *, int);
extern int XBase_getline(DOH *);

26
SWIG/Source/LParse/cscanner.c
View file

@ -1,24 +1,16 @@
/******************************************************************************* /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * cscanner.c
*
* C Scanner that is roughly compatible with the SWIG1.1 scanner.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
*******************************************************************************/
/* -----------------------------------------------------------------------------
* $Header$
*
* scanner.c
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "lparse.h" #include "lparse.h"
#define yylval lparse_yylval #define yylval lparse_yylval

21
SWIG/Source/LParse/lparse.h
View file

@ -1,17 +1,15 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * lparse.h
*
* Lame tag-based parsed based on the SWIG1.1 parser.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
* *
* Please read the file LICENSE for the copyright and terms by which SWIG * $Header$
* can be used and distributed. * ----------------------------------------------------------------------------- */
****************************************************************************/
#ifndef _LPARSE_H #ifndef _LPARSE_H
#define _LPARSE_H #define _LPARSE_H
@ -22,7 +20,6 @@
extern "C" { extern "C" {
#endif #endif
extern void LParse_push(DOH *); extern void LParse_push(DOH *);
extern DOH *LParse_skip_balanced(int, int); extern DOH *LParse_skip_balanced(int, int);
extern void LParse_skip_semi(); extern void LParse_skip_semi();

53
SWIG/Source/LParse/parser.y
View file

@ -1,25 +1,14 @@
%{ %{
/******************************************************************************* /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
*******************************************************************************/
/***********************************************************************
* $Header$
*
* parser.y * parser.y
* *
* YACC parser for parsing function declarations. * YACC grammar for Dave's lame parser.
***********************************************************************/ *
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define yylex lparse_yylex #define yylex lparse_yylex
#define yyerror lparse_yyerror #define yyerror lparse_yyerror
@ -597,7 +586,7 @@ tm_parm : type tm_name {
$$ = NewHash(); $$ = NewHash();
if ($2.array) { if ($2.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($2.array)); $1->arraystr = Swig_copy_string(Char($2.array));
} }
Setattr($$,"type",$1); Setattr($$,"type",$1);
if ($2.name) if ($2.name)
@ -610,7 +599,7 @@ tm_parm : type tm_name {
$1->is_pointer += $2.ivalue; $1->is_pointer += $2.ivalue;
if ($3.array) { if ($3.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($3.array)); $1->arraystr = Swig_copy_string(Char($3.array));
} }
Setattr($$,"type",$1); Setattr($$,"type",$1);
if ($3.name) if ($3.name)
@ -624,7 +613,7 @@ tm_parm : type tm_name {
$1->is_pointer++; $1->is_pointer++;
if ($3.array) { if ($3.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($3.array)); $1->arraystr = Swig_copy_string(Char($3.array));
} }
Setattr($$,"type",$1); Setattr($$,"type",$1);
if ($3.name) if ($3.name)
@ -750,7 +739,7 @@ variable_decl : extern_spec type declaration array2 def_args {
$2->is_pointer += $3.is_pointer; $2->is_pointer += $3.is_pointer;
if ($4.text) { if ($4.text) {
$2->is_pointer++; $2->is_pointer++;
$2->arraystr = copy_string(Char($4.text)); $2->arraystr = Swig_copy_string(Char($4.text));
} }
$2->is_reference = $3.is_reference; $2->is_reference = $3.is_reference;
o = new_node("Variable", Getfile($3.id),Getline($3.id)); o = new_node("Variable", Getfile($3.id),Getline($3.id));
@ -860,7 +849,7 @@ stail : SEMI { }
t->is_pointer += $2.is_pointer; t->is_pointer += $2.is_pointer;
if ($3.text) { if ($3.text) {
t->is_pointer++; t->is_pointer++;
t->arraystr = copy_string(Char($3.text)); t->arraystr = Swig_copy_string(Char($3.text));
} }
t->is_reference = $2.is_reference; t->is_reference = $2.is_reference;
o = new_node("Variable", Getfile($2.id),Getline($2.id)); o = new_node("Variable", Getfile($2.id),Getline($2.id));
@ -1021,7 +1010,7 @@ typedef_decl : TYPEDEF type declaration {
Active_typedef = (LParseType *) Copy($2); Active_typedef = (LParseType *) Copy($2);
$2->is_pointer += $3.is_pointer; $2->is_pointer += $3.is_pointer;
$2->is_pointer++; $2->is_pointer++;
$2->arraystr = copy_string(Char($4.text)); $2->arraystr = Swig_copy_string(Char($4.text));
LParse_typedef_add($2,$3.id); LParse_typedef_add($2,$3.id);
o = new_node("Typedef", $1.filename, $1.line); o = new_node("Typedef", $1.filename, $1.line);
Setattr(o,"name", $3.id); Setattr(o,"name", $3.id);
@ -1046,7 +1035,7 @@ typedeflist : COMMA declaration typedeflist {
LParseType *t; LParseType *t;
t = (LParseType *) Copy(Active_typedef); t = (LParseType *) Copy(Active_typedef);
t->is_pointer += $2.is_pointer + 1; t->is_pointer += $2.is_pointer + 1;
t->arraystr = copy_string(Char($3.text)); t->arraystr = Swig_copy_string(Char($3.text));
LParse_typedef_add(t,$2.id); LParse_typedef_add(t,$2.id);
o = new_node("Typedef", Getfile($2.id), Getline($2.id)); o = new_node("Typedef", Getfile($2.id), Getline($2.id));
Setattr(o,"name", $2.id); Setattr(o,"name", $2.id);
@ -1322,7 +1311,7 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end {
$1->is_pointer += $2.is_pointer; $1->is_pointer += $2.is_pointer;
$1->is_reference = $2.is_reference; $1->is_reference = $2.is_reference;
if ($3.text) { if ($3.text) {
$1->arraystr = copy_string(Char($3.text)); $1->arraystr = Swig_copy_string(Char($3.text));
$1->is_pointer++; $1->is_pointer++;
} }
Setattr(o,"name",$2.id); Setattr(o,"name",$2.id);
@ -1498,7 +1487,7 @@ cpp_tail : SEMI { }
t->is_pointer += $2.is_pointer; t->is_pointer += $2.is_pointer;
t->is_reference = $2.is_reference; t->is_reference = $2.is_reference;
if ($3.text) { if ($3.text) {
t->arraystr = copy_string(Char($3.text)); t->arraystr = Swig_copy_string(Char($3.text));
t->is_pointer++; t->is_pointer++;
} }
Setattr(o,"name",$2.id); Setattr(o,"name",$2.id);
@ -1595,7 +1584,7 @@ parm : type pname {
Setattr($$,"name",$2.name); Setattr($$,"name",$2.name);
if ($2.array) { if ($2.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($2.array)); $1->arraystr = Swig_copy_string(Char($2.array));
} }
if ($2.value) if ($2.value)
Setattr($$,"value",$2.value); Setattr($$,"value",$2.value);
@ -1607,7 +1596,7 @@ parm : type pname {
$1->is_pointer += $2.ivalue; $1->is_pointer += $2.ivalue;
if ($3.array) { if ($3.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($3.array)); $1->arraystr = Swig_copy_string(Char($3.array));
} }
if ($3.value) { if ($3.value) {
Setattr($$,"value",$3.value); Setattr($$,"value",$3.value);
@ -1621,7 +1610,7 @@ parm : type pname {
Setattr($$,"name",$3.name); Setattr($$,"name",$3.name);
if ($3.array) { if ($3.array) {
$1->is_pointer++; $1->is_pointer++;
$1->arraystr = copy_string(Char($3.array)); $1->arraystr = Swig_copy_string(Char($3.array));
} }
if ($3.value) { if ($3.value) {
Setattr($$,"value",$3.value); Setattr($$,"value",$3.value);
@ -1766,7 +1755,7 @@ realtype : TYPE_INT { $$ = NewLParseType(LPARSE_T_INT); }
} }
| CONST type { | CONST type {
$$ = $2; $$ = $2;
$$->qualifier = copy_string("const"); $$->qualifier = Swig_copy_string("const");
} }
| cpptype idtype { | cpptype idtype {
$$ = NewLParseType(LPARSE_T_USER); $$ = NewLParseType(LPARSE_T_USER);

30
SWIG/Source/LParse/type.c
View file

@ -1,28 +1,18 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * type.c
*
* Lame SWIG1.1 type implementation.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu static char cvsroot[] = "$Header$";
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
#include "lparse.h" #include "lparse.h"
/* -----------------------------------------------------------------------------
* $Header$
*
* type.c
*
* Lame type structure for old SWIG parser
* ----------------------------------------------------------------------------- */
extern DOH *LParseTypeStr(DOH *to); extern DOH *LParseTypeStr(DOH *to);
static DohObjInfo LParseTypeType = { static DohObjInfo LParseTypeType = {

42
SWIG/Source/Preprocessor/cpp.c
View file

@ -1,39 +1,25 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * cpp.c
*
* An implementation of a C preprocessor plus some support for additional
* SWIG directives.
*
* - SWIG directives such as %include, %extern, and %import are handled
* - A new macro %define ... %enddef can be used for multiline macros
* - No preprocessing is performed in %{ ... %} blocks
* - Lines beginning with %# are stripped down to #... and passed through.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
#include "preprocessor.h" #include "preprocessor.h"
#include <ctype.h> #include <ctype.h>
/* -----------------------------------------------------------------------------
* $Header$
*
* File : cpp.c
*
* The SWIG Preprocessor. This works almost exactly like the C preprocessor except
* for a number of extensions:
*
* - SWIG directives such as %include, %extern, and %import are recognized
* - A new macro %define ... %enddef is provided to make it easier to
* write multi-line macros.
* - No preprocessing is performed inside %{ ... %} blocks.
* - Lines beginning with %#... are stripped to #... and passed through
* unmodified.
* ----------------------------------------------------------------------------- */
static DOH *cpp = 0; /* C preprocessor data */ static DOH *cpp = 0; /* C preprocessor data */
static int include_all = 1; /* Follow all includes */ static int include_all = 1; /* Follow all includes */
static int single_include = 1; /* Only include each file once */ static int single_include = 1; /* Only include each file once */

56
SWIG/Source/Preprocessor/expr.c
View file

@ -1,31 +1,19 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
#include "preprocessor.h"
/* -----------------------------------------------------------------------------
* expr.c * expr.c
* *
* This is your basic ol' integer arithmetic expression evaluator. Could have * Integer arithmetic expression evaluator used to handle expressions
* used yacc for this, but it generates something like 1000 lines of code * encountered during preprocessing.
* (whereas this implementation is much smaller). *
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* This module is primarily for use by the preprocessor and any other parts of * Copyright (C) 1999-2000. The University of Chicago
* the compiler that need to perform compile-time expression evaluation. * See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "preprocessor.h"
static SwigScanner *scan = 0; static SwigScanner *scan = 0;
typedef struct { typedef struct {
@ -172,23 +160,25 @@ static void reduce_op() {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Preprocessor_expr_init() * Preprocessor_expr_init()
* *
* Initialize the expression evaluator * Initialize the expression evaluator
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void Preprocessor_expr_init() { void
Preprocessor_expr_init() {
if (!expr_init) init_precedence(); if (!expr_init) init_precedence();
if (!scan) scan = NewSwigScanner(); if (!scan) scan = NewSwigScanner();
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int Preprocessor_expr(DOH *s, int *error) * Preprocessor_expr()
* *
* Evaluates an arithmetic expression in s. * Evaluates an arithmetic expression. Returns the result and sets an error code.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int Preprocessor_expr(DOH *s, int *error) { int
Preprocessor_expr(DOH *s, int *error) {
int token = 0; int token = 0;
int op = 0; int op = 0;
@ -328,8 +318,14 @@ int Preprocessor_expr(DOH *s, int *error) {
return 0; return 0;
} }
/* Return the expression error message */ /* -----------------------------------------------------------------------------
char *Preprocessor_expr_error() { * Preprocessor_expr_error()
*
* Return error message set by the evaluator (if any)
* ----------------------------------------------------------------------------- */
char *
Preprocessor_expr_error() {
return errmsg; return errmsg;
} }

20
SWIG/Source/Preprocessor/preprocessor.h
View file

@ -1,17 +1,15 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * preprocessor.h
*
* SWIG preprocessor module.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
* *
* Please read the file LICENSE for the copyright and terms by which SWIG * $Header$
* can be used and distributed. * ----------------------------------------------------------------------------- */
****************************************************************************/
#ifndef _PREPROCESSOR_H #ifndef _PREPROCESSOR_H
#define _PREPROCESSOR_H #define _PREPROCESSOR_H

6
SWIG/Source/SWIG1.1/main.cxx
View file

@ -279,7 +279,11 @@ int SWIG_main(int argc, char *argv[], Language *l, Documentation *d) {
Swig_check_options(); Swig_check_options();
Swig_set_library(LibDir); {
DOH *rl = NewString("");
Printf(rl,"%s/%s", SwigLib,LibDir);
Swig_add_directory(rl);
}
// If we made it this far, looks good. go for it.... // If we made it this far, looks good. go for it....

61
SWIG/Source/Swig/getopt.c
View file

@ -1,44 +1,39 @@
/******************************************************************************* /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * getopt.c
*
* Handles the parsing of command line options. This is particularly nasty
* compared to other utilities given that command line options can potentially
* be read by many different modules within SWIG. Thus, in order to make sure
* there are no unrecognized options, each module is required to "mark"
* the options that it uses. Afterwards, we can make a quick scan to make
* sure there are no unmarked options.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
* *
* Please read the file LICENSE for the copyright and terms by which SWIG * To do:
* can be used and distributed. * - This module needs to be modified so that it doesn't call exit().
*******************************************************************************/ * Should have cleaner error handling in general.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
#include "swig.h" #include "swig.h"
/*******************************************************************************
* $Header$
*
* File : getopt.c
*
* Functions for handling command line arguments. This is a little funky because
* the arguments are checked in multiple places.
*******************************************************************************/
static char **args; static char **args;
static int numargs; static int numargs;
static int *marked; static int *marked;
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_init_args(int argc, char **argv) * Swig_init_args()
* *
* Initializes the argument list. * Initialize the argument list handler.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
Swig_init_args(int argc, char **argv) Swig_init_args(int argc, char **argv) {
{
int i; int i;
assert(argc > 0); assert(argc > 0);
assert(argv); assert(argv);
@ -53,10 +48,9 @@ Swig_init_args(int argc, char **argv)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_mark_arg(int n) * Swig_mark_arg()
* *
* Marks an argument as being parsed. All modules should do this whenever they * Marks an argument as being parsed.
* parse a command line option.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
@ -67,16 +61,16 @@ Swig_mark_arg(int n) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_check_options() * Swig_check_options()
* *
* Checks for unparsed command line options. If so, issues an error and exits. * Checkers for unprocessed command line options and errors.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void Swig_check_options() { void
Swig_check_options() {
int error = 0; int error = 0;
int i; int i;
assert(marked); assert(marked);
for (i = 1; i < numargs-1; i++) { for (i = 1; i < numargs-1; i++) {
if (!marked[i]) { if (!marked[i]) {
Printf(stderr,"swig error : Unrecognized option %s\n", args[i]); Printf(stderr,"swig error : Unrecognized option %s\n", args[i]);
@ -94,12 +88,13 @@ void Swig_check_options() {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_arg_error() * Swig_arg_error()
* *
* Generates a generic error message and exits. * Generates a generic error message and exits.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void Swig_arg_error() { void
Swig_arg_error() {
Printf(stderr,"SWIG : Unable to parse command line options.\n"); Printf(stderr,"SWIG : Unable to parse command line options.\n");
Printf(stderr,"Use 'swig -help' for available options.\n"); Printf(stderr,"Use 'swig -help' for available options.\n");
exit(1); exit(1);

106
SWIG/Source/Swig/include.c
View file

@ -1,46 +1,34 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * include.c
*
* The functions in this file are used to manage files in the SWIG library.
* General purpose functions for opening, including, and retrieving pathnames
* are provided.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
#include "swig.h" #include "swig.h"
/*******************************************************************************
* $Header$
*
* File : include.c
*
* Various file manipulation functions.
*******************************************************************************/
/* Delimeter used in accessing files and directories */ /* Delimeter used in accessing files and directories */
static DOH *directories = 0; /* List of include directories */ static DOH *directories = 0; /* List of include directories */
static DOH *libdir = 0; /* SWIG library directory */
static DOH *lastpath = 0; /* Last file that was included */ static DOH *lastpath = 0; /* Last file that was included */
static int bytes_read = 0; /* Bytes read */ static int bytes_read = 0; /* Bytes read */
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_add_directory( DOH *dirname) * Swig_add_directory()
* *
* Adds a directory to the SWIG search path. * Adds a directory to the SWIG search path.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
Swig_add_directory(DOH *dirname) Swig_add_directory(DOH *dirname) {
{
if (!directories) directories = NewList(); if (!directories) directories = NewList();
assert(directories); assert(directories);
if (!String_check(dirname)) { if (!String_check(dirname)) {
@ -51,35 +39,7 @@ Swig_add_directory(DOH *dirname)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void Swig_set_library(DOH *libname) * Swig_last_file()
*
* Sets the language specific library name like 'tcl', 'perl5', 'python', etc...
* ----------------------------------------------------------------------------- */
void
Swig_set_library(DOH *libname)
{
Delete(libdir);
if (!String_check(libname)) {
libname = NewString((char *) libname);
assert(libname);
}
libdir = libname;
}
/* -----------------------------------------------------------------------------
* DOH *Swig_get_library()
*
* Gets the language specific name like 'tcl', 'perl5', etc...
* ----------------------------------------------------------------------------- */
DOH *
Swig_get_library() {
assert(libdir);
return libdir;
}
/* -----------------------------------------------------------------------------
* DOH *Swig_last_file()
* *
* Returns the full pathname of the last file opened. * Returns the full pathname of the last file opened.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -91,13 +51,13 @@ Swig_last_file() {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *Swig_search_path() * Swig_search_path()
* *
* Returns a list of the current search paths. * Returns a list of the current search paths.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH *Swig_search_path() DOH *
{ Swig_search_path() {
DOH *filename; DOH *filename;
DOH *dirname; DOH *dirname;
DOH *slist; DOH *slist;
@ -111,12 +71,6 @@ DOH *Swig_search_path()
Append(slist,filename); Append(slist,filename);
for (i = 0; i < Len(directories); i++) { for (i = 0; i < Len(directories); i++) {
dirname = Getitem(directories,i); dirname = Getitem(directories,i);
if (libdir) {
filename = NewString("");
assert(filename);
Printf(filename,"%s%s%s%s", dirname, SWIG_FILE_DELIMETER, libdir, SWIG_FILE_DELIMETER);
Append(slist,filename);
}
filename = NewString(""); filename = NewString("");
assert(filename); assert(filename);
Printf(filename, "%s%s", dirname, SWIG_FILE_DELIMETER); Printf(filename, "%s%s", dirname, SWIG_FILE_DELIMETER);
@ -126,14 +80,13 @@ DOH *Swig_search_path()
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* FILE *Swig_open( DOH *name) * Swig_open()
* *
* Looks for a file and open it. * Looks for a file and open it. Returns an open FILE * on success.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
FILE * FILE *
Swig_open(DOH *name) Swig_open(DOH *name) {
{
FILE *f; FILE *f;
DOH *filename; DOH *filename;
DOH *spath = 0; DOH *spath = 0;
@ -166,12 +119,13 @@ Swig_open(DOH *name)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *Swig_read_file(FILE *f) * Swig_read_file()
* *
* Reads data from f and returns as a new string * Reads data from an open FILE * and returns it as a string.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH *Swig_read_file(FILE *f) { DOH *
Swig_read_file(FILE *f) {
char buffer[4096]; char buffer[4096];
DOH *str = NewString(""); DOH *str = NewString("");
assert(str); assert(str);
@ -183,14 +137,13 @@ DOH *Swig_read_file(FILE *f) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *Swig_include(DOH *name) * Swig_include()
* *
* Open a file and return it as a string. * Opens a file and returns it as a string.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
Swig_include(DOH *name) Swig_include(DOH *name) {
{
FILE *f; FILE *f;
DOH *str; DOH *str;
f = Swig_open(name); f = Swig_open(name);
@ -201,7 +154,12 @@ Swig_include(DOH *name)
Seek(str,0,SEEK_SET); Seek(str,0,SEEK_SET);
Setfile(str,lastpath); Setfile(str,lastpath);
Setline(str,1); Setline(str,1);
/* fprintf(stderr,"%d bytes read\n", bytes_read); */
return str; return str;
} }

28
SWIG/Source/Swig/misc.c
View file

@ -1,29 +1,27 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * misc.c
*
* Miscellaneous functions that don't really fit anywhere else.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
#include "swig.h" #include "swig.h"
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* $Header$ * Swig_copy_string()
* *
* misc.c * Duplicate a NULL-terminate string given as a char *.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
char *copy_string(const char *s) { char *
Swig_copy_string(const char *s) {
char *c = 0; char *c = 0;
if (s) { if (s) {
c = (char *) malloc(strlen(s)+1); c = (char *) malloc(strlen(s)+1);

133
SWIG/Source/Swig/scanner.c
View file

@ -1,21 +1,21 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * scanner.c
*
* This file implements a general purpose C/C++ compatible lexical scanner.
* This scanner isn't intended to be plugged directly into a parser built
* with yacc. Rather, it contains a lot of generic code that could be used
* to easily construct yacc-compatible scanners.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
static char cvsroot[] = "$Header$"; static char cvsroot[] = "$Header$";
#include "swig.h" #include "swig.h"
#include <ctype.h>
struct SwigScanner { struct SwigScanner {
DOH *text; /* Current token value */ DOH *text; /* Current token value */
@ -30,21 +30,14 @@ struct SwigScanner {
DOH *file; DOH *file;
}; };
#include <ctype.h>
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* $Header$ * NewSwigScanner()
* *
* scanner.c * Create a new scanner object
*
* A generic C-based lexical scanner.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------- SwigScanner *
* SwigScanner *NewSwigScanner() - Create a new scanner object. NewSwigScanner() {
* ----------------------------------------------------------------------------- */
SwigScanner *NewSwigScanner()
{
SwigScanner *s; SwigScanner *s;
s = (SwigScanner *) malloc(sizeof(SwigScanner)); s = (SwigScanner *) malloc(sizeof(SwigScanner));
s->line = 1; s->line = 1;
@ -61,10 +54,13 @@ SwigScanner *NewSwigScanner()
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DelSwigScanner(SwigScanner *s) - Delete a SwigScanner object * DelSwigScanner()
*
* Delete a scanner object.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void DelSwigScanner(SwigScanner *s)
{ void
DelSwigScanner(SwigScanner *s) {
assert(s); assert(s);
Delete(s->scanobjs); Delete(s->scanobjs);
Delete(s->text); Delete(s->text);
@ -73,9 +69,13 @@ void DelSwigScanner(SwigScanner *s)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* SwigScanner_clear(SwigScanner *s) - Clear a scanner object * SwigScanner_clear()
*
* Clear the contents of a scanner object.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void SwigScanner_clear(SwigScanner *s) {
void
SwigScanner_clear(SwigScanner *s) {
assert(s); assert(s);
Delete(s->str); Delete(s->str);
Clear(s->text); Clear(s->text);
@ -88,11 +88,14 @@ void SwigScanner_clear(SwigScanner *s) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* SwigScanner_push(SwigScanner *s, DOH *txt) - Push text into the scanner * SwigScanner_push()
*
* Push some new text into the scanner. The scanner will start parsing this text
* immediately before returning to the old text.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void SwigScanner_push(SwigScanner *s, DOH *txt) void
{ SwigScanner_push(SwigScanner *s, DOH *txt) {
assert(s && txt); assert(s && txt);
Push(s->scanobjs,txt); Push(s->scanobjs,txt);
if (s->str) Delete(s->str); if (s->str) Delete(s->str);
@ -100,30 +103,37 @@ void SwigScanner_push(SwigScanner *s, DOH *txt)
Incref(s->str); Incref(s->str);
s->line = Getline(txt); s->line = Getline(txt);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* SwigScanner_pushtoken(SwigScanner *s, int nt) * SwigScanner_pushtoken()
* *
* Set the next processing token. * Push a token into the scanner. This token will be returned on the next
* call to SwigScanner_token().
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void SwigScanner_pushtoken(SwigScanner *s, int nt) { void
SwigScanner_pushtoken(SwigScanner *s, int nt) {
assert(s); assert(s);
assert((nt >= 0) && (nt < SWIG_MAXTOKENS)); assert((nt >= 0) && (nt < SWIG_MAXTOKENS));
s->nexttoken = nt; s->nexttoken = nt;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* SwigScanner_set_location(SwigScanner *s, DOH *file, int line) * SwigScanner_set_location()
*
* Set the file and line number location of the scanner.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
SwigScanner_set_location(SwigScanner *s, DOH *file, int line) SwigScanner_set_location(SwigScanner *s, DOH *file, int line) {
{
Setline(s->str,line); Setline(s->str,line);
Setfile(s->str,file); Setfile(s->str,file);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* SwigScanner_get_file(SwigScanner *s) - Get current file * SwigScanner_get_file()
*
* Get the current file.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
@ -131,24 +141,29 @@ SwigScanner_get_file(SwigScanner *s) {
return Getfile(s->str); return Getfile(s->str);
} }
/* -----------------------------------------------------------------------------
* SwigScanner_get_line()
*
* Get the current line number
* ----------------------------------------------------------------------------- */
int int
SwigScanner_get_line(SwigScanner *s) { SwigScanner_get_line(SwigScanner *s) {
return Getline(s->str); return Getline(s->str);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void SwigScanner_idstart(SwigScanner *s, char *id) * SwigScanner_idstart()
* *
* Set the characters that can be used to start an identifier * Change the set of additional characters that can be used to start an identifier.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
SwigScanner_idstart(SwigScanner *s, char *id) { SwigScanner_idstart(SwigScanner *s, char *id) {
s->idstart = copy_string(id); s->idstart = Swig_copy_string(id);
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* char nextchar(SwigScanner *s) * nextchar()
* *
* Returns the next character from the scanner or 0 if end of the string. * Returns the next character from the scanner or 0 if end of the string.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -176,7 +191,7 @@ nextchar(SwigScanner *s)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void retract(SwigScanner *s, int n) * retract()
* *
* Retract n characters * Retract n characters
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
@ -199,14 +214,13 @@ retract(SwigScanner *s, int n) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int look(SwigScanner *s) * look()
* *
* Get the next token. * Return the raw value of the next token.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
static int static int
look(SwigScanner *s) look(SwigScanner *s) {
{
int state; int state;
char c = 0; char c = 0;
@ -632,14 +646,13 @@ look(SwigScanner *s)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* int SwigScanner_token(SwigScanner *s) * SwigScanner_token()
* *
* Return the next token or 0 if at the end of the string * Real entry point to return the next token. Returns 0 if at end of input.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int int
SwigScanner_token(SwigScanner *s) SwigScanner_token(SwigScanner *s) {
{
int t; int t;
Clear(s->text); Clear(s->text);
if (s->nexttoken >= 0) { if (s->nexttoken >= 0) {
@ -652,25 +665,24 @@ SwigScanner_token(SwigScanner *s)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* DOH *SwigScanner_text(SwigScanner *s) * SwigScanner_text()
* *
* Return the text associated with the last token returned. * Return the lexene associated with the last returned token.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
DOH * DOH *
SwigScanner_text(SwigScanner *s) SwigScanner_text(SwigScanner *s) {
{
return s->text; return s->text;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void SwigScanner_skip_line(SwigScanner *s) * SwigScanner_skip_line()
* *
* Skips to the end of a line * Skips to the end of a line
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
SwigScanner_skip_line(SwigScanner *s) SwigScanner_skip_line(SwigScanner *s) {
{
char c; char c;
int done = 0; int done = 0;
Clear(s->text); Clear(s->text);
@ -685,15 +697,14 @@ SwigScanner_skip_line(SwigScanner *s)
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* void SwigScanner_skip_balanced(SwigScanner *s, int start, int end) * SwigScanner_skip_balanced()
* *
* Skips a piece of code enclosed in begin/end symbols such as '{...}' or * Skips a piece of code enclosed in begin/end symbols such as '{...}' or
* (...). Ignores symbols inside comments or strings. * (...). Ignores symbols inside comments or strings.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
int int
SwigScanner_skip_balanced(SwigScanner *s, int startchar, int endchar) SwigScanner_skip_balanced(SwigScanner *s, int startchar, int endchar) {
{
char c; char c;
int num_levels = 1; int num_levels = 1;
int l; int l;

29
SWIG/Source/Swig/super.c
View file

@ -1,30 +1,21 @@
/* ---------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * super.c
*
* SuperStrings are just like strings, except that they maintain
* information as to the origininal file/line of each character they
* contain.
* *
* Authors : David Beazley * Author(s) : Dustin Mitchell (djmitche@cs.uchicago.edu)
* Dustin Mitchell
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street * ----------------------------------------------------------------------------- */
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
---------------------------------------------------------------------- */
#include "doh.h" #include "doh.h"
#include "swig.h" #include "swig.h"
static char cvstag[] = "$Header$"; static char cvstag[] = "$Header$";
/*
* SuperStrings are just like strings, except that they maintain
* information as to the origininal file/line of each character they
* contain.
*/
typedef struct SSTag typedef struct SSTag
{ {
int length; /* distance to the next tag */ int length; /* distance to the next tag */

28
SWIG/Source/Swig/swig.h
View file

@ -1,17 +1,16 @@
/**************************************************************************** /* -----------------------------------------------------------------------------
* Simplified Wrapper and Interface Generator (SWIG) * swig.h
*
* Header file for the SWIG core.
* *
* Author : David Beazley * Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Dustin Mitchell (djmitche@cs.uchicago.edu)
* *
* Department of Computer Science * Copyright (C) 1999-2000. The University of Chicago
* University of Chicago * See the file LICENSE for information on usage and redistribution.
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
* *
* Please read the file LICENSE for the copyright and terms by which Swig * $Header$
* can be used and distributed. * ----------------------------------------------------------------------------- */
****************************************************************************/
#ifndef _SWIGCORE_H #ifndef _SWIGCORE_H
#define _SWIGCORE_H #define _SWIGCORE_H
@ -20,6 +19,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include "doh.h" #include "doh.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -29,8 +29,6 @@ extern "C" {
/* --- File interface --- */ /* --- File interface --- */
extern void Swig_add_directory(DOH *dirname); extern void Swig_add_directory(DOH *dirname);
extern void Swig_set_library(DOH *libname);
extern DOH *Swig_get_library();
extern DOH *Swig_last_file(); extern DOH *Swig_last_file();
extern DOH *Swig_search_path(); extern DOH *Swig_search_path();
extern FILE *Swig_open(DOH *name); extern FILE *Swig_open(DOH *name);
@ -51,7 +49,6 @@ extern void Swig_mark_arg(int n);
extern void Swig_check_options(); extern void Swig_check_options();
extern void Swig_arg_error(); extern void Swig_arg_error();
/* --- Scanner Interface --- */ /* --- Scanner Interface --- */
typedef struct SwigScanner SwigScanner; typedef struct SwigScanner SwigScanner;
@ -122,8 +119,7 @@ extern void SwigScanner_idstart(SwigScanner *, char *idchar);
#define SWIG_TOKEN_LAST 99 #define SWIG_TOKEN_LAST 99
/* --- Misc --- */ /* --- Misc --- */
extern char *Swig_copy_string(const char *c);
extern char *copy_string(const char *c);
#ifdef __cplusplus #ifdef __cplusplus
} }