You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
6.8 KiB
261 lines
6.8 KiB
/* ----------------------------------------------------------------------------- |
|
* See the LICENSE file for information on copyright, usage and redistribution |
|
* of SWIG, and the README file for authors - http://www.swig.org/release.html. |
|
* |
|
* guile_gh_run.swg |
|
* |
|
* Guile GH runtime file |
|
* ----------------------------------------------------------------------------- */ |
|
|
|
#define SWIGGUILE |
|
#include "guile/gh.h" |
|
#include <stdio.h> |
|
#include <string.h> |
|
#include <stdlib.h> |
|
#include <assert.h> |
|
|
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
typedef SCM (*swig_guile_proc)(); |
|
|
|
#define SWIG_malloc(size) \ |
|
SCM_MUST_MALLOC(size) |
|
#define SWIG_free(mem) \ |
|
scm_must_free(mem) |
|
#define SWIG_ConvertPtr(s, result, type, flags) \ |
|
SWIG_Guile_ConvertPtr(&swig_module, s, result, type, flags) |
|
#define SWIG_MustGetPtr(s, type, argnum, flags) \ |
|
SWIG_Guile_MustGetPtr(&swig_module, s, type, argnum, flags, FUNC_NAME) |
|
#define SWIG_NewPointerObj(ptr, type, owner) \ |
|
SWIG_Guile_NewPointerObj(&swig_module, (void*)ptr, type, owner) |
|
#define SWIG_GetModule(clientdata) SWIG_Guile_GetModule() |
|
#define SWIG_SetModule(clientdata, pointer) SWIG_Guile_SetModule(pointer) |
|
|
|
/* Ignore object-ownership changes in gh mode */ |
|
#define SWIG_Guile_MarkPointerNoncollectable(s) (s) |
|
#define SWIG_Guile_MarkPointerDestroyed(s) (s) |
|
|
|
#define SWIG_contract_assert(expr, msg) \ |
|
if (!(expr)) \ |
|
scm_error(gh_symbol2scm("swig-contract-assertion-failed"), \ |
|
(char *) FUNC_NAME, (char *) msg, \ |
|
SCM_EOL, SCM_BOOL_F); else |
|
|
|
/* SCM_CHAR and SCM_CHARP were introduced in Guile 1.4; the following is for |
|
1.3.4 compatibility. */ |
|
#ifndef SCM_CHAR |
|
# define SCM_CHAR SCM_ICHR |
|
#endif |
|
#ifndef SCM_CHARP |
|
# define SCM_CHARP SCM_ICHRP |
|
#endif |
|
|
|
/* This function replaces gh_scm2char, which is broken in Guile 1.4 */ |
|
SWIGINTERN char |
|
GSWIG_scm2char (SCM s) |
|
{ |
|
if (SCM_CHARP(s)) return SCM_CHAR(s); |
|
scm_wrong_type_arg(NULL, 0, s); |
|
} |
|
#define gh_scm2char GSWIG_scm2char |
|
|
|
/* Interface function */ |
|
#define SWIG_scm2str(x) gh_scm2newstr(x, NULL) |
|
|
|
/* More 1.3.4 compatibility */ |
|
#ifndef SCM_INPUT_PORT_P |
|
# define SCM_INPUT_PORT_P SCM_INPORTP |
|
# define SCM_OUTPUT_PORT_P SCM_OUTPORTP |
|
#endif |
|
|
|
SWIGINTERN long |
|
SWIG_convert_integer(SCM o, |
|
long lower_bound, long upper_bound, |
|
const char *func_name, int argnum) |
|
{ |
|
long value = gh_scm2long(o); |
|
if (value < lower_bound || value > upper_bound) |
|
scm_wrong_type_arg((char *) func_name, argnum, o); |
|
return value; |
|
} |
|
|
|
SWIGINTERN unsigned long |
|
SWIG_convert_unsigned_integer(SCM o, |
|
unsigned long lower_bound, |
|
unsigned long upper_bound, |
|
const char *func_name, int argnum) |
|
{ |
|
unsigned long value = gh_scm2ulong(o); |
|
if (value < lower_bound || value > upper_bound) |
|
scm_wrong_type_arg((char *) func_name, argnum, o); |
|
return value; |
|
} |
|
|
|
SWIGINTERN swig_type_info * |
|
SWIG_Guile_LookupType(swig_module_info *module, SCM s, int normal) |
|
{ |
|
swig_module_info *iter; |
|
if (!module) return 0; |
|
iter = module; |
|
do { |
|
if ((normal && (unsigned long) SCM_TYP16(s) == *((int *)iter->clientdata))) { |
|
|
|
return iter->types[(long) SCM_CAR(s) >> 16]; |
|
} |
|
iter = iter->next; |
|
} while (iter != module); |
|
return 0; |
|
} |
|
|
|
#ifdef SWIG_GLOBAL |
|
#define SWIG_GUILE_MODULE_STATIC |
|
#elif !defined(SWIG_NOINCLUDE) |
|
#define SWIG_GUILE_MODULE_STATIC static |
|
#endif |
|
|
|
#ifdef SWIG_GUILE_MODULE_STATIC |
|
static swig_module_info *swig_guile_module = 0; |
|
SWIG_GUILE_MODULE_STATIC swig_module_info *SWIG_Guile_GetModule(void) { |
|
return swig_guile_module; |
|
} |
|
SWIG_GUILE_MODULE_STATIC void SWIG_Guile_SetModule(swig_module_info *pointer) { |
|
swig_guile_module = pointer; |
|
} |
|
#else |
|
SWIGEXPORT swig_module_info * SWIG_Guile_GetModule(void); |
|
SWIGEXPORT void SWIG_Guile_SetModule(swig_module_info *pointer); |
|
#endif |
|
|
|
SWIGINTERN SCM |
|
SWIG_Guile_NewPointerObj(swig_module_info *module, void *ptr, |
|
swig_type_info *type, int owner) |
|
{ |
|
unsigned long tag; |
|
if (ptr==NULL) return SCM_EOL; |
|
if (!module) return SCM_EOL; |
|
for (tag = 0; tag < module->size; ++tag) { |
|
if (module->types[tag] == type) |
|
break; |
|
} |
|
if (tag >= module->size) |
|
return SCM_EOL; |
|
|
|
|
|
SCM_RETURN_NEWSMOB( ((tag << 16) | *((int *)module->clientdata)), ptr); |
|
} |
|
|
|
/* Return 0 if successful. */ |
|
SWIGINTERN int |
|
SWIG_Guile_ConvertPtr(swig_module_info *module, SCM s, void **result, |
|
swig_type_info *type, int flags) |
|
{ |
|
swig_cast_info *cast; |
|
swig_type_info *from; |
|
if (SCM_NULLP(s)) { |
|
*result = NULL; |
|
return SWIG_OK; |
|
} else if (SCM_NIMP(s)) { |
|
from = SWIG_Guile_LookupType(module, s, 1); |
|
if (!from) return SWIG_ERROR; |
|
if (type) { |
|
cast = SWIG_TypeCheckStruct(from, type); |
|
if (cast) { |
|
int newmemory = 0; |
|
*result = SWIG_TypeCast(cast, (void *) SCM_CDR(s), &newmemory); |
|
assert(!newmemory); /* newmemory handling not yet implemented */ |
|
return SWIG_OK; |
|
} else { |
|
return SWIG_ERROR; |
|
} |
|
} else { |
|
*result = (void *) SCM_CDR(s); |
|
return SWIG_OK; |
|
} |
|
} |
|
return SWIG_ERROR; |
|
} |
|
|
|
SWIGINTERN void * |
|
SWIG_Guile_MustGetPtr (swig_module_info *module, SCM s, swig_type_info *type, |
|
int argnum, int flags, const char *func_name) |
|
{ |
|
void *result; |
|
int res = SWIG_Guile_ConvertPtr(module, s, &result, type, flags); |
|
if (!SWIG_IsOK(res)) { |
|
/* type mismatch */ |
|
scm_wrong_type_arg((char *) func_name, argnum, s); |
|
} |
|
return result; |
|
} |
|
|
|
/* Init */ |
|
|
|
SWIGINTERN int |
|
print_swig (SCM swig_smob, SCM port, scm_print_state *pstate) |
|
{ |
|
swig_type_info *type = SWIG_Guile_LookupType(0, swig_smob, 1); |
|
if (type) { |
|
scm_puts((char *) "#<swig ", port); |
|
if (type->str != NULL) |
|
scm_puts((char *) type->str, port); |
|
else |
|
scm_puts((char *) type->name, port); |
|
scm_puts((char *) " ", port); |
|
scm_intprint((long) SCM_CDR(swig_smob), 16, port); |
|
scm_puts((char *) ">", port); |
|
/* non-zero means success */ |
|
return 1; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
|
|
SWIGINTERN SCM |
|
equalp_swig (SCM A, SCM B) |
|
{ |
|
if (SCM_CAR(A) == SCM_CAR(B) |
|
&& SCM_CDR(A) == SCM_CDR(B)) |
|
return SCM_BOOL_T; |
|
else return SCM_BOOL_F; |
|
} |
|
|
|
SWIGINTERN void |
|
SWIG_Guile_Init (swig_module_info *module) |
|
{ |
|
*((int *)module->clientdata) = |
|
scm_make_smob_type_mfpe((char *) "swig", 0, NULL, NULL, print_swig, equalp_swig); |
|
} |
|
|
|
SWIGINTERN int |
|
SWIG_Guile_GetArgs (SCM *dest, SCM rest, |
|
int reqargs, int optargs, |
|
const char *procname) |
|
{ |
|
int i; |
|
int num_args_passed = 0; |
|
for (i = 0; i<reqargs; i++) { |
|
if (!SCM_CONSP(rest)) |
|
scm_wrong_num_args(gh_str02scm((char *) procname)); |
|
*dest++ = SCM_CAR(rest); |
|
rest = SCM_CDR(rest); |
|
num_args_passed++; |
|
} |
|
for (i = 0; i<optargs && SCM_CONSP(rest); i++) { |
|
*dest++ = SCM_CAR(rest); |
|
rest = SCM_CDR(rest); |
|
num_args_passed++; |
|
} |
|
for (; i<optargs; i++) |
|
*dest++ = SCM_UNDEFINED; |
|
if (!SCM_NULLP(rest)) |
|
scm_wrong_num_args(gh_str02scm((char *) procname)); |
|
return num_args_passed; |
|
} |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
/* guile.swg ends here */
|
|
|