| #include "EXTERN.h" |
| #include "perl.h" |
| #include "XSUB.h" |
| |
| #include "ClearSilver.h" |
| |
| /* #define DEBUG_MODE 1 |
| */ |
| |
| typedef struct { |
| HDF* hdf; |
| NEOERR* err; |
| } perlHDF; |
| |
| typedef struct { |
| CSPARSE* cs; |
| NEOERR* err; |
| } perlCS; |
| |
| typedef perlHDF* ClearSilver__HDF; |
| typedef perlCS* ClearSilver__CS; |
| |
| static char* g_sort_func_name; |
| |
| static void debug(char* fmt, ...) |
| { |
| #ifdef DEBUG_MODE |
| va_list argp; |
| va_start(argp, fmt); |
| vprintf(fmt, argp); |
| va_end(argp); |
| #endif |
| } |
| |
| static NEOERR *output (void *ctx, char *s) |
| { |
| sv_catpv((SV*)ctx, s); |
| |
| return STATUS_OK; |
| } |
| |
| static int sortFunction(const void* in_a, const void* in_b) |
| { |
| HDF** hdf_a; |
| HDF** hdf_b; |
| perlHDF a, b; |
| SV* sv_a; |
| SV* sv_b; |
| int count; |
| int ret; |
| |
| dSP; |
| |
| hdf_a = (HDF**)in_a; |
| hdf_b = (HDF**)in_b; |
| |
| /* convert to a type Perl can access */ |
| a.hdf = *hdf_a; |
| a.err = STATUS_OK; |
| b.hdf = *hdf_b; |
| b.err = STATUS_OK; |
| |
| ENTER; |
| SAVETMPS; |
| |
| PUSHMARK(SP); |
| sv_a = sv_newmortal(); |
| sv_setref_pv(sv_a, "ClearSilver::HDF", (void*)&a); |
| |
| sv_b = sv_newmortal(); |
| sv_setref_pv(sv_b, "ClearSilver::HDF", (void*)&b); |
| |
| XPUSHs(sv_a); |
| XPUSHs(sv_b); |
| |
| PUTBACK; |
| |
| count = call_pv(g_sort_func_name, G_SCALAR); |
| |
| SPAGAIN; |
| |
| if (count != 1) |
| croak("Big trouble\n"); |
| |
| PUTBACK; |
| |
| ret = POPi; |
| |
| FREETMPS; |
| LEAVE; |
| |
| return ret; |
| } |
| |
| |
| |
| |
| |
| MODULE = ClearSilver PACKAGE = ClearSilver::HDF PREFIX = perlhdf_ |
| |
| ClearSilver::HDF |
| perlhdf_new(self) |
| char* self |
| PREINIT: |
| ClearSilver__HDF hdf; |
| CODE: |
| debug("%s\n", self); |
| hdf = (ClearSilver__HDF)malloc(sizeof(perlHDF)); |
| if (!hdf) { |
| RETVAL = NULL; |
| } else { |
| hdf->err = hdf_init(&(hdf->hdf)); |
| RETVAL = hdf; |
| } |
| OUTPUT: |
| RETVAL |
| |
| void |
| perlhdf_DESTROY(hdf) |
| ClearSilver::HDF hdf; |
| CODE: |
| debug("hdf_DESTROY:%x\n", hdf); |
| hdf_destroy(&(hdf->hdf)); |
| |
| |
| int |
| perlhdf_setValue(hdf, key, value) |
| ClearSilver::HDF hdf |
| char* key |
| char* value |
| CODE: |
| hdf->err = hdf_set_value(hdf->hdf, key, value); |
| if (hdf->err == STATUS_OK) { |
| RETVAL = 0; |
| } else { |
| RETVAL = 1; |
| } |
| OUTPUT: |
| RETVAL |
| |
| |
| char* |
| perlhdf_getValue(hdf, key, default_value) |
| ClearSilver::HDF hdf |
| char* key |
| char* default_value |
| CODE: |
| RETVAL = hdf_get_value(hdf->hdf, key, default_value); |
| OUTPUT: |
| RETVAL |
| |
| |
| int |
| perlhdf_copy(hdf, name, src); |
| ClearSilver::HDF hdf |
| char* name |
| ClearSilver::HDF src |
| CODE: |
| hdf->err = hdf_copy(hdf->hdf, name, src->hdf); |
| if (hdf->err == STATUS_OK) { |
| RETVAL = 0; |
| } else { |
| RETVAL = 1; |
| } |
| OUTPUT: |
| RETVAL |
| |
| int |
| perlhdf_readFile(hdf, filename) |
| ClearSilver::HDF hdf |
| char* filename |
| CODE: |
| hdf->err = hdf_read_file(hdf->hdf, filename); |
| if (hdf->err == STATUS_OK) { |
| RETVAL = 1; |
| } else { |
| RETVAL = 0; |
| } |
| OUTPUT: |
| RETVAL |
| |
| int |
| perlhdf_writeFile(hdf, filename) |
| ClearSilver::HDF hdf |
| char* filename |
| CODE: |
| hdf->err = hdf_write_file(hdf->hdf, filename); |
| if (hdf->err == STATUS_OK) { |
| RETVAL = 1; |
| } else { |
| RETVAL = 0; |
| } |
| OUTPUT: |
| RETVAL |
| |
| ClearSilver::HDF |
| perlhdf_getObj(hdf, name) |
| ClearSilver::HDF hdf; |
| char* name |
| PREINIT: |
| HDF* tmp_hdf; |
| perlHDF* perlhdf; |
| CODE: |
| do { |
| tmp_hdf = hdf_get_obj(hdf->hdf, name); |
| if (!tmp_hdf) { |
| RETVAL = NULL; |
| break; |
| } |
| perlhdf = (perlHDF*)malloc(sizeof(perlHDF)); |
| if (!perlhdf) { |
| RETVAL = NULL; |
| break; |
| } |
| perlhdf->hdf = tmp_hdf; |
| perlhdf->err = STATUS_OK; |
| RETVAL = perlhdf; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| ClearSilver::HDF |
| perlhdf_objChild(hdf) |
| ClearSilver::HDF hdf; |
| PREINIT: |
| HDF* tmp_hdf; |
| perlHDF* child; |
| CODE: |
| do { |
| tmp_hdf = hdf_obj_child(hdf->hdf); |
| if (!tmp_hdf) { |
| RETVAL = NULL; |
| break; |
| } |
| child = (perlHDF*)malloc(sizeof(perlHDF)); |
| if (!child) { |
| RETVAL = NULL; |
| break; |
| } |
| child->hdf = tmp_hdf; |
| child->err = STATUS_OK; |
| RETVAL = child; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| |
| ClearSilver::HDF |
| perlhdf_getChild(hdf, name) |
| ClearSilver::HDF hdf; |
| char* name; |
| PREINIT: |
| HDF* tmp_hdf; |
| perlHDF* child; |
| CODE: |
| do { |
| tmp_hdf = hdf_get_child(hdf->hdf, name); |
| if (!tmp_hdf) { |
| RETVAL = NULL; |
| break; |
| } |
| child = (perlHDF*)malloc(sizeof(perlHDF)); |
| if (!child) { |
| RETVAL = NULL; |
| break; |
| } |
| child->hdf = tmp_hdf; |
| child->err = STATUS_OK; |
| RETVAL = child; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| char* |
| perlhdf_objValue(hdf) |
| ClearSilver::HDF hdf; |
| CODE: |
| RETVAL = hdf_obj_value(hdf->hdf); |
| OUTPUT: |
| RETVAL |
| |
| char* |
| perlhdf_objName(hdf) |
| ClearSilver::HDF hdf; |
| CODE: |
| RETVAL = hdf_obj_name(hdf->hdf); |
| OUTPUT: |
| RETVAL |
| |
| ClearSilver::HDF |
| perlhdf_objNext(hdf) |
| ClearSilver::HDF hdf; |
| PREINIT: |
| HDF* tmp_hdf; |
| perlHDF* next; |
| CODE: |
| do { |
| tmp_hdf = hdf_obj_next(hdf->hdf); |
| if (!tmp_hdf) { |
| RETVAL = NULL; |
| break; |
| } |
| next = (perlHDF*)malloc(sizeof(perlHDF)); |
| if (!next) { |
| RETVAL = NULL; |
| break; |
| } |
| next->hdf = tmp_hdf; |
| next->err = STATUS_OK; |
| RETVAL = next; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| int |
| perlhdf_sortObj(hdf, func_name) |
| ClearSilver::HDF hdf; |
| char* func_name; |
| PREINIT: |
| NEOERR* err; |
| CODE: |
| g_sort_func_name = func_name; |
| err = hdf_sort_obj(hdf->hdf, sortFunction); |
| RETVAL = 0; |
| OUTPUT: |
| RETVAL |
| |
| |
| int |
| perlhdf_setSymlink(hdf, src, dest) |
| ClearSilver::HDF hdf; |
| char* src; |
| char* dest; |
| PREINIT: |
| NEOERR* err; |
| CODE: |
| err = hdf_set_symlink (hdf->hdf, src, dest); |
| if (err == STATUS_OK) { |
| RETVAL = 1; |
| } else { |
| RETVAL = 0; |
| } |
| OUTPUT: |
| RETVAL |
| |
| |
| int |
| perlhdf_removeTree(hdf, name) |
| ClearSilver::HDF hdf; |
| char* name; |
| PREINIT: |
| NEOERR* err; |
| CODE: |
| err = hdf_remove_tree(hdf->hdf, name); |
| if (err == STATUS_OK) { |
| RETVAL = 1; |
| } else { |
| RETVAL = 0; |
| } |
| OUTPUT: |
| RETVAL |
| |
| |
| MODULE = ClearSilver PACKAGE = ClearSilver::CS PREFIX = perlcs_ |
| |
| ClearSilver::CS |
| perlcs_new(self, hdf) |
| char* self |
| ClearSilver::HDF hdf; |
| PREINIT: |
| perlCS* cs; |
| CODE: |
| cs = (perlCS*)malloc(sizeof(perlCS)); |
| if (!cs) { |
| RETVAL = NULL; |
| } else { |
| cs->err = cs_init(&(cs->cs), hdf->hdf); |
| if (cs->err == STATUS_OK) { |
| cs->err = cgi_register_strfuncs(cs->cs); |
| } |
| RETVAL = cs; |
| } |
| OUTPUT: |
| RETVAL |
| |
| void |
| perlcs_DESTROY(cs) |
| ClearSilver::CS cs; |
| CODE: |
| debug("perlcs_DESTROY() is called\n"); |
| cs_destroy(&(cs->cs)); |
| |
| void |
| perlcs_displayError(cs) |
| ClearSilver::CS cs; |
| CODE: |
| nerr_log_error(cs->err); |
| |
| char * |
| perlcs_render(cs) |
| ClearSilver::CS cs |
| CODE: |
| { |
| SV *str = newSV(0); |
| cs->err = cs_render(cs->cs, str, output); |
| if (cs->err == STATUS_OK) { |
| ST(0) = sv_2mortal(str); |
| } else { |
| SvREFCNT_dec(str); |
| ST(0) = &PL_sv_undef; |
| } |
| XSRETURN(1); |
| } |
| |
| int |
| perlcs_parseFile(cs, cs_file) |
| ClearSilver::CS cs |
| char* cs_file |
| CODE: |
| do { |
| cs->err = cs_parse_file(cs->cs, cs_file); |
| if (cs->err != STATUS_OK) { |
| cs->err = nerr_pass(cs->err); |
| RETVAL = 0; |
| break; |
| } |
| RETVAL = 1; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| int |
| perlcs_parseString(cs, in_str) |
| ClearSilver::CS cs |
| char* in_str |
| PREINIT: |
| char* cs_str; |
| int len; |
| CODE: |
| do { |
| len = strlen(in_str); |
| cs_str = (char *)malloc(len); |
| if (!cs_str) { |
| RETVAL = 0; |
| break; |
| } |
| strcpy(cs_str, in_str); |
| cs->err = cs_parse_string(cs->cs, cs_str, len); |
| if (cs->err != STATUS_OK) |
| RETVAL = 0; |
| RETVAL = 1; |
| } while (0); |
| OUTPUT: |
| RETVAL |
| |
| |
| |