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

Name cleanup

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@384 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-04-05 03:37:37 +00:00
commit 9f92983369
3 changed files with 118 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -17,9 +17,9 @@ static char cvsroot[] = "$Header$";
/* Delimeter used in accessing files and directories */
static DOH *directories = 0; /* List of include directories */
static DOH *lastpath = 0; /* Last file that was included */
static int bytes_read = 0; /* Bytes read */
static DOHList *directories = 0; /* List of include directories */
static DOHString *lastpath = 0; /* Last file that was included */
static int bytes_read = 0; /* Bytes read */
/* -----------------------------------------------------------------------------
* Swig_add_directory()
@ -28,7 +28,7 @@ static int bytes_read = 0; /* Bytes read */
* ----------------------------------------------------------------------------- */
void
Swig_add_directory(const DOH *dirname) {
Swig_add_directory(const DOHString_or_char *dirname) {
if (!directories) directories = NewList();
assert(directories);
if (!String_check(dirname)) {
@ -44,7 +44,7 @@ Swig_add_directory(const DOH *dirname) {
* Returns the full pathname of the last file opened.
* ----------------------------------------------------------------------------- */
DOH *
DOHString *
Swig_last_file() {
assert(lastpath);
return lastpath;
@ -56,11 +56,11 @@ Swig_last_file() {
* Returns a list of the current search paths.
* ----------------------------------------------------------------------------- */
DOH *
DOHList *
Swig_search_path() {
DOH *filename;
DOH *dirname;
DOH *slist;
DOHString *filename;
DOHString *dirname;
DOHList *slist;
int i;
slist = NewList();
@ -86,12 +86,12 @@ Swig_search_path() {
* ----------------------------------------------------------------------------- */
FILE *
Swig_open(const DOH *name) {
FILE *f;
DOH *filename;
DOH *spath = 0;
char *cname;
int i;
Swig_open(const DOHString_or_char *name) {
FILE *f;
DOHString *filename;
DOHList *spath = 0;
char *cname;
int i;
if (!directories) directories = NewList();
assert(directories);
@ -124,10 +124,11 @@ Swig_open(const DOH *name) {
* Reads data from an open FILE * and returns it as a string.
* ----------------------------------------------------------------------------- */
DOH *
DOHString *
Swig_read_file(FILE *f) {
char buffer[4096];
DOH *str = NewString("");
char buffer[4096];
DOHString *str = NewString("");
assert(str);
while (fgets(buffer,4095,f)) {
Append(str,buffer);
@ -142,10 +143,11 @@ Swig_read_file(FILE *f) {
* Opens a file and returns it as a string.
* ----------------------------------------------------------------------------- */
DOH *
Swig_include(const DOH *name) {
FILE *f;
DOH *str;
DOHString *
Swig_include(const DOHString_or_char *name) {
FILE *f;
DOHString *str;
f = Swig_open(name);
if (!f) return 0;
str = Swig_read_file(f);
@ -164,10 +166,11 @@ Swig_include(const DOH *name) {
* ----------------------------------------------------------------------------- */
int
Swig_insert_file(const DOH *filename, DOH *outfile) {
Swig_insert_file(const DOHString_or_char *filename, DOHFile *outfile) {
char buffer[4096];
int nbytes;
FILE *f = Swig_open(filename);
if (!f) return -1;
while ((nbytes = Read(f,buffer,4096)) > 0) {
Write(outfile,buffer,nbytes);

91
SWIG/Source/Swig/stype.c
View file

@ -103,7 +103,7 @@
* ----------------------------------------------------------------------------- */
void
StringType_add_pointer(DOH *t) {
StringType_add_pointer(DOHString *t) {
assert(DohIsString(t));
Insert(t,0,"*.");
}
@ -115,7 +115,7 @@ StringType_add_pointer(DOH *t) {
* ----------------------------------------------------------------------------- */
void
StringType_add_array(DOH *t, DOH *size) {
StringType_add_array(DOHString *t, DOHString *size) {
assert(DohIsString(t));
Insert(t,0,"].");
Insert(t,0,size);
@ -129,7 +129,7 @@ StringType_add_array(DOH *t, DOH *size) {
* ----------------------------------------------------------------------------- */
void
StringType_add_reference(DOH *t) {
StringType_add_reference(DOHString *t) {
assert(DohIsString(t));
Insert(t,0,"&.");
}
@ -141,7 +141,7 @@ StringType_add_reference(DOH *t) {
* ----------------------------------------------------------------------------- */
void
StringType_add_qualifier(DOH *t, DOH *qual) {
StringType_add_qualifier(DOHString *t, DOHString *qual) {
assert(DohIsString(t));
Insert(t,0,".");
Insert(t,0,qual);
@ -156,9 +156,10 @@ StringType_add_qualifier(DOH *t, DOH *qual) {
* ----------------------------------------------------------------------------- */
void
StringType_add_function(DOH *t, DOH *parms) {
DOH *pstr;
int i,l;
StringType_add_function(DOHString *t, DOHList *parms) {
DOHString *pstr;
int i,l;
assert(DohIsString(t));
Insert(t,0,").");
pstr = NewString("");
@ -178,9 +179,10 @@ StringType_add_function(DOH *t, DOH *parms) {
*
* Isolate a single element of a type string (delimeted by periods)
* ----------------------------------------------------------------------------- */
static DOH *
static DOHString *
isolate_element(char *c) {
DOH *result = NewString("");
DOHString *result = NewString("");
while (*c) {
if (*c == '.') return result;
else if (*c == '(') {
@ -222,13 +224,14 @@ isolate_element(char *c) {
* Splits a type into it's component parts and returns a list of string.
* ----------------------------------------------------------------------------- */
DOH *StringType_split(DOH *t) {
DOH *item, *list;
DOHList *StringType_split(DOH *t) {
DOH *item;
DOHList *list;
char *c;
int len;
assert(DohIsString(t));
c = Char(t);
list = NewList();
while (*c) {
item = isolate_element(c);
@ -252,10 +255,11 @@ DOH *StringType_split(DOH *t) {
* Pop off the first type-constructor object and update the type
* ----------------------------------------------------------------------------- */
DOH *StringType_pop(DOH *t)
DOHString *StringType_pop(DOH *t)
{
DOH *result;
char *c;
DOHString *result;
char *c;
assert(DohIsString(t));
if (Len(t) == 0) return 0;
c = Char(t);
@ -274,7 +278,7 @@ DOH *StringType_pop(DOH *t)
* Push a type constructor onto the type
* ----------------------------------------------------------------------------- */
void StringType_push(DOH *t, DOH *cons)
void StringType_push(DOHString *t, DOHString *cons)
{
if (!cons) return;
if (!Len(cons)) return;
@ -294,9 +298,11 @@ void StringType_push(DOH *t, DOH *cons)
* Splits a comma separated list of components into strings.
* ----------------------------------------------------------------------------- */
DOH *StringType_split_parms(DOH *p) {
DOH *item, *list;
DOHList *StringType_split_parms(DOHString *p) {
DOH *item;
DOHList *list;
char *c;
assert(DohIsString(p));
c = Char(p);
assert(*c == '(');
@ -354,7 +360,7 @@ DOH *StringType_split_parms(DOH *p) {
* Returns the tag for a struct/enum/whatnot
* ----------------------------------------------------------------------------- */
DOH *StringType_get_tag(DOH *s) {
DOHString *StringType_get_tag(DOHString *s) {
char *c = Char(s);
if (*c == '{')
@ -384,10 +390,10 @@ DOH *StringType_get_tag(DOH *s) {
* Splits a comma separated list of enum elements
* ----------------------------------------------------------------------------- */
DOH *StringType_split_enum(DOH *s) {
DOH *list;
DOH *item;
char *c = Char(s);
DOHList *StringType_split_enum(DOHString *s) {
DOHList *list;
DOH *item;
char *c = Char(s);
assert(*c == '<');
c++;
@ -424,9 +430,11 @@ DOH *StringType_split_enum(DOH *s) {
* Splits a comma separated list of structure components
* ----------------------------------------------------------------------------- */
DOH *StringType_split_struct(DOH *p) {
DOH *item, *list;
char *c;
DOHList *StringType_split_struct(DOHString *p) {
DOH *item;
DOHList *list;
char *c;
assert(DohIsString(p));
c = Char(p);
assert(*c == '{');
@ -497,48 +505,54 @@ DOH *StringType_split_struct(DOH *p) {
* Testing functions for querying a datatype
* ----------------------------------------------------------------------------- */
int StringType_ispointer(DOH *t) {
int StringType_ispointer(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '*') return 1;
return 0;
}
int StringType_isreference(DOH *t) {
int StringType_isreference(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '&') return 1;
return 0;
}
int StringType_isarray(DOH *t) {
int StringType_isarray(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '[') return 1;
return 0;
}
int StringType_isfunction(DOH *t) {
int StringType_isfunction(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '(') return 1;
return 0;
}
int StringType_isstruct(DOH *t) {
int StringType_isstruct(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '{') return 1;
return 0;
}
int StringType_isqualifier(DOH *t) {
int StringType_isqualifier(DOHString *t) {
char *c;
assert(DohIsString(t));
c = Char(t);
if (*c == '+') return 1;
@ -551,8 +565,9 @@ int StringType_isqualifier(DOH *t) {
* Returns the base of a datatype.
* ----------------------------------------------------------------------------- */
DOH *StringType_base(DOH *t) {
DOHString *StringType_base(DOHString *t) {
char *c, *d;
assert(DohIsString(t));
c = Char(t);
d = c + strlen(c);
@ -569,12 +584,12 @@ DOH *StringType_base(DOH *t) {
* Create a C string representation of a datatype.
* ----------------------------------------------------------------------------- */
DOH *
StringType_cstr(DOH *s, DOH *id)
DOHString *
StringType_cstr(DOHString *s, DOHString_or_char *id)
{
DOH *result;
DOH *element, *nextelement;
DOH *elements;
DOHString *result;
DOHString *element, *nextelement;
DOHList *elements;
int nelements, i;
char *c;

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

@ -28,13 +28,13 @@ extern "C" {
/* --- File interface --- */
extern void Swig_add_directory(const DOH *dirname);
extern DOH *Swig_last_file();
extern DOH *Swig_search_path();
extern FILE *Swig_open(const DOH *name);
extern DOH *Swig_read_file(FILE *f);
extern DOH *Swig_include(const DOH *name);
extern int Swig_insert_file(const DOH *name, DOH *outfile);
extern void Swig_add_directory(const DOHString_or_char *dirname);
extern DOHString *Swig_last_file();
extern DOHList *Swig_search_path();
extern FILE *Swig_open(const DOHString_or_char *name);
extern DOHString *Swig_read_file(FILE *f);
extern DOHString *Swig_include(const DOHString_or_char *name);
extern int Swig_insert_file(const DOHString_or_char *name, DOHFile *outfile);
#define SWIG_FILE_DELIMETER "/"
@ -55,18 +55,18 @@ extern void Swig_arg_error();
typedef struct SwigScanner SwigScanner;
extern SwigScanner *NewSwigScanner();
extern void DelSwigScanner(SwigScanner *);
extern void SwigScanner_clear(SwigScanner *);
extern void SwigScanner_push(SwigScanner *, DOH *);
extern void SwigScanner_pushtoken(SwigScanner *, int);
extern int SwigScanner_token(SwigScanner *);
extern DOH *SwigScanner_text(SwigScanner *);
extern void SwigScanner_skip_line(SwigScanner *);
extern int SwigScanner_skip_balanced(SwigScanner *, int startchar, int endchar);
extern void SwigScanner_set_location(SwigScanner *, DOH *file, int line);
extern DOH *SwigScanner_get_file(SwigScanner *);
extern int SwigScanner_get_line(SwigScanner *);
extern void SwigScanner_idstart(SwigScanner *, char *idchar);
extern void DelSwigScanner(SwigScanner *);
extern void SwigScanner_clear(SwigScanner *);
extern void SwigScanner_push(SwigScanner *, DOHString *);
extern void SwigScanner_pushtoken(SwigScanner *, int);
extern int SwigScanner_token(SwigScanner *);
extern DOHString *SwigScanner_text(SwigScanner *);
extern void SwigScanner_skip_line(SwigScanner *);
extern int SwigScanner_skip_balanced(SwigScanner *, int startchar, int endchar);
extern void SwigScanner_set_location(SwigScanner *, DOHString *file, int line);
extern DOHString *SwigScanner_get_file(SwigScanner *);
extern int SwigScanner_get_line(SwigScanner *);
extern void SwigScanner_idstart(SwigScanner *, char *idchar);
#define SWIG_MAXTOKENS 512
#define SWIG_TOKEN_LPAREN 1
@ -121,26 +121,26 @@ extern void SwigScanner_idstart(SwigScanner *, char *idchar);
/* --- Functions for manipulating the string-based type encoding --- */
extern void StringType_add_pointer(DOH *t);
extern void StringType_add_array(DOH *t, DOH *size);
extern void StringType_add_reference(DOH *t);
extern void StringType_add_qualifier(DOH *t, DOH *qual);
extern void StringType_add_function(DOH *t, DOH *parms);
extern DOH *StringType_split(DOH *t);
extern DOH *StringType_pop(DOH *t);
extern void StringType_push(DOH *t, DOH *s);
extern DOH *StringType_split_parms(DOH *p);
extern DOH *StringType_split_struct(DOH *s);
extern DOH *StringType_split_enum(DOH *s);
extern DOH *StringType_get_tag(DOH *s);
extern DOH *StringType_cstr(DOH *s, DOH *id);
extern int StringType_ispointer(DOH *t);
extern int StringType_isreference(DOH *t);
extern int StringType_isarray(DOH *t);
extern int StringType_isfunction(DOH *t);
extern int StringType_isstruct(DOH *t);
extern int StringType_isqualifier(DOH *t);
extern DOH *StringType_base(DOH *t);
extern void StringType_add_pointer(DOHString *t);
extern void StringType_add_array(DOHString *t, DOHString *size);
extern void StringType_add_reference(DOHString *t);
extern void StringType_add_qualifier(DOHString *t, DOHString *qual);
extern void StringType_add_function(DOHString *t, DOHString *parms);
extern DOHList *StringType_split(DOHString *t);
extern DOHString *StringType_pop(DOHString *t);
extern void StringType_push(DOHString *t, DOHString *s);
extern DOHList *StringType_split_parms(DOHString *p);
extern DOHList *StringType_split_struct(DOHString *s);
extern DOHList *StringType_split_enum(DOHString *s);
extern DOHString *StringType_get_tag(DOHString *s);
extern DOHString *StringType_cstr(DOHString *s, DOHString_or_char *id);
extern int StringType_ispointer(DOHString *t);
extern int StringType_isreference(DOHString *t);
extern int StringType_isarray(DOHString *t);
extern int StringType_isfunction(DOHString *t);
extern int StringType_isstruct(DOHString *t);
extern int StringType_isqualifier(DOHString *t);
extern DOHString *StringType_base(DOHString *t);
/* --- NEW Type system --- */