f50c94d933
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@557 626c5289-ae23-0410-ae9c-e8d60b6d4f22
645 lines
15 KiB
C
645 lines
15 KiB
C
/* -----------------------------------------------------------------------------
|
|
* test.c
|
|
*
|
|
* This module implements a SWIG module in the new tag-based parser.
|
|
* This is work in progress.
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
#include "swig.h"
|
|
#include "preprocessor.h"
|
|
#include "lparse.h"
|
|
|
|
/* -------- Module variables ------- */
|
|
|
|
#define CPLUS_PUBLIC 1
|
|
#define CPLUS_PRIVATE 2
|
|
#define CPLUS_PROTECTED 3
|
|
|
|
static DOHFile *runtime = 0;
|
|
static DOHFile *headers = 0;
|
|
static DOHFile *wrappers = 0;
|
|
static DOHFile *init = 0;
|
|
|
|
static DOH *config_top = 0;
|
|
|
|
static int ExternMode = 0;
|
|
static int ImportMode = 0;
|
|
static int ReadOnly = 0;
|
|
static int CPlusMode = CPLUS_PUBLIC;
|
|
static int NewMode = 0;
|
|
static DOHString *ModuleName = 0;
|
|
static int NativeMode = 0;
|
|
static DOHString *NewName = 0;
|
|
static DOHHash *RenameHash = 0;
|
|
static DOHHash *Rules = 0;
|
|
|
|
/* Object oriented flags */
|
|
|
|
static int InClass = 0;
|
|
static DOHString *ClassType = 0;
|
|
static DOHString *ClassName = 0;
|
|
static DOHString *ClassRename = 0;
|
|
static int AddMethods = 0;
|
|
|
|
/* -------- File inclusion directions -------- */
|
|
|
|
static int
|
|
emit_includefile(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
c = Getattr(obj,"child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
}
|
|
|
|
static int
|
|
emit_externfile(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
int oldem = ExternMode;
|
|
ExternMode = 1;
|
|
c = Getattr(obj,"child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
ExternMode = oldem;
|
|
}
|
|
|
|
static int
|
|
emit_importfile(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
int oldem = ExternMode;
|
|
ExternMode = 1;
|
|
ImportMode = 1;
|
|
c = Getattr(obj,"child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
ExternMode = oldem;
|
|
ImportMode = 0;
|
|
}
|
|
|
|
static int
|
|
emit_scope(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
c = Getattr(obj,"child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* -------- Code blocks -------- */
|
|
|
|
/* %{ ... %} directive */
|
|
static int
|
|
emit_headerblock(DOH *obj, void *clientdata) {
|
|
Dump(Getattr(obj,"code"),headers);
|
|
return 0;
|
|
}
|
|
|
|
/* %wrapper %{ ... %} directive */
|
|
static int
|
|
emit_wrapperblock(DOH *obj, void *clientdata) {
|
|
Dump(Getattr(obj,"code"),wrappers);
|
|
return 0;
|
|
}
|
|
|
|
/* %init %{ ... %} directive */
|
|
static int
|
|
emit_initblock(DOH *obj, void *clientdata) {
|
|
Dump(Getattr(obj,"code"),init);
|
|
return 0;
|
|
}
|
|
|
|
/* %runtime %{ ... %} directive */
|
|
static int
|
|
emit_runtimeblock(DOH *obj, void *clientdata) {
|
|
Dump(Getattr(obj,"code"),runtime);
|
|
return 0;
|
|
}
|
|
|
|
/* ------ Basic C declarations ----- */
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* function
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
static int
|
|
emit_function(DOH *obj, void *clientdata) {
|
|
DOHString *name, *scriptname, *type, *storage;
|
|
DOHList *parms;
|
|
DOHHash *p;
|
|
Wrapper *wf;
|
|
int numarg = 0, numopt = 0;
|
|
int i, pn;
|
|
|
|
if (ExternMode) return 0;
|
|
|
|
name = Getattr(obj,"name"); /* Name of the function */
|
|
type = Getattr(obj,"type"); /* Return type */
|
|
parms = Getattr(obj,"parms"); /* Parameters */
|
|
storage = Getattr(obj,"storage"); /* Storage class */
|
|
|
|
/* See if the function is being renamed */
|
|
if (NewName) scriptname = NewName;
|
|
else scriptname = name;
|
|
|
|
/* Is this a member function? */
|
|
if (InClass) {
|
|
/* Handle member functions */
|
|
/* goto function_exit; */
|
|
}
|
|
|
|
wf = NewWrapper();
|
|
|
|
Printv(wf->def,
|
|
"static PyObject *", Swig_name_wrapper(scriptname), "(PyObject *self, PyObject *args) {\n",
|
|
0);
|
|
|
|
/* Loop over all of the function arguments and build pieces of the wrapper function */
|
|
{
|
|
DOHString *parsestr; /* Format string for parsing arguments */
|
|
DOHString *argstr; /* List of arguments */
|
|
DOHString *inputstr;
|
|
DOHString *checkstr;
|
|
DOHString *initstr;
|
|
DOHString *targetstr;
|
|
|
|
parsestr = NewString("");
|
|
argstr = NewString("");
|
|
inputstr = NewString("");
|
|
checkstr = NewString("");
|
|
initstr = NewString("");
|
|
targetstr = NewString("");
|
|
|
|
p = parms;
|
|
pn = 0;
|
|
|
|
while (p) {
|
|
int nmatch = 0;
|
|
DOHHash *map;
|
|
DOHHash *rules;
|
|
char suffix[32];
|
|
|
|
sprintf(suffix,"_%d", pn);
|
|
|
|
map = Swig_map_match(Rules, "argument", p, &nmatch);
|
|
|
|
if (!map) {
|
|
Printf(stderr,"%s:%d. No argument rule for %S\n", Getfile(p),Getline(p),SwigType_cstr(Getattr(p,"type"),Getattr(p,"name")));
|
|
return;
|
|
}
|
|
/* Pull out the rules */
|
|
rules = Getattr(map,"rules");
|
|
if (rules) {
|
|
DOH *linit;
|
|
DOH *lparse;
|
|
DOH *linput;
|
|
DOH *lcheck;
|
|
DOH *largstr;
|
|
DOH *ltarget;
|
|
|
|
linit = Copy(Getattr(rules,"init"));
|
|
lparse = Copy(Getattr(rules,"parse"));
|
|
linput = Copy(Getattr(rules,"input"));
|
|
lcheck = Copy(Getattr(rules,"check"));
|
|
ltarget = Copy(Getattr(rules,"target"));
|
|
|
|
largstr = 0;
|
|
/* Construct the parse and argument strings */
|
|
|
|
if (lparse) {
|
|
DOHList *sp;
|
|
DOHString *pstr;
|
|
int i;
|
|
Seek(lparse,0,SEEK_SET);
|
|
sp = DohSplit(lparse,",",-1);
|
|
pstr = Getitem(sp,0);
|
|
if (pstr) {
|
|
char *c = Char(pstr);
|
|
while (*c && (*c != '\"')) c++;
|
|
c++;
|
|
while (*c && (*c != '\"')) {
|
|
Putc(*c, parsestr);
|
|
c++;
|
|
}
|
|
}
|
|
largstr = NewString("");
|
|
for (i = 1; i < Len(sp); i++) {
|
|
Printf(largstr,",%s",Getitem(sp,i));
|
|
}
|
|
Delete(sp);
|
|
}
|
|
|
|
/* Variable substitution. We're going to walk down the map's children and perform variable name
|
|
replacements */
|
|
|
|
{
|
|
DOH *c = Getattr(map,"child");
|
|
while (c) {
|
|
if (Cmp(Getattr(c,"tag"),"variable") == 0) {
|
|
DOH *vname;
|
|
DOH *rname;
|
|
DOH *vtype;
|
|
DOH *vvalue;
|
|
DOH *storage;
|
|
DOH *local;
|
|
|
|
storage = Getattr(c,"storage");
|
|
vname = Getattr(c,"name");
|
|
vtype = Getattr(c,"type");
|
|
vvalue = Getattr(c,"value");
|
|
|
|
rname = NewStringf("%s_%d",vname,pn);
|
|
|
|
if (largstr) Replace(largstr,vname,rname,DOH_REPLACE_ID | DOH_REPLACE_NOQUOTE);
|
|
if (linit) Replace(linit,vname,rname,DOH_REPLACE_ID | DOH_REPLACE_NOQUOTE);
|
|
if (linput) Replace(linput,vname,rname,DOH_REPLACE_ID | DOH_REPLACE_NOQUOTE);
|
|
if (lcheck) Replace(lcheck,vname,rname,DOH_REPLACE_ID | DOH_REPLACE_NOQUOTE);
|
|
if (ltarget) Replace(ltarget,vname,rname, DOH_REPLACE_ID | DOH_REPLACE_NOQUOTE);
|
|
|
|
/* Declare as local to wrapper function */
|
|
local = NewString("");
|
|
Printf(local,"%S", SwigType_cstr(vtype,rname));
|
|
if (vvalue) {
|
|
Printf(local," = %s", vvalue);
|
|
}
|
|
Wrapper_add_local(wf,rname,local);
|
|
Delete(local);
|
|
Delete(rname);
|
|
}
|
|
c = Swig_next(c);
|
|
}
|
|
}
|
|
if (largstr) Append(argstr, largstr);
|
|
if (linput) Append(inputstr,linput);
|
|
if (lcheck) Append(checkstr,lcheck);
|
|
if (linit) Append(initstr,linit);
|
|
if (ltarget) Printf(targetstr,"%s,", ltarget);
|
|
Delete(largstr);
|
|
Delete(linput);
|
|
Delete(lcheck);
|
|
Delete(linit);
|
|
Delete(ltarget);
|
|
}
|
|
|
|
while (nmatch > 0) {
|
|
p = Swig_next(p);
|
|
nmatch--;
|
|
pn++;
|
|
}
|
|
}
|
|
|
|
/* Dump out the wrapper code */
|
|
|
|
if (pn > 0)
|
|
Delitem(targetstr,DOH_END);
|
|
|
|
Printv(wf->code,
|
|
initstr,
|
|
"if (PyParse_Args(\"", parsestr, "\"", argstr, ") == NULL) return NULL;\n",
|
|
inputstr,
|
|
checkstr,
|
|
"result = ", name, "(", targetstr, ");\n",
|
|
0);
|
|
}
|
|
|
|
Printf(wf->code,"}\n");
|
|
Wrapper_print(wf,wrappers);
|
|
|
|
function_exit:
|
|
Delete(NewName);
|
|
NewName = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* variable
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
static int
|
|
emit_variable(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"variable\n");
|
|
return 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* constant
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
static int
|
|
emit_constant(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"constant\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_typedef(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"typedef\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_enum(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
Printf(stdout,"enum\n");
|
|
c = Getattr(obj,"child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_enumvalue(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"enumvalue\n");
|
|
return 0;
|
|
}
|
|
|
|
/* ------ C++ stuff ------ */
|
|
|
|
static int
|
|
emit_class(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
Printf(stdout,"class\n");
|
|
c = Getattr(obj, "child");
|
|
if (c) {
|
|
int ic = InClass;
|
|
InClass = 1;
|
|
Swig_emit(c,clientdata);
|
|
InClass = ic;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_destructor(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"destructor\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_classdecl(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"classdecl\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_private(DOH *obj, void *clientdata) {
|
|
CPlusMode = CPLUS_PRIVATE;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_protected(DOH *obj, void *clientdata) {
|
|
CPlusMode = CPLUS_PROTECTED;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_public(DOH *obj, void *clientdata) {
|
|
CPlusMode = CPLUS_PUBLIC;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_addmethods(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
Printf(stdout,"addmethods\n");
|
|
c = Getattr(obj, "child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ------ SWIG directives ------ */
|
|
|
|
static int
|
|
emit_moduledirective(DOH *obj, void *clientdata) {
|
|
if (!ModuleName) {
|
|
ModuleName = Getattr(obj,"name");
|
|
DohIncref(ModuleName);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_renamedirective(DOH *obj, void *clientdata) {
|
|
DOHString *name, *rename;
|
|
name = Getattr(obj,"oldname");
|
|
rename = Getattr(obj,"newname");
|
|
if (name && rename)
|
|
Setattr(RenameHash,name,rename);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_readonlydirective(DOH *obj, void *clientdata) {
|
|
ReadOnly = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_readwritedirective(DOH *obj, void *clientdata) {
|
|
ReadOnly = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_namedirective(DOH *obj, void *clientdata) {
|
|
if (NewName) Delete(NewName);
|
|
NewName = Getattr(obj,"name");
|
|
if (NewName) DohIncref(NewName);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_newdirective(DOH *obj, void *clientdata) {
|
|
NewMode = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_exceptiondirective(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"exceptiondirective\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_pragmadirective(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"pragmadirective\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_nativedirective(DOH *obj, void *clientdata) {
|
|
DOH *c;
|
|
int oldnative = NativeMode;
|
|
NativeMode = 1;
|
|
c = Getattr(obj, "child");
|
|
if (c) {
|
|
Swig_emit(c,clientdata);
|
|
}
|
|
NativeMode = oldnative;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_typemap(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"typemap\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_typemapcopy(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"typemapcopy\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_applydirective(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"applydirective\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_cleardirective(DOH *obj, void *clientdata) {
|
|
Printf(stdout,"cleardirective\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
emit_map(DOH *obj, void *clientdata) {
|
|
DOH *parms;
|
|
DOH *rulename;
|
|
DOH *rules;
|
|
|
|
rulename = Getattr(obj,"name");
|
|
parms = Getattr(obj,"parms");
|
|
rules = Getattr(obj,"child");
|
|
|
|
Swig_map_add(Rules,rulename,parms,obj);
|
|
}
|
|
|
|
/* -------- Entry point -------- */
|
|
|
|
static char *runtime_banner = "\n\
|
|
/* ----------------------------------------------------------------------------- \n\
|
|
Runtime\n\
|
|
----------------------------------------------------------------------------- */\n";
|
|
|
|
static char *header_banner = "\n\
|
|
/* ----------------------------------------------------------------------------- \n\
|
|
Headers\n\
|
|
----------------------------------------------------------------------------- */\n";
|
|
|
|
static char *wrapper_banner = "\n\
|
|
/* ----------------------------------------------------------------------------- \n\
|
|
Wrappers\n\
|
|
----------------------------------------------------------------------------- */\n";
|
|
|
|
static char *init_banner = "\n\
|
|
/* ----------------------------------------------------------------------------- \n\
|
|
Initialization\n\
|
|
----------------------------------------------------------------------------- */\n";
|
|
|
|
void test_emit(DOH *top, void *clientdata) {
|
|
|
|
/* Initialization */
|
|
|
|
runtime = NewString(runtime_banner);
|
|
headers = NewString(header_banner);
|
|
wrappers = NewString(wrapper_banner);
|
|
init = NewString(init_banner);
|
|
|
|
Rules = NewHash();
|
|
RenameHash = NewHash();
|
|
|
|
if (config_top)
|
|
Swig_emit(config_top, clientdata);
|
|
|
|
Swig_emit(top, clientdata);
|
|
|
|
Swig_banner(stdout);
|
|
|
|
Dump(runtime,stdout);
|
|
Dump(headers,stdout);
|
|
Dump(wrappers,stdout);
|
|
Dump(init, stdout);
|
|
Delete(runtime);
|
|
Delete(headers);
|
|
Delete(wrappers);
|
|
Delete(init);
|
|
Delete(RenameHash);
|
|
}
|
|
|
|
static SwigRule rules[] = {
|
|
"includefile", emit_includefile,
|
|
"externfile", emit_externfile,
|
|
"importfile", emit_importfile,
|
|
"headerblock", emit_headerblock,
|
|
"wrapperblock", emit_wrapperblock,
|
|
"initblock", emit_initblock,
|
|
"runtimeblock", emit_runtimeblock,
|
|
"scope", emit_scope,
|
|
"function", emit_function,
|
|
"variable", emit_variable,
|
|
"constant", emit_constant,
|
|
"typedef", emit_typedef,
|
|
"class", emit_class,
|
|
"destructor", emit_destructor,
|
|
"enum", emit_enum,
|
|
"enumvalue", emit_enumvalue,
|
|
"classdecl", emit_classdecl,
|
|
"private", emit_private,
|
|
"protected", emit_protected,
|
|
"public", emit_public,
|
|
"addmethods", emit_addmethods,
|
|
"moduledirective", emit_moduledirective,
|
|
"renamedirective", emit_renamedirective,
|
|
"readonlydirective", emit_readonlydirective,
|
|
"readwritedirective", emit_readwritedirective,
|
|
"namedirective", emit_namedirective,
|
|
"newdirective", emit_newdirective,
|
|
"exceptiondirective", emit_exceptiondirective,
|
|
"pragmadirective", emit_pragmadirective,
|
|
"nativedirective", emit_nativedirective,
|
|
"typemap", emit_typemap,
|
|
"typemapcopy", emit_typemapcopy,
|
|
"applydirective", emit_applydirective,
|
|
"cleardirective", emit_cleardirective,
|
|
"map", emit_map,
|
|
NULL, NULL
|
|
};
|
|
|
|
/* Initialize the module */
|
|
void test_init() {
|
|
DOHString *config;
|
|
DOHString *pconfig;
|
|
|
|
Swig_add_rules(rules);
|
|
|
|
|
|
/* Try to get the language specific configuration */
|
|
|
|
config = Swig_include("pyconf.swg");
|
|
|
|
if (!config) {
|
|
Printf(stderr,"*** Fatal error. Unable to find pyconf.swg\n");
|
|
exit(0);
|
|
}
|
|
|
|
/* Run the preprocessor on the configuration file and parse it */
|
|
Seek(config,0,SEEK_SET);
|
|
Setline(config,1);
|
|
pconfig = Preprocessor_parse(config);
|
|
|
|
Seek(pconfig,0,SEEK_SET);
|
|
config_top = LParse_parse(pconfig);
|
|
}
|
|
|
|
|
|
|
|
|