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

Replaced all [const] String_or_char * to const_String_or_char_ptr, by the following command:

Browse source 
sed -i "s/\(const \)\?String_or_char \*/const_String_or_char_ptr /g" CParse/* Include/* Modules/* Preprocessor/* Swig/*

This is a preparation for moving to new DOH, since for strong typed objects we need the const_String_or_char_ptr class to implicit convert to and from String * or const char *.



git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11080 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Haoyu Bai 2009-01-24 13:15:51 +00:00
commit 6d2aef67d9
39 changed files with 230 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Source/CParse/cparse.h
View file

@ -34,7 +34,7 @@ extern "C" {
extern void scanner_ignore_typedef(void);
extern void scanner_last_id(int);
extern void scanner_clear_rename(void);
extern void scanner_set_location(String_or_char *file, int line);
extern void scanner_set_location(const_String_or_char_ptr file, int line);
extern void scanner_set_main_input_file(String *file);
extern String *scanner_get_main_input_file();
extern void Swig_cparse_follow_locators(int);

2
Source/CParse/cscanner.c
View file

@ -442,7 +442,7 @@ int yylook(void) {
static int check_typedef = 0;
void scanner_set_location(String_or_char *file, int line) {
void scanner_set_location(const_String_or_char_ptr file, int line) {
Scanner_set_location(scan,file,line-1);
}

4
Source/CParse/parser.y
View file

@ -66,7 +66,7 @@ static void yyerror (const char *e) {
(void)e;
}
static Node *new_node(const String_or_char *tag) {
static Node *new_node(const_String_or_char_ptr tag) {
Node *n = NewHash();
set_nodeType(n,tag);
Setfile(n,cparse_file);
@ -1425,7 +1425,7 @@ static void default_arguments(Node *n) {
* Used by the parser to mark subtypes with extra information.
* ----------------------------------------------------------------------------- */
static void tag_nodes(Node *n, const String_or_char *attrname, DOH *value) {
static void tag_nodes(Node *n, const_String_or_char_ptr attrname, DOH *value) {
while (n) {
Setattr(n, attrname, value);
tag_nodes(firstChild(n), attrname, value);

3
Source/DOH/doh.h
View file

@ -144,6 +144,9 @@ typedef void DOH;
#define DOHString_or_char DOH
#define DOHObj_or_char DOH
typedef const DOHString_or_char * const_String_or_char_ptr;
typedef const DOHString_or_char * DOHconst_String_or_char_ptr;
#define DOH_BEGIN -1
#define DOH_END -2
#define DOH_CUR -3

4
Source/Modules/allegrocl.cxx
View file

@ -625,7 +625,7 @@ void note_implicit_template_instantiation(SwigType *t) {
add_defined_foreign_type(0, 0, t, t, implicit_ns ? implicit_ns : current_namespace);
}
String *get_ffi_type(SwigType *ty, const String_or_char *name) {
String *get_ffi_type(SwigType *ty, const_String_or_char_ptr name) {
/* lookup defined foreign type.
if it exists, it will return a form suitable for placing
into lisp code to generate the def-foreign-type name */
@ -1962,7 +1962,7 @@ int any_varargs(ParmList *pl) {
return 0;
}
String *get_lisp_type(SwigType *ty, const String_or_char *name) {
String *get_lisp_type(SwigType *ty, const_String_or_char_ptr name) {
Hash *typemap = Swig_typemap_search("lisptype", ty, name, 0);
if (typemap) {
String *typespec = Getattr(typemap, "code");

8
Source/Modules/chicken.cxx
View file

@ -101,12 +101,12 @@ protected:
int isPointer(SwigType *t);
void dispatchFunction(Node *n);
String *chickenNameMapping(String *, String_or_char *);
String *chickenNameMapping(String *, const_String_or_char_ptr );
String *chickenPrimitiveName(String *);
String *runtimeCode();
String *defaultExternalRuntimeFilename();
String *buildClosFunctionCall(List *types, String_or_char *closname, String_or_char *funcname);
String *buildClosFunctionCall(List *types, const_String_or_char_ptr closname, const_String_or_char_ptr funcname);
};
/* -----------------------------------------------------------------------
@ -1234,7 +1234,7 @@ int CHICKEN::importDirective(Node *n) {
return Language::importDirective(n);
}
String *CHICKEN::buildClosFunctionCall(List *types, String_or_char *closname, String_or_char *funcname) {
String *CHICKEN::buildClosFunctionCall(List *types, const_String_or_char_ptr closname, const_String_or_char_ptr funcname) {
String *method_signature = NewString("");
String *func_args = NewString("");
String *func_call = NewString("");
@ -1508,7 +1508,7 @@ int CHICKEN::validIdentifier(String *s) {
* If class_name = "" that means the mapping is for a function or
* variable not attached to any class.
* ------------------------------------------------------------ */
String *CHICKEN::chickenNameMapping(String *name, String_or_char *class_name) {
String *CHICKEN::chickenNameMapping(String *name, const_String_or_char_ptr class_name) {
String *n = NewString("");
if (Strcmp(class_name, "") == 0) {

2
Source/Modules/csharp.cxx
View file

@ -85,7 +85,7 @@ class CSHARP:public Language {
enum EnumFeature { SimpleEnum, TypeunsafeEnum, TypesafeEnum, ProperEnum };
static Parm *NewParmFromNode(SwigType *type, const String_or_char *name, Node *n) {
static Parm *NewParmFromNode(SwigType *type, const_String_or_char_ptr name, Node *n) {
Parm *p = NewParm(type, name);
Setfile(p, Getfile(n));
Setline(p, Getline(n));

4
Source/Modules/directors.cxx
View file

@ -84,7 +84,7 @@ String *Swig_director_declaration(Node *n) {
}
String *Swig_method_call(String_or_char *name, ParmList *parms) {
String *Swig_method_call(const_String_or_char_ptr name, ParmList *parms) {
String *func;
int i = 0;
int comma = 0;
@ -128,7 +128,7 @@ String *Swig_method_call(String_or_char *name, ParmList *parms) {
*
*/
String *Swig_method_decl(SwigType *returntype, SwigType *decl, const String_or_char *id, List *args, int strip, int values) {
String *Swig_method_decl(SwigType *returntype, SwigType *decl, const_String_or_char_ptr id, List *args, int strip, int values) {
String *result;
List *elements;
String *element = 0, *nextelement;

2
Source/Modules/guile.cxx
View file

@ -1654,7 +1654,7 @@ public:
* If class_name = "" that means the mapping is for a function or
* variable not attached to any class.
* ------------------------------------------------------------ */
String *goopsNameMapping(String *name, String_or_char *class_name) {
String *goopsNameMapping(String *name, const_String_or_char_ptr class_name) {
String *n = NewString("");
if (Strcmp(class_name, "") == 0) {

2
Source/Modules/java.cxx
View file

@ -82,7 +82,7 @@ class JAVA:public Language {
enum EnumFeature { SimpleEnum, TypeunsafeEnum, TypesafeEnum, ProperEnum };
static Parm *NewParmFromNode(SwigType *type, const String_or_char *name, Node *n) {
static Parm *NewParmFromNode(SwigType *type, const_String_or_char_ptr name, Node *n) {
Parm *p = NewParm(type, name);
Setfile(p, Getfile(n));
Setline(p, Getline(n));

2
Source/Modules/main.cxx
View file

@ -285,7 +285,7 @@ static void set_outdir(const String *c_wrapper_file_dir) {
}
/* This function sets the name of the configuration file */
void SWIG_config_file(const String_or_char *filename) {
void SWIG_config_file(const_String_or_char_ptr filename) {
lang_config = NewString(filename);
}

8
Source/Modules/overload.cxx
View file

@ -316,7 +316,7 @@ static bool print_typecheck(String *f, int j, Parm *pj) {
* ReplaceFormat()
* ----------------------------------------------------------------------------- */
static String *ReplaceFormat(const String_or_char *fmt, int j) {
static String *ReplaceFormat(const_String_or_char_ptr fmt, int j) {
String *lfmt = NewString(fmt);
char buf[50];
sprintf(buf, "%d", j);
@ -352,7 +352,7 @@ static String *ReplaceFormat(const String_or_char *fmt, int j) {
/*
Cast dispatch mechanism.
*/
String *Swig_overload_dispatch_cast(Node *n, const String_or_char *fmt, int *maxargs) {
String *Swig_overload_dispatch_cast(Node *n, const_String_or_char_ptr fmt, int *maxargs) {
int i, j;
*maxargs = 1;
@ -536,7 +536,7 @@ String *Swig_overload_dispatch_cast(Node *n, const String_or_char *fmt, int *max
/*
Fast dispatch mechanism, provided by Salvador Fandi~no Garc'ia (#930586).
*/
String *Swig_overload_dispatch_fast(Node *n, const String_or_char *fmt, int *maxargs) {
String *Swig_overload_dispatch_fast(Node *n, const_String_or_char_ptr fmt, int *maxargs) {
int i, j;
*maxargs = 1;
@ -695,7 +695,7 @@ String *Swig_overload_dispatch_fast(Node *n, const String_or_char *fmt, int *max
return f;
}
String *Swig_overload_dispatch(Node *n, const String_or_char *fmt, int *maxargs) {
String *Swig_overload_dispatch(Node *n, const_String_or_char_ptr fmt, int *maxargs) {
if (fast_dispatch_mode || GetFlag(n, "feature:fastdispatch")) {
return Swig_overload_dispatch_fast(n, fmt, maxargs);

2
Source/Modules/php.cxx
View file

@ -1934,7 +1934,7 @@ public:
return NewStringEmpty();
}
String *PhpTypeFromTypemap(char *op, Node *n, String_or_char *lname) {
String *PhpTypeFromTypemap(char *op, Node *n, const_String_or_char_ptr lname) {
String *tms = Swig_typemap_lookup(op, n, lname, 0);
if (!tms)
return 0;

4
Source/Modules/pike.cxx
View file

@ -224,7 +224,7 @@ public:
* name (i.e. "enum_test").
* ------------------------------------------------------------ */
String *strip(const DOHString_or_char *name) {
String *strip(const DOHconst_String_or_char_ptr name) {
String *s = Copy(name);
if (Strncmp(name, PrefixPlusUnderscore, Len(PrefixPlusUnderscore)) != 0) {
return s;
@ -237,7 +237,7 @@ public:
* add_method()
* ------------------------------------------------------------ */
void add_method(const DOHString_or_char *name, const DOHString_or_char *function, const DOHString_or_char *description) {
void add_method(const DOHconst_String_or_char_ptr name, const DOHconst_String_or_char_ptr function, const DOHconst_String_or_char_ptr description) {
String *rename = NULL;
switch (current) {
case NO_CPP:

16
Source/Modules/ruby.cxx
View file

@ -78,7 +78,7 @@ public:
Delete(temp);
}
void set_name(const String_or_char *cn, const String_or_char *rn, const String_or_char *valn) {
void set_name(const_String_or_char_ptr cn, const_String_or_char_ptr rn, const_String_or_char_ptr valn) {
/* Original C/C++ class (or struct) name */
Clear(cname);
Append(cname, cn);
@ -104,7 +104,7 @@ public:
Printv(prefix, (rn ? rn : cn), "_", NIL);
}
char *strip(const String_or_char *s) {
char *strip(const_String_or_char_ptr s) {
Clear(temp);
Append(temp, s);
if (Strncmp(s, prefix, Len(prefix)) == 0) {
@ -1228,7 +1228,7 @@ public:
/**
* Process the comma-separated list of aliases (if any).
*/
void defineAliases(Node *n, const String_or_char *iname) {
void defineAliases(Node *n, const_String_or_char_ptr iname) {
String *aliasv = Getattr(n, "feature:alias");
if (aliasv) {
List *aliases = Split(aliasv, ',', INT_MAX);
@ -1262,7 +1262,7 @@ public:
* as another instance of the same class.
* --------------------------------------------------------------------- */
void create_command(Node *n, const String_or_char *iname) {
void create_command(Node *n, const_String_or_char_ptr iname) {
String *alloc_func = Swig_name_wrapper(iname);
String *wname = Swig_name_wrapper(iname);
@ -2566,7 +2566,7 @@ public:
/* First wrap the allocate method */
current = CONSTRUCTOR_ALLOCATE;
Swig_name_register((String_or_char *) "construct", (String_or_char *) "%c_allocate");
Swig_name_register((const_String_or_char_ptr ) "construct", (const_String_or_char_ptr ) "%c_allocate");
Language::constructorHandler(n);
@ -2601,7 +2601,7 @@ public:
Delete(docs);
current = CONSTRUCTOR_INITIALIZE;
Swig_name_register((String_or_char *) "construct", (String_or_char *) "new_%c");
Swig_name_register((const_String_or_char_ptr ) "construct", (const_String_or_char_ptr ) "new_%c");
Language::constructorHandler(n);
/* Restore original parameter list */
@ -2609,7 +2609,7 @@ public:
Swig_restore(n);
/* Done */
Swig_name_unregister((String_or_char *) "construct");
Swig_name_unregister((const_String_or_char_ptr ) "construct");
current = NO_CPP;
klass->constructor_defined = 1;
return SWIG_OK;
@ -2623,7 +2623,7 @@ public:
/* First wrap the allocate method */
current = CONSTRUCTOR_ALLOCATE;
Swig_name_register((String_or_char *) "construct", (String_or_char *) "%c_allocate");
Swig_name_register((const_String_or_char_ptr ) "construct", (const_String_or_char_ptr ) "%c_allocate");
return Language::copyconstructorHandler(n);
}

12
Source/Modules/swigmod.h
View file

@ -313,7 +313,7 @@ int SWIG_main(int, char **, Language *);
void emit_parameter_variables(ParmList *l, Wrapper *f);
void emit_return_variable(Node *n, SwigType *rt, Wrapper *f);
void SWIG_exit(int); /* use EXIT_{SUCCESS,FAILURE} */
void SWIG_config_file(const String_or_char *);
void SWIG_config_file(const_String_or_char_ptr );
const String *SWIG_output_directory();
void SWIG_config_cppext(const char *ext);
@ -329,17 +329,17 @@ void emit_mark_varargs(ParmList *l);
String *emit_action(Node *n);
int emit_action_code(Node *n, String *wrappercode, String *action);
void Swig_overload_check(Node *n);
String *Swig_overload_dispatch(Node *n, const String_or_char *fmt, int *);
String *Swig_overload_dispatch_cast(Node *n, const String_or_char *fmt, int *);
String *Swig_overload_dispatch_fast(Node *n, const String_or_char *fmt, int *);
String *Swig_overload_dispatch(Node *n, const_String_or_char_ptr fmt, int *);
String *Swig_overload_dispatch_cast(Node *n, const_String_or_char_ptr fmt, int *);
String *Swig_overload_dispatch_fast(Node *n, const_String_or_char_ptr fmt, int *);
SwigType *cplus_value_type(SwigType *t);
/* directors.cxx start */
String *Swig_csuperclass_call(String *base, String *method, ParmList *l);
String *Swig_class_declaration(Node *n, String *name);
String *Swig_class_name(Node *n);
String *Swig_method_call(String_or_char *name, ParmList *parms);
String *Swig_method_decl(SwigType *rtype, SwigType *decl, const String_or_char *id, List *args, int strip, int values);
String *Swig_method_call(const_String_or_char_ptr name, ParmList *parms);
String *Swig_method_decl(SwigType *rtype, SwigType *decl, const_String_or_char_ptr id, List *args, int strip, int values);
String *Swig_director_declaration(Node *n);
void Swig_director_emit_dynamic_cast(Node *n, Wrapper *f);
/* directors.cxx end */

4
Source/Modules/uffi.cxx
View file

@ -131,7 +131,7 @@ static void add_defined_foreign_type(String *type) {
}
static String *get_ffi_type(SwigType *ty, const String_or_char *name) {
static String *get_ffi_type(SwigType *ty, const_String_or_char_ptr name) {
Hash *typemap = Swig_typemap_search("ffitype", ty, name, 0);
if (typemap) {
String *typespec = Getattr(typemap, "code");
@ -167,7 +167,7 @@ static String *get_ffi_type(SwigType *ty, const String_or_char *name) {
return 0;
}
static String *get_lisp_type(SwigType *ty, const String_or_char *name) {
static String *get_lisp_type(SwigType *ty, const_String_or_char_ptr name) {
Hash *typemap = Swig_typemap_search("lisptype", ty, name, 0);
if (typemap) {
String *typespec = Getattr(typemap, "code");

13
Source/Preprocessor/cpp.c
View file

@ -74,7 +74,7 @@ static void copy_location(const DOH *s1, DOH *s2) {
Setline(s2, Getline((DOH *) s1));
}
static String *cpp_include(String_or_char *fn, int sysfile) {
static String *cpp_include(const_String_or_char_ptr fn, int sysfile) {
String *s = sysfile ? Swig_include_sys(fn) : Swig_include(fn);
if (s && single_include) {
String *file = Getfile(s);
@ -261,8 +261,9 @@ void Preprocessor_error_as_warning(int a) {
* ----------------------------------------------------------------------------- */
String_or_char *Macro_vararg_name(String_or_char *str, String_or_char *line) {
String_or_char *argname, *varargname;
const_String_or_char_ptr Macro_vararg_name(const_String_or_char_ptr str, const_String_or_char_ptr line) {
String *argname;
String *varargname;
char *s, *dots;
argname = Copy(str);
@ -288,13 +289,13 @@ String_or_char *Macro_vararg_name(String_or_char *str, String_or_char *line) {
return varargname;
}
Hash *Preprocessor_define(const String_or_char *_str, int swigmacro) {
Hash *Preprocessor_define(const_String_or_char_ptr _str, int swigmacro) {
String *macroname = 0, *argstr = 0, *macrovalue = 0, *file = 0, *s = 0;
Hash *macro = 0, *symbols = 0, *m1;
List *arglist = 0;
int c, line;
int varargs = 0;
String_or_char *str = (String_or_char *) _str;
const_String_or_char_ptr str = (const_String_or_char_ptr ) _str;
assert(cpp);
assert(str);
@ -532,7 +533,7 @@ macro_error:
*
* Undefines a macro.
* ----------------------------------------------------------------------------- */
void Preprocessor_undef(const String_or_char *str) {
void Preprocessor_undef(const_String_or_char_ptr str) {
Hash *symbols;
assert(cpp);
symbols = Getattr(cpp, kpp_symbols);

4
Source/Preprocessor/preprocessor.h
View file

@ -19,8 +19,8 @@ extern "C" {
#endif
extern int Preprocessor_expr(String *s, int *error);
extern char *Preprocessor_expr_error(void);
extern Hash *Preprocessor_define(const String_or_char *str, int swigmacro);
extern void Preprocessor_undef(const String_or_char *name);
extern Hash *Preprocessor_define(const_String_or_char_ptr str, int swigmacro);
extern void Preprocessor_undef(const_String_or_char_ptr name);
extern void Preprocessor_init(void);
extern void Preprocessor_delete(void);
extern String *Preprocessor_parse(String *s);

26
Source/Swig/cwrap.c
View file

@ -45,7 +45,7 @@ String *Swig_cparm_name(Parm *p, int i) {
* and user defined types to pointers.
* ----------------------------------------------------------------------------- */
static String *Swig_clocal(SwigType *t, const String_or_char *name, const String_or_char *value) {
static String *Swig_clocal(SwigType *t, const_String_or_char_ptr name, const_String_or_char_ptr value) {
String *decl;
decl = NewStringEmpty();
@ -147,7 +147,7 @@ String *Swig_wrapped_member_var_type(SwigType *t, int varcref) {
}
static String *Swig_wrapped_var_deref(SwigType *t, String_or_char *name, int varcref) {
static String *Swig_wrapped_var_deref(SwigType *t, const_String_or_char_ptr name, int varcref) {
if (SwigType_isclass(t)) {
if (varcref) {
if (cparse_cplusplus) {
@ -163,7 +163,7 @@ static String *Swig_wrapped_var_deref(SwigType *t, String_or_char *name, int var
}
}
static String *Swig_wrapped_var_assign(SwigType *t, const String_or_char *name, int varcref) {
static String *Swig_wrapped_var_assign(SwigType *t, const_String_or_char_ptr name, int varcref) {
if (SwigType_isclass(t)) {
if (varcref) {
return NewStringf("%s", name);
@ -251,7 +251,7 @@ int Swig_cargs(Wrapper *w, ParmList *p) {
* function call.
* ----------------------------------------------------------------------------- */
String *Swig_cresult(SwigType *t, const String_or_char *name, const String_or_char *decl) {
String *Swig_cresult(SwigType *t, const_String_or_char_ptr name, const_String_or_char_ptr decl) {
String *fcall;
fcall = NewStringEmpty();
@ -309,7 +309,7 @@ String *Swig_cresult(SwigType *t, const String_or_char *name, const String_or_ch
*
* ----------------------------------------------------------------------------- */
String *Swig_cfunction_call(String_or_char *name, ParmList *parms) {
String *Swig_cfunction_call(const_String_or_char_ptr name, ParmList *parms) {
String *func;
int i = 0;
int comma = 0;
@ -376,7 +376,7 @@ String *Swig_cfunction_call(String_or_char *name, ParmList *parms) {
* set to "(*this)->" or some similar sequence.
* ----------------------------------------------------------------------------- */
static String *Swig_cmethod_call(String_or_char *name, ParmList *parms, String_or_char *self, String *explicit_qualifier, SwigType *director_type) {
static String *Swig_cmethod_call(const_String_or_char_ptr name, ParmList *parms, const_String_or_char_ptr self, String *explicit_qualifier, SwigType *director_type) {
String *func, *nname;
int i = 0;
Parm *p = parms;
@ -468,7 +468,7 @@ static String *Swig_cmethod_call(String_or_char *name, ParmList *parms, String_o
* calloc(1,sizeof(name));
* ----------------------------------------------------------------------------- */
String *Swig_cconstructor_call(String_or_char *name) {
String *Swig_cconstructor_call(const_String_or_char_ptr name) {
DOH *func;
func = NewStringEmpty();
@ -487,7 +487,7 @@ String *Swig_cconstructor_call(String_or_char *name) {
*
* ----------------------------------------------------------------------------- */
String *Swig_cppconstructor_base_call(String_or_char *name, ParmList *parms, int skip_self) {
String *Swig_cppconstructor_base_call(const_String_or_char_ptr name, ParmList *parms, int skip_self) {
String *func;
String *nname;
int i = 0;
@ -532,15 +532,15 @@ String *Swig_cppconstructor_base_call(String_or_char *name, ParmList *parms, int
return func;
}
String *Swig_cppconstructor_call(String_or_char *name, ParmList *parms) {
String *Swig_cppconstructor_call(const_String_or_char_ptr name, ParmList *parms) {
return Swig_cppconstructor_base_call(name, parms, 0);
}
String *Swig_cppconstructor_nodirector_call(String_or_char *name, ParmList *parms) {
String *Swig_cppconstructor_nodirector_call(const_String_or_char_ptr name, ParmList *parms) {
return Swig_cppconstructor_base_call(name, parms, 1);
}
String *Swig_cppconstructor_director_call(String_or_char *name, ParmList *parms) {
String *Swig_cppconstructor_director_call(const_String_or_char_ptr name, ParmList *parms) {
return Swig_cppconstructor_base_call(name, parms, 0);
}
@ -683,7 +683,7 @@ String *Swig_cppdestructor_call(Node *n) {
*
* ----------------------------------------------------------------------------- */
String *Swig_cmemberset_call(String_or_char *name, SwigType *type, String_or_char *self, int varcref) {
String *Swig_cmemberset_call(const_String_or_char_ptr name, SwigType *type, const_String_or_char_ptr self, int varcref) {
String *func;
String *pname0 = Swig_cparm_name(0, 0);
String *pname1 = Swig_cparm_name(0, 1);
@ -718,7 +718,7 @@ String *Swig_cmemberset_call(String_or_char *name, SwigType *type, String_or_cha
*
* ----------------------------------------------------------------------------- */
String *Swig_cmemberget_call(const String_or_char *name, SwigType *t, String_or_char *self, int varcref) {
String *Swig_cmemberget_call(const_String_or_char_ptr name, SwigType *t, const_String_or_char_ptr self, int varcref) {
String *func;
String *call;
String *pname0 = Swig_cparm_name(0, 0);

10
Source/Swig/error.c
View file

@ -50,7 +50,7 @@ static char wrn_nnum_fmt[64];
static char err_line_fmt[64];
static char err_eof_fmt[64];
static String *format_filename(const String_or_char *filename);
static String *format_filename(const_String_or_char_ptr filename);
/* -----------------------------------------------------------------------------
* Swig_warning()
@ -58,7 +58,7 @@ static String *format_filename(const String_or_char *filename);
* Issue a warning message
* ----------------------------------------------------------------------------- */
void Swig_warning(int wnum, const String_or_char *filename, int line, const char *fmt, ...) {
void Swig_warning(int wnum, const_String_or_char_ptr filename, int line, const char *fmt, ...) {
String *out;
char *msg;
int wrn = 1;
@ -121,7 +121,7 @@ void Swig_warning(int wnum, const String_or_char *filename, int line, const char
* Issue an error message
* ----------------------------------------------------------------------------- */
void Swig_error(const String_or_char *filename, int line, const char *fmt, ...) {
void Swig_error(const_String_or_char_ptr filename, int line, const char *fmt, ...) {
va_list ap;
String *formatted_filename = NULL;
@ -170,7 +170,7 @@ void Swig_error_silent(int s) {
* Takes a comma separate list of warning numbers and puts in the filter.
* ----------------------------------------------------------------------------- */
void Swig_warnfilter(const String_or_char *wlist, int add) {
void Swig_warnfilter(const_String_or_char_ptr wlist, int add) {
char *c;
char *cw;
String *s;
@ -268,7 +268,7 @@ void Swig_error_msg_format(ErrorMessageFormat format) {
*
* Remove double backslashes in Windows filename paths for display
* ----------------------------------------------------------------------------- */
static String *format_filename(const String_or_char *filename) {
static String *format_filename(const_String_or_char_ptr filename) {
String *formatted_filename = NewString(filename);
#if defined(_WIN32)
Replaceall(formatted_filename, "\\\\", "\\");

30
Source/Swig/include.c
View file

@ -33,7 +33,7 @@ int Swig_get_push_dir(void) {
* Adds a directory to the SWIG search path.
* ----------------------------------------------------------------------------- */
List *Swig_add_directory(const String_or_char *dirname) {
List *Swig_add_directory(const_String_or_char_ptr dirname) {
String *adirname;
if (!directories)
directories = NewList();
@ -53,7 +53,7 @@ List *Swig_add_directory(const String_or_char *dirname) {
* the preprocessor to grab files in the same directory as other included files.
* ----------------------------------------------------------------------------- */
void Swig_push_directory(const String_or_char *dirname) {
void Swig_push_directory(const_String_or_char_ptr dirname) {
String *pdirname;
if (!Swig_get_push_dir())
return;
@ -155,7 +155,7 @@ List *Swig_search_path() {
* FILE * on success.
* ----------------------------------------------------------------------------- */
static FILE *Swig_open_file(const String_or_char *name, int sysfile, int use_include_path) {
static FILE *Swig_open_file(const_String_or_char_ptr name, int sysfile, int use_include_path) {
FILE *f;
String *filename;
List *spath = 0;
@ -191,12 +191,12 @@ static FILE *Swig_open_file(const String_or_char *name, int sysfile, int use_inc
}
/* Open a file - searching the include paths to find it */
FILE *Swig_include_open(const String_or_char *name) {
FILE *Swig_include_open(const_String_or_char_ptr name) {
return Swig_open_file(name, 0, 1);
}
/* Open a file - does not use include paths to find it */
FILE *Swig_open(const String_or_char *name) {
FILE *Swig_open(const_String_or_char_ptr name) {
return Swig_open_file(name, 0, 0);
}
@ -233,7 +233,7 @@ String *Swig_read_file(FILE *f) {
* Opens a file and returns it as a string.
* ----------------------------------------------------------------------------- */
static String *Swig_include_any(const String_or_char *name, int sysfile) {
static String *Swig_include_any(const_String_or_char_ptr name, int sysfile) {
FILE *f;
String *str;
String *file;
@ -251,11 +251,11 @@ static String *Swig_include_any(const String_or_char *name, int sysfile) {
return str;
}
String *Swig_include(const String_or_char *name) {
String *Swig_include(const_String_or_char_ptr name) {
return Swig_include_any(name, 0);
}
String *Swig_include_sys(const String_or_char *name) {
String *Swig_include_sys(const_String_or_char_ptr name) {
return Swig_include_any(name, 1);
}
@ -265,7 +265,7 @@ String *Swig_include_sys(const String_or_char *name) {
* Copies the contents of a file into another file
* ----------------------------------------------------------------------------- */
int Swig_insert_file(const String_or_char *filename, File *outfile) {
int Swig_insert_file(const_String_or_char_ptr filename, File *outfile) {
char buffer[4096];
int nbytes;
FILE *f = Swig_include_open(filename);
@ -289,7 +289,7 @@ int Swig_insert_file(const String_or_char *filename, File *outfile) {
static Hash *named_files = 0;
void Swig_register_filebyname(const String_or_char *filename, File *outfile) {
void Swig_register_filebyname(const_String_or_char_ptr filename, File *outfile) {
if (!named_files)
named_files = NewHash();
Setattr(named_files, filename, outfile);
@ -301,7 +301,7 @@ void Swig_register_filebyname(const String_or_char *filename, File *outfile) {
* Get a named file
* ----------------------------------------------------------------------------- */
File *Swig_filebyname(const String_or_char *filename) {
File *Swig_filebyname(const_String_or_char_ptr filename) {
if (!named_files)
return 0;
return Getattr(named_files, filename);
@ -313,7 +313,7 @@ File *Swig_filebyname(const String_or_char *filename) {
* Returns the suffix of a file
* ----------------------------------------------------------------------------- */
char *Swig_file_suffix(const String_or_char *filename) {
char *Swig_file_suffix(const_String_or_char_ptr filename) {
char *d;
char *c = Char(filename);
int len = Len(filename);
@ -335,7 +335,7 @@ char *Swig_file_suffix(const String_or_char *filename) {
* Returns the filename with no suffix attached.
* ----------------------------------------------------------------------------- */
char *Swig_file_basename(const String_or_char *filename) {
char *Swig_file_basename(const_String_or_char_ptr filename) {
static char tmp[1024];
char *c;
strcpy(tmp, Char(filename));
@ -349,7 +349,7 @@ char *Swig_file_basename(const String_or_char *filename) {
*
* Return the file with any leading path stripped off
* ----------------------------------------------------------------------------- */
char *Swig_file_filename(const String_or_char *filename) {
char *Swig_file_filename(const_String_or_char_ptr filename) {
static char tmp[1024];
const char *delim = SWIG_FILE_DELIMITER;
char *c;
@ -367,7 +367,7 @@ char *Swig_file_filename(const String_or_char *filename) {
*
* Return the name of the directory associated with a file
* ----------------------------------------------------------------------------- */
char *Swig_file_dirname(const String_or_char *filename) {
char *Swig_file_dirname(const_String_or_char_ptr filename) {
static char tmp[1024];
const char *delim = SWIG_FILE_DELIMITER;
char *c;

2
Source/Swig/misc.c
View file

@ -77,7 +77,7 @@ void Swig_banner(File *f) {
* Emits a SWIG identifying banner in the target language
* ----------------------------------------------------------------------------- */
void Swig_banner_target_lang(File *f, const String_or_char *commentchar) {
void Swig_banner_target_lang(File *f, const_String_or_char_ptr commentchar) {
Printf(f, "%s This file was automatically generated by SWIG (http://www.swig.org).\n", commentchar);
Printf(f, "%s Version %s\n", commentchar, Swig_package_version());
Printf(f, "%s\n", commentchar);

26
Source/Swig/naming.c
View file

@ -27,13 +27,13 @@ static Hash *naming_hash = 0;
* Register a new naming format.
* ----------------------------------------------------------------------------- */
void Swig_name_register(const String_or_char *method, const String_or_char *format) {
void Swig_name_register(const_String_or_char_ptr method, const_String_or_char_ptr format) {
if (!naming_hash)
naming_hash = NewHash();
Setattr(naming_hash, method, format);
}
void Swig_name_unregister(const String_or_char *method) {
void Swig_name_unregister(const_String_or_char_ptr method) {
if (naming_hash) {
Delattr(naming_hash, method);
}
@ -127,7 +127,7 @@ static int name_mangle(String *r) {
* Converts all of the non-identifier characters of a string to underscores.
* ----------------------------------------------------------------------------- */
String *Swig_name_mangle(const String_or_char *s) {
String *Swig_name_mangle(const_String_or_char_ptr s) {
#if 0
String *r = NewString(s);
name_mangle(r);
@ -143,7 +143,7 @@ String *Swig_name_mangle(const String_or_char *s) {
* Returns the name of a wrapper function.
* ----------------------------------------------------------------------------- */
String *Swig_name_wrapper(const String_or_char *fname) {
String *Swig_name_wrapper(const_String_or_char_ptr fname) {
String *r;
String *f;
@ -168,7 +168,7 @@ String *Swig_name_wrapper(const String_or_char *fname) {
* Returns the name of a class method.
* ----------------------------------------------------------------------------- */
String *Swig_name_member(const String_or_char *classname, const String_or_char *mname) {
String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_char_ptr mname) {
String *r;
String *f;
String *rclassname;
@ -201,7 +201,7 @@ String *Swig_name_member(const String_or_char *classname, const String_or_char *
* Returns the name of the accessor function used to get a variable.
* ----------------------------------------------------------------------------- */
String *Swig_name_get(const String_or_char *vname) {
String *Swig_name_get(const_String_or_char_ptr vname) {
String *r;
String *f;
@ -229,7 +229,7 @@ String *Swig_name_get(const String_or_char *vname) {
* Returns the name of the accessor function used to set a variable.
* ----------------------------------------------------------------------------- */
String *Swig_name_set(const String_or_char *vname) {
String *Swig_name_set(const_String_or_char_ptr vname) {
String *r;
String *f;
@ -253,7 +253,7 @@ String *Swig_name_set(const String_or_char *vname) {
* Returns the name of the accessor function used to create an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_construct(const String_or_char *classname) {
String *Swig_name_construct(const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -286,7 +286,7 @@ String *Swig_name_construct(const String_or_char *classname) {
* Returns the name of the accessor function used to copy an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_copyconstructor(const String_or_char *classname) {
String *Swig_name_copyconstructor(const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -319,7 +319,7 @@ String *Swig_name_copyconstructor(const String_or_char *classname) {
* Returns the name of the accessor function used to destroy an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_destroy(const String_or_char *classname) {
String *Swig_name_destroy(const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -351,7 +351,7 @@ String *Swig_name_destroy(const String_or_char *classname) {
* Returns the name of the accessor function used to disown an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_disown(const String_or_char *classname) {
String *Swig_name_disown(const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -727,7 +727,7 @@ void Swig_features_get(Hash *features, String *prefix, String *name, SwigType *d
* concatenating the feature name plus ':' plus the attribute name.
* ----------------------------------------------------------------------------- */
void Swig_feature_set(Hash *features, const String_or_char *name, SwigType *decl, const String_or_char *featurename, String *value, Hash *featureattribs) {
void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, String *value, Hash *featureattribs) {
Hash *n;
Hash *fhash;
@ -1436,7 +1436,7 @@ static String *apply_rename(String *newname, int fullname, String *prefix, Strin
*
* ----------------------------------------------------------------------------- */
String *Swig_name_make(Node *n, String *prefix, String_or_char *cname, SwigType *decl, String *oldname) {
String *Swig_name_make(Node *n, String *prefix, const_String_or_char_ptr cname, SwigType *decl, String *oldname) {
String *nname = 0;
String *result = 0;
String *name = NewString(cname);

2
Source/Swig/parms.c
View file

@ -17,7 +17,7 @@ char cvsroot_parms_c[] = "$Id$";
* Create a new parameter from datatype 'type' and name 'name'.
* ------------------------------------------------------------------------ */
Parm *NewParm(SwigType *type, const String_or_char *name) {
Parm *NewParm(SwigType *type, const_String_or_char_ptr name) {
Parm *p = NewHash();
set_nodeType(p, "parm");
if (type) {

4
Source/Swig/scanner.c
View file

@ -118,7 +118,7 @@ void Scanner_push(Scanner * s, String *txt) {
* call to Scanner_token().
* ----------------------------------------------------------------------------- */
void Scanner_pushtoken(Scanner * s, int nt, const String_or_char *val) {
void Scanner_pushtoken(Scanner * s, int nt, const_String_or_char_ptr val) {
assert(s);
assert((nt >= 0) && (nt < SWIG_MAXTOKENS));
s->nexttoken = nt;
@ -212,7 +212,7 @@ static char nextchar(Scanner * s) {
* Sets error information on the scanner.
* ----------------------------------------------------------------------------- */
static void set_error(Scanner *s, int line, String_or_char *msg) {
static void set_error(Scanner *s, int line, const_String_or_char_ptr msg) {
s->error_line = line;
s->error = NewString(msg);
}

8
Source/Swig/stype.c
View file

@ -537,7 +537,7 @@ String *SwigType_namestr(const SwigType *t) {
* Create a C string representation of a datatype.
* ----------------------------------------------------------------------------- */
String *SwigType_str(SwigType *s, const String_or_char *id) {
String *SwigType_str(SwigType *s, const_String_or_char_ptr id) {
String *result;
String *element = 0, *nextelement;
List *elements;
@ -732,7 +732,7 @@ SwigType *SwigType_ltype(SwigType *s) {
* with an equivalent assignable version.
* -------------------------------------------------------------------- */
String *SwigType_lstr(SwigType *s, const String_or_char *id) {
String *SwigType_lstr(SwigType *s, const_String_or_char_ptr id) {
String *result;
SwigType *tc;
@ -749,7 +749,7 @@ String *SwigType_lstr(SwigType *s, const String_or_char *id) {
* datatype printed by str().
* ----------------------------------------------------------------------------- */
String *SwigType_rcaststr(SwigType *s, const String_or_char *name) {
String *SwigType_rcaststr(SwigType *s, const_String_or_char_ptr name) {
String *result, *cast;
String *element = 0, *nextelement;
SwigType *td, *rs, *tc = 0;
@ -892,7 +892,7 @@ String *SwigType_rcaststr(SwigType *s, const String_or_char *name) {
* Casts a variable from the real type to the local datatype.
* ----------------------------------------------------------------------------- */
String *SwigType_lcaststr(SwigType *s, const String_or_char *name) {
String *SwigType_lcaststr(SwigType *s, const_String_or_char_ptr name) {
String *result;
result = NewStringEmpty();

120
Source/Swig/swig.h
View file

@ -110,15 +110,15 @@ extern "C" {
extern SwigType *NewSwigType(int typecode);
extern SwigType *SwigType_del_element(SwigType *t);
extern SwigType *SwigType_add_pointer(SwigType *t);
extern SwigType *SwigType_add_memberpointer(SwigType *t, const String_or_char *qual);
extern SwigType *SwigType_add_memberpointer(SwigType *t, const_String_or_char_ptr qual);
extern SwigType *SwigType_del_memberpointer(SwigType *t);
extern SwigType *SwigType_del_pointer(SwigType *t);
extern SwigType *SwigType_add_array(SwigType *t, const String_or_char *size);
extern SwigType *SwigType_add_array(SwigType *t, const_String_or_char_ptr size);
extern SwigType *SwigType_del_array(SwigType *t);
extern SwigType *SwigType_pop_arrays(SwigType *t);
extern SwigType *SwigType_add_reference(SwigType *t);
extern SwigType *SwigType_del_reference(SwigType *t);
extern SwigType *SwigType_add_qualifier(SwigType *t, const String_or_char *qual);
extern SwigType *SwigType_add_qualifier(SwigType *t, const_String_or_char_ptr qual);
extern SwigType *SwigType_del_qualifier(SwigType *t);
extern SwigType *SwigType_add_function(SwigType *t, ParmList *parms);
extern SwigType *SwigType_add_template(SwigType *t, ParmList *parms);
@ -129,10 +129,10 @@ extern "C" {
extern void SwigType_push(SwigType *t, SwigType *s);
extern List *SwigType_parmlist(const SwigType *p);
extern String *SwigType_parm(String *p);
extern String *SwigType_str(SwigType *s, const String_or_char *id);
extern String *SwigType_lstr(SwigType *s, const String_or_char *id);
extern String *SwigType_rcaststr(SwigType *s, const String_or_char *id);
extern String *SwigType_lcaststr(SwigType *s, const String_or_char *id);
extern String *SwigType_str(SwigType *s, const_String_or_char_ptr id);
extern String *SwigType_lstr(SwigType *s, const_String_or_char_ptr id);
extern String *SwigType_rcaststr(SwigType *s, const_String_or_char_ptr id);
extern String *SwigType_lcaststr(SwigType *s, const_String_or_char_ptr id);
extern String *SwigType_manglestr(SwigType *t);
extern SwigType *SwigType_ltype(SwigType *t);
extern int SwigType_ispointer(SwigType *t);
@ -151,7 +151,7 @@ extern "C" {
extern int SwigType_isvarargs(const SwigType *t);
extern int SwigType_istemplate(const SwigType *t);
extern int SwigType_isenum(SwigType *t);
extern int SwigType_check_decl(SwigType *t, const String_or_char *decl);
extern int SwigType_check_decl(SwigType *t, const_String_or_char_ptr decl);
extern SwigType *SwigType_strip_qualifiers(SwigType *t);
extern SwigType *SwigType_functionpointer_decompose(SwigType *t);
extern String *SwigType_base(const SwigType *t);
@ -162,7 +162,7 @@ extern "C" {
extern String *SwigType_prefix(const SwigType *t);
extern int SwigType_array_ndim(SwigType *t);
extern String *SwigType_array_getdim(SwigType *t, int n);
extern void SwigType_array_setdim(SwigType *t, int n, const String_or_char *rep);
extern void SwigType_array_setdim(SwigType *t, int n, const_String_or_char_ptr rep);
extern SwigType *SwigType_array_type(SwigType *t);
extern String *SwigType_default(SwigType *t);
extern void SwigType_typename_replace(SwigType *t, String *pat, String *rep);
@ -173,14 +173,14 @@ extern "C" {
/* --- Type-system managment --- */
extern void SwigType_typesystem_init(void);
extern int SwigType_typedef(SwigType *type, String_or_char *name);
extern int SwigType_typedef_class(String_or_char *name);
extern int SwigType_typedef_using(String_or_char *qname);
extern int SwigType_typedef(SwigType *type, const_String_or_char_ptr name);
extern int SwigType_typedef_class(const_String_or_char_ptr name);
extern int SwigType_typedef_using(const_String_or_char_ptr qname);
extern void SwigType_inherit(String *subclass, String *baseclass, String *cast, String *conversioncode);
extern int SwigType_issubtype(SwigType *subtype, SwigType *basetype);
extern void SwigType_scope_alias(String *aliasname, Typetab *t);
extern void SwigType_using_scope(Typetab *t);
extern void SwigType_new_scope(const String_or_char *name);
extern void SwigType_new_scope(const_String_or_char_ptr name);
extern void SwigType_inherit_scope(Typetab *scope);
extern Typetab *SwigType_pop_scope(void);
extern Typetab *SwigType_set_scope(Typetab *h);
@ -192,8 +192,8 @@ extern "C" {
extern int SwigType_isclass(SwigType *t);
extern void SwigType_attach_symtab(Symtab *syms);
extern void SwigType_remember(SwigType *t);
extern void SwigType_remember_clientdata(SwigType *t, const String_or_char *clientdata);
extern void SwigType_remember_mangleddata(String *mangled, const String_or_char *clientdata);
extern void SwigType_remember_clientdata(SwigType *t, const_String_or_char_ptr clientdata);
extern void SwigType_remember_mangleddata(String *mangled, const_String_or_char_ptr clientdata);
extern void (*SwigType_remember_trace(void (*tf) (SwigType *, String *, String *))) (SwigType *, String *, String *);
extern void SwigType_emit_type_table(File *f_headers, File *f_table);
extern int SwigType_type(SwigType *t);
@ -201,25 +201,25 @@ extern "C" {
/* --- Symbol table module --- */
extern void Swig_symbol_init(void);
extern void Swig_symbol_setscopename(const String_or_char *name);
extern void Swig_symbol_setscopename(const_String_or_char_ptr name);
extern String *Swig_symbol_getscopename(void);
extern String *Swig_symbol_qualifiedscopename(Symtab *symtab);
extern Symtab *Swig_symbol_newscope(void);
extern Symtab *Swig_symbol_setscope(Symtab *);
extern Symtab *Swig_symbol_getscope(const String_or_char *symname);
extern Symtab *Swig_symbol_getscope(const_String_or_char_ptr symname);
extern Symtab *Swig_symbol_current(void);
extern Symtab *Swig_symbol_popscope(void);
extern Node *Swig_symbol_add(String_or_char *symname, Node *node);
extern void Swig_symbol_cadd(String_or_char *symname, Node *node);
extern Node *Swig_symbol_clookup(String_or_char *symname, Symtab *tab);
extern Node *Swig_symbol_clookup_check(String_or_char *symname, Symtab *tab, int (*check) (Node *));
extern Symtab *Swig_symbol_cscope(String_or_char *symname, Symtab *tab);
extern Node *Swig_symbol_clookup_local(String_or_char *symname, Symtab *tab);
extern Node *Swig_symbol_clookup_local_check(String_or_char *symname, Symtab *tab, int (*check) (Node *));
extern Node *Swig_symbol_add(const_String_or_char_ptr symname, Node *node);
extern void Swig_symbol_cadd(const_String_or_char_ptr symname, Node *node);
extern Node *Swig_symbol_clookup(const_String_or_char_ptr symname, Symtab *tab);
extern Node *Swig_symbol_clookup_check(const_String_or_char_ptr symname, Symtab *tab, int (*check) (Node *));
extern Symtab *Swig_symbol_cscope(const_String_or_char_ptr symname, Symtab *tab);
extern Node *Swig_symbol_clookup_local(const_String_or_char_ptr symname, Symtab *tab);
extern Node *Swig_symbol_clookup_local_check(const_String_or_char_ptr symname, Symtab *tab, int (*check) (Node *));
extern String *Swig_symbol_qualified(Node *node);
extern Node *Swig_symbol_isoverloaded(Node *node);
extern void Swig_symbol_remove(Node *node);
extern void Swig_symbol_alias(String_or_char *aliasname, Symtab *tab);
extern void Swig_symbol_alias(const_String_or_char_ptr aliasname, Symtab *tab);
extern void Swig_symbol_inherit(Symtab *tab);
extern SwigType *Swig_symbol_type_qualify(const SwigType *ty, Symtab *tab);
extern String *Swig_symbol_string_qualify(String *s, Symtab *tab);
@ -246,17 +246,17 @@ extern int ParmList_is_compactdefargs(ParmList *p);
/* --- Naming functions --- */
extern void Swig_name_register(const String_or_char *method, const String_or_char *format);
extern void Swig_name_unregister(const String_or_char *method);
extern String *Swig_name_mangle(const String_or_char *s);
extern String *Swig_name_wrapper(const String_or_char *fname);
extern String *Swig_name_member(const String_or_char *classname, const String_or_char *mname);
extern String *Swig_name_get(const String_or_char *vname);
extern String *Swig_name_set(const String_or_char *vname);
extern String *Swig_name_construct(const String_or_char *classname);
extern String *Swig_name_copyconstructor(const String_or_char *classname);
extern String *Swig_name_destroy(const String_or_char *classname);
extern String *Swig_name_disown(const String_or_char *classname);
extern void Swig_name_register(const_String_or_char_ptr method, const_String_or_char_ptr format);
extern void Swig_name_unregister(const_String_or_char_ptr method);
extern String *Swig_name_mangle(const_String_or_char_ptr s);
extern String *Swig_name_wrapper(const_String_or_char_ptr fname);
extern String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_char_ptr mname);
extern String *Swig_name_get(const_String_or_char_ptr vname);
extern String *Swig_name_set(const_String_or_char_ptr vname);
extern String *Swig_name_construct(const_String_or_char_ptr classname);
extern String *Swig_name_copyconstructor(const_String_or_char_ptr classname);
extern String *Swig_name_destroy(const_String_or_char_ptr classname);
extern String *Swig_name_disown(const_String_or_char_ptr classname);
extern void Swig_naming_init(void);
extern void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn);
@ -267,25 +267,25 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern int Swig_need_name_warning(Node *n);
extern int Swig_need_redefined_warn(Node *a, Node *b, int InClass);
extern String *Swig_name_make(Node *n, String *prefix, String_or_char *cname, SwigType *decl, String *oldname);
extern String *Swig_name_make(Node *n, String *prefix, const_String_or_char_ptr cname, SwigType *decl, String *oldname);
extern String *Swig_name_warning(Node *n, String *prefix, String *name, SwigType *decl);
extern String *Swig_name_decl(Node *n);
extern String *Swig_name_fulldecl(Node *n);
/* --- parameterized rename functions --- */
extern void Swig_name_object_set(Hash *namehash, String_or_char *name, SwigType *decl, DOH *object);
extern DOH *Swig_name_object_get(Hash *namehash, String_or_char *prefix, String_or_char *name, SwigType *decl);
extern void Swig_name_object_set(Hash *namehash, String *name, SwigType *decl, DOH *object);
extern DOH *Swig_name_object_get(Hash *namehash, String *prefix, String *name, SwigType *decl);
extern void Swig_name_object_inherit(Hash *namehash, String *base, String *derived);
extern void Swig_features_get(Hash *features, String_or_char *prefix, String_or_char *name, SwigType *decl, Node *n);
extern void Swig_feature_set(Hash *features, const String_or_char *name, SwigType *decl, const String_or_char *featurename, String *value, Hash *featureattribs);
extern void Swig_features_get(Hash *features, String *prefix, String *name, SwigType *decl, Node *n);
extern void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, String *value, Hash *featureattribs);
/* --- Misc --- */
extern char *Swig_copy_string(const char *c);
extern void Swig_set_fakeversion(const char *version);
extern const char *Swig_package_version(void);
extern void Swig_banner(File *f);
extern void Swig_banner_target_lang(File *f, const String_or_char *commentchar);
extern void Swig_banner_target_lang(File *f, const_String_or_char_ptr commentchar);
extern String *Swig_strip_c_comments(const String *s);
extern String *Swig_filename_escape(String *filename);
extern void Swig_filename_correct(String *filename);
@ -311,11 +311,11 @@ extern int ParmList_is_compactdefargs(ParmList *p);
typedef enum { EMF_STANDARD, EMF_MICROSOFT } ErrorMessageFormat;
extern void Swig_warning(int num, const String_or_char *filename, int line, const char *fmt, ...);
extern void Swig_error(const String_or_char *filename, int line, const char *fmt, ...);
extern void Swig_warning(int num, const_String_or_char_ptr filename, int line, const char *fmt, ...);
extern void Swig_error(const_String_or_char_ptr filename, int line, const char *fmt, ...);
extern int Swig_error_count(void);
extern void Swig_error_silent(int s);
extern void Swig_warnfilter(const String_or_char *wlist, int val);
extern void Swig_warnfilter(const_String_or_char_ptr wlist, int val);
extern void Swig_warnall(void);
extern int Swig_warn_count(void);
extern void Swig_error_msg_format(ErrorMessageFormat format);
@ -324,17 +324,17 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern String *Swig_cparm_name(Parm *p, int i);
extern String *Swig_wrapped_var_type(SwigType *t, int varcref);
extern int Swig_cargs(Wrapper *w, ParmList *l);
extern String *Swig_cresult(SwigType *t, const String_or_char *name, const String_or_char *decl);
extern String *Swig_cresult(SwigType *t, const_String_or_char_ptr name, const_String_or_char_ptr decl);
extern String *Swig_cfunction_call(String_or_char *name, ParmList *parms);
extern String *Swig_cconstructor_call(String_or_char *name);
extern String *Swig_cppconstructor_call(String_or_char *name, ParmList *parms);
extern String *Swig_cfunction_call(const_String_or_char_ptr name, ParmList *parms);
extern String *Swig_cconstructor_call(const_String_or_char_ptr name);
extern String *Swig_cppconstructor_call(const_String_or_char_ptr name, ParmList *parms);
extern String *Swig_unref_call(Node *n);
extern String *Swig_ref_call(Node *n, const String *lname);
extern String *Swig_cdestructor_call(Node *n);
extern String *Swig_cppdestructor_call(Node *n);
extern String *Swig_cmemberset_call(String_or_char *name, SwigType *type, String_or_char *self, int varcref);
extern String *Swig_cmemberget_call(const String_or_char *name, SwigType *t, String_or_char *self, int varcref);
extern String *Swig_cmemberset_call(const_String_or_char_ptr name, SwigType *type, const_String_or_char_ptr self, int varcref);
extern String *Swig_cmemberget_call(const_String_or_char_ptr name, SwigType *t, const_String_or_char_ptr self, int varcref);
extern int Swig_add_extension_code(Node *n, const String *function_name, ParmList *parms, SwigType *return_type, const String *code, int cplusplus, const String *self);
@ -363,22 +363,22 @@ extern int ParmList_is_compactdefargs(ParmList *p);
/* --- Legacy Typemap API (somewhat simplified, ha!) --- */
extern void Swig_typemap_init(void);
extern void Swig_typemap_register(const String_or_char *op, ParmList *pattern, String_or_char *code, ParmList *locals, ParmList *kwargs);
extern int Swig_typemap_copy(const String_or_char *op, ParmList *srcpattern, ParmList *pattern);
extern void Swig_typemap_clear(const String_or_char *op, ParmList *pattern);
extern void Swig_typemap_register(const_String_or_char_ptr op, ParmList *pattern, const_String_or_char_ptr code, ParmList *locals, ParmList *kwargs);
extern int Swig_typemap_copy(const_String_or_char_ptr op, ParmList *srcpattern, ParmList *pattern);
extern void Swig_typemap_clear(const_String_or_char_ptr op, ParmList *pattern);
extern int Swig_typemap_apply(ParmList *srcpat, ParmList *destpat);
extern void Swig_typemap_clear_apply(ParmList *pattern);
extern void Swig_typemap_debug(void);
extern Hash *Swig_typemap_search(const String_or_char *op, SwigType *type, const String_or_char *pname, SwigType **matchtype);
extern Hash *Swig_typemap_search_multi(const String_or_char *op, ParmList *parms, int *nmatch);
extern String *Swig_typemap_lookup(const String_or_char *op, Node *n, const String_or_char *lname, Wrapper *f);
extern String *Swig_typemap_lookup_out(const String_or_char *op, Node *n, const String_or_char *lname, Wrapper *f, String *actioncode);
extern void Swig_typemap_attach_kwargs(Hash *tm, const String_or_char *op, Parm *p);
extern Hash *Swig_typemap_search(const_String_or_char_ptr op, SwigType *type, const_String_or_char_ptr pname, SwigType **matchtype);
extern Hash *Swig_typemap_search_multi(const_String_or_char_ptr op, ParmList *parms, int *nmatch);
extern String *Swig_typemap_lookup(const_String_or_char_ptr op, Node *n, const_String_or_char_ptr lname, Wrapper *f);
extern String *Swig_typemap_lookup_out(const_String_or_char_ptr op, Node *n, const_String_or_char_ptr lname, Wrapper *f, String *actioncode);
extern void Swig_typemap_attach_kwargs(Hash *tm, const_String_or_char_ptr op, Parm *p);
extern void Swig_typemap_new_scope(void);
extern Hash *Swig_typemap_pop_scope(void);
extern void Swig_typemap_attach_parms(const String_or_char *op, ParmList *parms, Wrapper *f);
extern void Swig_typemap_attach_parms(const_String_or_char_ptr op, ParmList *parms, Wrapper *f);
/* --- Code fragment support --- */

26
Source/Swig/swigfile.h
View file

@ -9,25 +9,25 @@
/* $Id: swig.h 9603 2006-12-05 21:47:01Z beazley $ */
extern List *Swig_add_directory(const String_or_char *dirname);
extern void Swig_push_directory(const String_or_char *dirname);
extern List *Swig_add_directory(const_String_or_char_ptr dirname);
extern void Swig_push_directory(const_String_or_char_ptr dirname);
extern void Swig_pop_directory(void);
extern String *Swig_last_file(void);
extern List *Swig_search_path(void);
extern FILE *Swig_include_open(const String_or_char *name);
extern FILE *Swig_open(const String_or_char *name);
extern FILE *Swig_include_open(const_String_or_char_ptr name);
extern FILE *Swig_open(const_String_or_char_ptr name);
extern String *Swig_read_file(FILE *f);
extern String *Swig_include(const String_or_char *name);
extern String *Swig_include_sys(const String_or_char *name);
extern int Swig_insert_file(const String_or_char *name, File *outfile);
extern String *Swig_include(const_String_or_char_ptr name);
extern String *Swig_include_sys(const_String_or_char_ptr name);
extern int Swig_insert_file(const_String_or_char_ptr name, File *outfile);
extern void Swig_set_push_dir(int dopush);
extern int Swig_get_push_dir(void);
extern void Swig_register_filebyname(const String_or_char *filename, File *outfile);
extern File *Swig_filebyname(const String_or_char *filename);
extern char *Swig_file_suffix(const String_or_char *filename);
extern char *Swig_file_basename(const String_or_char *filename);
extern char *Swig_file_filename(const String_or_char *filename);
extern char *Swig_file_dirname(const String_or_char *filename);
extern void Swig_register_filebyname(const_String_or_char_ptr filename, File *outfile);
extern File *Swig_filebyname(const_String_or_char_ptr filename);
extern char *Swig_file_suffix(const_String_or_char_ptr filename);
extern char *Swig_file_basename(const_String_or_char_ptr filename);
extern char *Swig_file_filename(const_String_or_char_ptr filename);
extern char *Swig_file_dirname(const_String_or_char_ptr filename);
/* Delimiter used in accessing files and directories */

2
Source/Swig/swigparm.h
View file

@ -11,7 +11,7 @@
/* $Id: swig.h 9629 2006-12-30 18:27:47Z beazley $ */
/* Individual parameters */
extern Parm *NewParm(SwigType *type, const String_or_char *name);
extern Parm *NewParm(SwigType *type, const_String_or_char_ptr name);
extern Parm *CopyParm(Parm *p);
/* Parameter lists */

2
Source/Swig/swigscan.h
View file

@ -15,7 +15,7 @@ extern Scanner *NewScanner(void);
extern void DelScanner(Scanner *);
extern void Scanner_clear(Scanner *);
extern void Scanner_push(Scanner *, String *);
extern void Scanner_pushtoken(Scanner *, int, const String_or_char *value);
extern void Scanner_pushtoken(Scanner *, int, const_String_or_char_ptr value);
extern int Scanner_token(Scanner *);
extern String *Scanner_text(Scanner *);
extern void Scanner_skip_line(Scanner *);

2
Source/Swig/swigtree.h
View file

@ -31,7 +31,7 @@
/* Utility functions */
extern int checkAttribute(Node *obj, const String_or_char *name, const String_or_char *value);
extern int checkAttribute(Node *obj, const_String_or_char_ptr name, const_String_or_char_ptr value);
extern void appendChild(Node *node, Node *child);
extern void prependChild(Node *node, Node *child);
extern void removeNode(Node *node);

10
Source/Swig/swigwrap.h
View file

@ -22,8 +22,8 @@ extern void Wrapper_compact_print_mode_set(int flag);
extern void Wrapper_pretty_print(String *str, File *f);
extern void Wrapper_compact_print(String *str, File *f);
extern void Wrapper_print(Wrapper *w, File *f);
extern int Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl);
extern int Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...);
extern int Wrapper_check_local(Wrapper *w, const String_or_char *name);
extern char *Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl);
extern char *Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...);
extern int Wrapper_add_local(Wrapper *w, const_String_or_char_ptr name, const_String_or_char_ptr decl);
extern int Wrapper_add_localv(Wrapper *w, const_String_or_char_ptr name, ...);
extern int Wrapper_check_local(Wrapper *w, const_String_or_char_ptr name);
extern char *Wrapper_new_local(Wrapper *w, const_String_or_char_ptr name, const_String_or_char_ptr decl);
extern char *Wrapper_new_localv(Wrapper *w, const_String_or_char_ptr name, ...);

26
Source/Swig/symbol.c
View file

@ -220,7 +220,7 @@ void Swig_symbol_init() {
* Set the C scopename of the current symbol table.
* ----------------------------------------------------------------------------- */
void Swig_symbol_setscopename(const String_or_char *name) {
void Swig_symbol_setscopename(const_String_or_char_ptr name) {
String *qname;
/* assert(!Getattr(current_symtab,"name")); */
Setattr(current_symtab, "name", name);
@ -250,10 +250,10 @@ String *Swig_symbol_getscopename() {
* Given a fully qualified C scopename, this function returns a symbol table
* ----------------------------------------------------------------------------- */
Symtab *Swig_symbol_getscope(const String_or_char *name) {
Symtab *Swig_symbol_getscope(const_String_or_char_ptr name) {
if (!symtabs)
return 0;
if (Equal("::", (String_or_char *) name))
if (Equal("::", (const_String_or_char_ptr ) name))
name = "";
return Getattr(symtabs, name);
}
@ -373,7 +373,7 @@ Symtab *Swig_symbol_current() {
* Makes an alias for a symbol in the global symbol table.
* ----------------------------------------------------------------------------- */
void Swig_symbol_alias(String_or_char *aliasname, Symtab *s) {
void Swig_symbol_alias(const_String_or_char_ptr aliasname, Symtab *s) {
String *qname = Swig_symbol_qualifiedscopename(current_symtab);
if (qname) {
Printf(qname, "::%s", aliasname);
@ -421,7 +421,7 @@ void Swig_symbol_inherit(Symtab *s) {
* Adds a node to the C symbol table only.
* ----------------------------------------------------------------------------- */
void Swig_symbol_cadd(String_or_char *name, Node *n) {
void Swig_symbol_cadd(const_String_or_char_ptr name, Node *n) {
Node *append = 0;
Node *cn;
@ -594,7 +594,7 @@ void Swig_symbol_cadd(String_or_char *name, Node *n) {
* for namespace support, type resolution, and other issues.
* ----------------------------------------------------------------------------- */
Node *Swig_symbol_add(String_or_char *symname, Node *n) {
Node *Swig_symbol_add(const_String_or_char_ptr symname, Node *n) {
Hash *c, *cn, *cl = 0;
SwigType *decl, *ndecl;
String *cstorage, *nstorage;
@ -890,7 +890,7 @@ static Node *_symbol_lookup(String *name, Symtab *symtab, int (*check) (Node *n)
return 0;
}
static Node *symbol_lookup(String_or_char *name, Symtab *symtab, int (*check) (Node *n)) {
static Node *symbol_lookup(const_String_or_char_ptr name, Symtab *symtab, int (*check) (Node *n)) {
Node *n = 0;
if (DohCheck(name)) {
n = _symbol_lookup(name, symtab, check);
@ -908,7 +908,7 @@ static Node *symbol_lookup(String_or_char *name, Symtab *symtab, int (*check) (N
* symbol_lookup_qualified()
* ----------------------------------------------------------------------------- */
static Node *symbol_lookup_qualified(String_or_char *name, Symtab *symtab, String *prefix, int local, int (*checkfunc) (Node *n)) {
static Node *symbol_lookup_qualified(const_String_or_char_ptr name, Symtab *symtab, String *prefix, int local, int (*checkfunc) (Node *n)) {
/* This is a little funky, we search by fully qualified names */
if (!symtab)
@ -974,7 +974,7 @@ static Node *symbol_lookup_qualified(String_or_char *name, Symtab *symtab, Strin
* to get the real node.
* ----------------------------------------------------------------------------- */
Node *Swig_symbol_clookup(String_or_char *name, Symtab *n) {
Node *Swig_symbol_clookup(const_String_or_char_ptr name, Symtab *n) {
Hash *hsym = 0;
Node *s = 0;
@ -1046,7 +1046,7 @@ Node *Swig_symbol_clookup(String_or_char *name, Symtab *n) {
* inheritance hierarchy.
* ----------------------------------------------------------------------------- */
Node *Swig_symbol_clookup_check(String_or_char *name, Symtab *n, int (*checkfunc) (Node *n)) {
Node *Swig_symbol_clookup_check(const_String_or_char_ptr name, Symtab *n, int (*checkfunc) (Node *n)) {
Hash *hsym = 0;
Node *s = 0;
@ -1110,7 +1110,7 @@ Node *Swig_symbol_clookup_check(String_or_char *name, Symtab *n, int (*checkfunc
* Swig_symbol_clookup_local()
* ----------------------------------------------------------------------------- */
Node *Swig_symbol_clookup_local(String_or_char *name, Symtab *n) {
Node *Swig_symbol_clookup_local(const_String_or_char_ptr name, Symtab *n) {
Hash *h, *hsym;
Node *s = 0;
@ -1158,7 +1158,7 @@ Node *Swig_symbol_clookup_local(String_or_char *name, Symtab *n) {
* Swig_symbol_clookup_local_check()
* ----------------------------------------------------------------------------- */
Node *Swig_symbol_clookup_local_check(String_or_char *name, Symtab *n, int (*checkfunc) (Node *)) {
Node *Swig_symbol_clookup_local_check(const_String_or_char_ptr name, Symtab *n, int (*checkfunc) (Node *)) {
Hash *h, *hsym;
Node *s = 0;
@ -1209,7 +1209,7 @@ Node *Swig_symbol_clookup_local_check(String_or_char *name, Symtab *n, int (*che
* Look up a scope name.
* ----------------------------------------------------------------------------- */
Symtab *Swig_symbol_cscope(String_or_char *name, Symtab *symtab) {
Symtab *Swig_symbol_cscope(const_String_or_char_ptr name, Symtab *symtab) {
char *cname = Char(name);
if (strncmp(cname, "::", 2) == 0)
return symbol_lookup_qualified(0, global_scope, name, 0, 0);

2
Source/Swig/tree.c
View file

@ -229,7 +229,7 @@ Node *copyNode(Node *n) {
* checkAttribute()
* ----------------------------------------------------------------------------- */
int checkAttribute(Node *n, const String_or_char *name, const String_or_char *value) {
int checkAttribute(Node *n, const_String_or_char_ptr name, const_String_or_char_ptr value) {
String *v = Getattr(n, name);
return v ? Equal(v, value) : 0;
}

28
Source/Swig/typemap.c
View file

@ -107,7 +107,7 @@ void Swig_typemap_init() {
tm_scope = 0;
}
static String *tmop_name(const String_or_char *op) {
static String *tmop_name(const_String_or_char_ptr op) {
static Hash *names = 0;
String *s;
/* Due to "interesting" object-identity semantics of DOH,
@ -164,7 +164,7 @@ Hash *Swig_typemap_pop_scope() {
* Add a new multi-valued typemap
* ----------------------------------------------------------------------------- */
void Swig_typemap_register(const String_or_char *op, ParmList *parms, String_or_char *code, ParmList *locals, ParmList *kwargs) {
void Swig_typemap_register(const_String_or_char_ptr op, ParmList *parms, const_String_or_char_ptr code, ParmList *locals, ParmList *kwargs) {
Hash *tm;
Hash *tm1;
Hash *tm2;
@ -270,7 +270,7 @@ void Swig_typemap_register(const String_or_char *op, ParmList *parms, String_or_
* Retrieve typemap information from current scope.
* ----------------------------------------------------------------------------- */
static Hash *Swig_typemap_get(SwigType *type, String_or_char *name, int scope) {
static Hash *Swig_typemap_get(SwigType *type, const_String_or_char_ptr name, int scope) {
Hash *tm, *tm1;
/* See if this type has been seen before */
if ((scope < 0) || (scope > tm_scope))
@ -292,7 +292,7 @@ static Hash *Swig_typemap_get(SwigType *type, String_or_char *name, int scope) {
* Copy a typemap
* ----------------------------------------------------------------------------- */
int Swig_typemap_copy(const String_or_char *op, ParmList *srcparms, ParmList *parms) {
int Swig_typemap_copy(const_String_or_char_ptr op, ParmList *srcparms, ParmList *parms) {
Hash *tm = 0;
String *tmop;
Parm *p;
@ -347,7 +347,7 @@ int Swig_typemap_copy(const String_or_char *op, ParmList *srcparms, ParmList *pa
* Delete a multi-valued typemap
* ----------------------------------------------------------------------------- */
void Swig_typemap_clear(const String_or_char *op, ParmList *parms) {
void Swig_typemap_clear(const_String_or_char_ptr op, ParmList *parms) {
SwigType *type;
String *name;
Parm *p;
@ -590,7 +590,7 @@ static SwigType *strip_arrays(SwigType *type) {
* that includes a 'code' attribute.
* ----------------------------------------------------------------------------- */
Hash *Swig_typemap_search(const String_or_char *op, SwigType *type, const String_or_char *name, SwigType **matchtype) {
Hash *Swig_typemap_search(const_String_or_char_ptr op, SwigType *type, const_String_or_char_ptr name, SwigType **matchtype) {
Hash *result = 0, *tm, *tm1, *tma;
Hash *backup = 0;
SwigType *noarrays = 0;
@ -737,7 +737,7 @@ ret_result:
* Search for a multi-valued typemap.
* ----------------------------------------------------------------------------- */
Hash *Swig_typemap_search_multi(const String_or_char *op, ParmList *parms, int *nmatch) {
Hash *Swig_typemap_search_multi(const_String_or_char_ptr op, ParmList *parms, int *nmatch) {
SwigType *type;
SwigType *mtype = 0;
String *name;
@ -1173,7 +1173,7 @@ static void typemap_locals(DOHString * s, ParmList *l, Wrapper *f, int argnum) {
* $1 in the out typemap will be replaced by the code in actioncode.
* ----------------------------------------------------------------------------- */
static String *Swig_typemap_lookup_impl(const String_or_char *op, Node *node, const String_or_char *lname, Wrapper *f, String *actioncode) {
static String *Swig_typemap_lookup_impl(const_String_or_char_ptr op, Node *node, const_String_or_char_ptr lname, Wrapper *f, String *actioncode) {
SwigType *type;
SwigType *mtype = 0;
String *pname;
@ -1384,13 +1384,13 @@ static String *Swig_typemap_lookup_impl(const String_or_char *op, Node *node, co
return s;
}
String *Swig_typemap_lookup_out(const String_or_char *op, Node *node, const String_or_char *lname, Wrapper *f, String *actioncode) {
String *Swig_typemap_lookup_out(const_String_or_char_ptr op, Node *node, const_String_or_char_ptr lname, Wrapper *f, String *actioncode) {
assert(actioncode);
assert(Cmp(op, "out") == 0);
return Swig_typemap_lookup_impl(op, node, lname, f, actioncode);
}
String *Swig_typemap_lookup(const String_or_char *op, Node *node, const String_or_char *lname, Wrapper *f) {
String *Swig_typemap_lookup(const_String_or_char_ptr op, Node *node, const_String_or_char_ptr lname, Wrapper *f) {
return Swig_typemap_lookup_impl(op, node, lname, f, 0);
}
@ -1406,7 +1406,7 @@ String *Swig_typemap_lookup(const String_or_char *op, Node *node, const String_o
* A new attribute called "tmap:in:foo" with value "xyz" is attached to p.
* ----------------------------------------------------------------------------- */
void Swig_typemap_attach_kwargs(Hash *tm, const String_or_char *op, Parm *p) {
void Swig_typemap_attach_kwargs(Hash *tm, const_String_or_char_ptr op, Parm *p) {
String *temp = NewStringEmpty();
Parm *kw = Getattr(tm, "kwargs");
while (kw) {
@ -1438,7 +1438,7 @@ void Swig_typemap_attach_kwargs(Hash *tm, const String_or_char *op, Parm *p) {
* attribute, print that warning message.
* ----------------------------------------------------------------------------- */
static void Swig_typemap_warn(const String_or_char *op, Parm *p) {
static void Swig_typemap_warn(const_String_or_char_ptr op, Parm *p) {
String *temp = NewStringf("%s:warning", op);
String *w = Getattr(p, tmop_name(temp));
Delete(temp);
@ -1447,7 +1447,7 @@ static void Swig_typemap_warn(const String_or_char *op, Parm *p) {
}
}
static void Swig_typemap_emit_code_fragments(const String_or_char *op, Parm *p) {
static void Swig_typemap_emit_code_fragments(const_String_or_char_ptr op, Parm *p) {
String *temp = NewStringf("%s:fragment", op);
String *f = Getattr(p, tmop_name(temp));
if (f) {
@ -1479,7 +1479,7 @@ String *Swig_typemap_get_option(Hash *tm, String *name) {
return 0;
}
void Swig_typemap_attach_parms(const String_or_char *op, ParmList *parms, Wrapper *f) {
void Swig_typemap_attach_parms(const_String_or_char_ptr op, ParmList *parms, Wrapper *f) {
Parm *p, *firstp;
Hash *tm;
int nmatch = 0;

10
Source/Swig/typeobj.c
View file

@ -110,7 +110,7 @@ char cvsroot_typeobj_c[] = "$Id$";
* ----------------------------------------------------------------------------- */
#ifdef NEW
SwigType *NewSwigType(const String_or_char *initial) {
SwigType *NewSwigType(const_String_or_char_ptr initial) {
return NewString(initial);
}
@ -419,7 +419,7 @@ int SwigType_isreference(SwigType *t) {
* stored in exactly the same way as "q(const volatile)".
* ----------------------------------------------------------------------------- */
SwigType *SwigType_add_qualifier(SwigType *t, const String_or_char *qual) {
SwigType *SwigType_add_qualifier(SwigType *t, const_String_or_char_ptr qual) {
char temp[256], newq[256];
int sz, added = 0;
char *q, *cqual;
@ -537,7 +537,7 @@ SwigType *SwigType_functionpointer_decompose(SwigType *t) {
* Add, remove, and test for C++ pointer to members.
* ----------------------------------------------------------------------------- */
SwigType *SwigType_add_memberpointer(SwigType *t, const String_or_char *name) {
SwigType *SwigType_add_memberpointer(SwigType *t, const_String_or_char_ptr name) {
String *temp = NewStringf("m(%s).", name);
Insert(t, 0, temp);
Delete(temp);
@ -579,7 +579,7 @@ int SwigType_ismemberpointer(SwigType *t) {
* SwigType_pop_arrays() - Remove all arrays
* ----------------------------------------------------------------------------- */
SwigType *SwigType_add_array(SwigType *t, const String_or_char *size) {
SwigType *SwigType_add_array(SwigType *t, const_String_or_char_ptr size) {
char temp[512];
strcpy(temp, "a(");
strcat(temp, Char(size));
@ -673,7 +673,7 @@ String *SwigType_array_getdim(SwigType *t, int n) {
}
/* Replace nth array dimension */
void SwigType_array_setdim(SwigType *t, int n, const String_or_char *rep) {
void SwigType_array_setdim(SwigType *t, int n, const_String_or_char_ptr rep) {
String *result = 0;
char temp;
char *start;

12
Source/Swig/typesys.c
View file

@ -163,7 +163,7 @@ void SwigType_typesystem_init() {
* already defined.
* ----------------------------------------------------------------------------- */
int SwigType_typedef(SwigType *type, String_or_char *name) {
int SwigType_typedef(SwigType *type, const_String_or_char_ptr name) {
if (Getattr(current_typetab, name))
return -1; /* Already defined */
if (Strcmp(type, name) == 0) { /* Can't typedef a name to itself */
@ -193,7 +193,7 @@ int SwigType_typedef(SwigType *type, String_or_char *name) {
* Defines a class in the current scope.
* ----------------------------------------------------------------------------- */
int SwigType_typedef_class(String_or_char *name) {
int SwigType_typedef_class(const_String_or_char_ptr name) {
String *cname;
/* Printf(stdout,"class : '%s'\n", name); */
if (Getattr(current_typetab, name))
@ -232,7 +232,7 @@ String *SwigType_scope_name(Typetab *ttab) {
* Creates a new scope
* ----------------------------------------------------------------------------- */
void SwigType_new_scope(const String_or_char *name) {
void SwigType_new_scope(const_String_or_char_ptr name) {
Typetab *s;
Hash *ttab;
String *qname;
@ -1071,7 +1071,7 @@ int SwigType_istypedef(SwigType *t) {
* Name is a qualified name like A::B.
* ----------------------------------------------------------------------------- */
int SwigType_typedef_using(String_or_char *name) {
int SwigType_typedef_using(const_String_or_char_ptr name) {
String *base;
String *td;
String *prefix;
@ -1415,7 +1415,7 @@ static Hash *r_remembered = 0; /* Hash of types we remembered already */
static void (*r_tracefunc) (SwigType *t, String *mangled, String *clientdata) = 0;
void SwigType_remember_mangleddata(String *mangled, const String_or_char *clientdata) {
void SwigType_remember_mangleddata(String *mangled, const_String_or_char_ptr clientdata) {
if (!r_mangleddata) {
r_mangleddata = NewHash();
}
@ -1423,7 +1423,7 @@ void SwigType_remember_mangleddata(String *mangled, const String_or_char *client
}
void SwigType_remember_clientdata(SwigType *t, const String_or_char *clientdata) {
void SwigType_remember_clientdata(SwigType *t, const_String_or_char_ptr clientdata) {
String *mt;
SwigType *lt;
Hash *h;

10
Source/Swig/wrapfunc.c
View file

@ -406,7 +406,7 @@ void Wrapper_print(Wrapper *w, File *f) {
* present (which may or may not be okay to the caller).
* ----------------------------------------------------------------------------- */
int Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) {
int Wrapper_add_local(Wrapper *w, const_String_or_char_ptr name, const_String_or_char_ptr decl) {
/* See if the local has already been declared */
if (Getattr(w->localh, name)) {
return -1;
@ -424,7 +424,7 @@ int Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_ch
* to manually construct the 'decl' string before calling.
* ----------------------------------------------------------------------------- */
int Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...) {
int Wrapper_add_localv(Wrapper *w, const_String_or_char_ptr name, ...) {
va_list ap;
int ret;
String *decl;
@ -451,7 +451,7 @@ int Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...) {
* Check to see if a local name has already been declared
* ----------------------------------------------------------------------------- */
int Wrapper_check_local(Wrapper *w, const String_or_char *name) {
int Wrapper_check_local(Wrapper *w, const_String_or_char_ptr name) {
if (Getattr(w->localh, name)) {
return 1;
}
@ -465,7 +465,7 @@ int Wrapper_check_local(Wrapper *w, const String_or_char *name) {
* used. Returns the name that was actually selected.
* ----------------------------------------------------------------------------- */
char *Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) {
char *Wrapper_new_local(Wrapper *w, const_String_or_char_ptr name, const_String_or_char_ptr decl) {
int i;
String *nname = NewString(name);
String *ndecl = NewString(decl);
@ -496,7 +496,7 @@ char *Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_
* to manually construct the 'decl' string before calling.
* ----------------------------------------------------------------------------- */
char *Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...) {
char *Wrapper_new_localv(Wrapper *w, const_String_or_char_ptr name, ...) {
va_list ap;
char *ret;
String *decl;