static int eca_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param) { SV *sv = mg->mg_obj; ECAslot *dup = eca_dup(sv2slot(sv)); sv_setuv(sv, PTR2UV(dup)); PERL_UNUSED_VAR(param); return 0; }
SV* plcb_convert_retrieval(PLCB_t *object, AV *docav, const char *data, size_t data_len, uint32_t flags) { SV *ret_sv, *input_sv, *flags_sv; uint32_t f_common, f_legacy; input_sv = newSVpvn(data, data_len); f_common = flags & PLCB_CF_MASK; f_legacy = flags & PLCB_LF_MASK; flags_sv = *av_fetch(docav, PLCB_RETIDX_FMTSPEC, 1); #define IS_FMT(fbase) f_common == PLCB_CF_##fbase || f_legacy == PLCB_LF_##fbase if (object->cv_customdec) { ret_sv = custom_convert(docav, object->cv_customdec, input_sv, &flags, CONVERT_IN); /* Flags remain unchanged? */ } else if (IS_FMT(JSON)) { SvUTF8_on(input_sv); ret_sv = serialize_convert(object->cv_jsondec, input_sv, CONVERT_IN); flags = PLCB_CF_JSON; } else if (IS_FMT(STORABLE)) { ret_sv = serialize_convert(object->cv_deserialize, input_sv, CONVERT_IN); flags = PLCB_CF_STORABLE; } else if (IS_FMT(UTF8)) { SvUTF8_on(input_sv); ret_sv = input_sv; SvREFCNT_inc(ret_sv); flags = PLCB_CF_UTF8; } else { if (IS_FMT(RAW)) { flags = PLCB_CF_RAW; } else { warn("Unrecognized flags 0x%x. Assuming raw", flags); } ret_sv = input_sv; SvREFCNT_inc(ret_sv); } #undef IS_FMT SvREFCNT_dec(input_sv); if (SvIOK(flags_sv) == 0 || SvUVX(flags_sv) != flags) { sv_setuv(flags_sv, flags); } return ret_sv; }
int PLCB_args_set(PLCB_t *object, plcb_SINGLEOP *args, lcb_CMDSTORE *scmd, plcb_DOCVAL *vspec) { UV exp = 0; SV *dur_sv = NULL; int ignore_cas = 0; int persist_to = 0, replicate_to = 0; plcb_OPTION doc_specs[] = { PLCB_KWARG(PLCB_ARG_K_VALUE, SV, &vspec->value), PLCB_KWARG(PLCB_ARG_K_EXPIRY, EXP, &exp), PLCB_KWARG(PLCB_ARG_K_CAS, CAS, &scmd->cas), PLCB_KWARG(PLCB_ARG_K_FMT, U32, &vspec->spec), {NULL} }; plcb_OPTION opt_specs[] = { PLCB_KWARG(PLCB_ARG_K_IGNORECAS, BOOL, &ignore_cas), PLCB_KWARG(PLCB_ARG_K_FRAGMENT, SV, &vspec->value), PLCB_KWARG(PLCB_ARG_K_PERSIST, INT, &persist_to), PLCB_KWARG(PLCB_ARG_K_REPLICATE, INT, &replicate_to), { NULL } }; if (is_append(args->cmdbase)) { doc_specs[0].type = PLCB_ARG_T_PAD; vspec->spec = PLCB_CF_UTF8; } else { vspec->spec = PLCB_CF_JSON; opt_specs[1].type = PLCB_ARG_T_PAD; } load_doc_options(object, args->docav, doc_specs); if (args->cmdopts) { plcb_extract_args(args->cmdopts, opt_specs); } scmd->exptime = exp; if (ignore_cas) { scmd->cas = 0; } if (is_append(args->cmdbase)) { scmd->exptime = 0; } else if (args->cmdbase == PLCB_CMD_ADD) { scmd->cas = 0; } dur_sv = *av_fetch(args->docav, PLCB_RETIDX_OPTIONS, 1); if (SvIOK(dur_sv)) { SvUVX(dur_sv) = PLCB_MKDURABILITY(persist_to, replicate_to); } else { sv_setuv(dur_sv, PLCB_MKDURABILITY(persist_to, replicate_to)); } if (vspec->value == NULL || SvTYPE(vspec->value) == SVt_NULL) { die("Must have value!"); } if (is_append(args->cmdbase)) { if (vspec->spec != PLCB_CF_UTF8 && vspec->spec != PLCB_CF_RAW) { die("append and prepend must use 'raw' or 'utf8' formats"); } } return 0; }
void qrpng_internal (HV * options) { char * text; unsigned text_length; qr_t qr = {0}; qrpng_t qrpng = {0}; SV ** sv_ptr; qrpng_status_t qrpng_status; SV ** size_ptr; /* Get the text. This is assumed to exist. */ HASH_FETCH_PV (options, text); qr.input = text; qr.input_length = text_length; qr.level = 1; sv_ptr = hv_fetch (options, "level", strlen ("level"), 0); if (sv_ptr) { qr.level = SvUV (* sv_ptr); } if (qr.level < 1 || qr.level > 4) { croak ("Bad level %d; this is between 1 and 4", qr.level); } sv_ptr = hv_fetch (options, "version", strlen ("version"), 0); if (sv_ptr) { qr.version = SvUV (* sv_ptr); if (qr.version < 1 || qr.version > 40) { croak ("Bad version %d; this is between 1 and 40", qr.version); } initecc (& qr); } else { initeccsize (& qr); } initframe(& qr); qrencode (& qr); sv_ptr = hv_fetch (options, "quiet", strlen ("quiet"), 0); if (sv_ptr) { SV * quiet_sv; quiet_sv = * sv_ptr; qrpng.quietzone = SvUV (quiet_sv); } else { qrpng.quietzone = QUIETZONE; } sv_ptr = hv_fetch (options, "scale", strlen ("scale"), 0); if (sv_ptr) { SV * scale_sv; scale_sv = * sv_ptr; qrpng.scale = SvUV (scale_sv); } else { qrpng.scale = 3; } qrpng_status = qrpng_make_png (& qr, & qrpng); if (qrpng_status != qrpng_ok) { croak ("bad status %d from qrpng_make_png", qrpng_status); } sv_ptr = hv_fetch (options, "out_sv", strlen ("out_sv"), 0); if (sv_ptr) { /* Write it as a scalar. The code is copied out of Image::PNG::Libpng, but we don't depend on that. */ scalar_as_image_t si = {0}; png_set_write_fn (qrpng.png, & si, perl_png_scalar_write, 0 /* No flush function */); /* Write using our function. */ png_write_png (qrpng.png, qrpng.info, PNG_TRANSFORM_INVERT_MONO, NULL); /* Put the data into %options as $options{png_data}. */ (void) hv_store (options, "png_data", strlen ("png_data"), si.png_image, 0); } else { char * out; unsigned int out_length; HASH_FETCH_PV (options, out); qrpng.filename = out; qrpng_write (& qrpng); } size_ptr = hv_fetch (options, "size", strlen ("size"), 0); if (size_ptr) { // fprintf (stderr, "%s:%d: OK baby.\n", __FILE__, __LINE__); if (SvROK (* size_ptr) && SvTYPE (SvRV (* size_ptr)) < SVt_PVAV) { SV * sv = SvRV (* size_ptr); // fprintf (stderr, "%s:%d: OK baby.\n", __FILE__, __LINE__); sv_setuv (sv, (UV) qrpng.img_size); } } qrfree (& qr); qrpng_free (& qrpng); }
void IvrPython::run(){ FILE* fp; int retval; #ifndef IVR_PERL pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0); #endif //IVR_PERL // static PyThreadState* pyMainThreadState; fp = fopen((char*)fileName,"r"); if(fp != NULL){ #ifndef IVR_PERL PyMethodDef extIvrPython[] = { // media functions {"enqueueMediaFile", ivrEnqueueMediaFile, METH_VARARGS, "ivr: enqueue media file. " "filename: string, front : int = 1(default true) "}, {"emptyMediaQueue", ivrEmptyMediaQueue, METH_VARARGS, "ivr: empty the media queue."}, {"startRecording", ivrStartRecording, METH_VARARGS, "ivr: start recording to file. filename : string."}, {"stopRecording", ivrStopRecording, METH_VARARGS, "ivr: stop recording to file."}, #ifdef IVR_WITH_TTS {"say", ivrSay, METH_VARARGS, "ivr tts and enqueue. msg: string, front: boolean "}, #endif //IVR_WITH_TTS // DTMF functions {"enableDTMFDetection", ivrEnableDTMFDetection, METH_VARARGS, "enable DTMF detection. " "setCallback(onDTMF_FUNC, \"onDTMF\") first!"}, {"disableDTMFDetection", ivrDisableDTMFDetection, METH_VARARGS, "disable DTMF detection permanently"}, {"pauseDTMFDetection", ivrPauseDTMFDetection, METH_VARARGS, "pause DTMF detection temporarily, can be resumed"}, {"resumeDTMFDetection", ivrResumeDTMFDetection, METH_VARARGS, "resume DTMF detection"}, // informational {"getTime", ivrGetTime, METH_VARARGS, "Example Module"}, {"getFrom", ivrGetFrom, METH_VARARGS, "Example Module"}, {"getTo", ivrGetTo, METH_VARARGS, "Example Module"}, {"getFromURI", ivrGetFromURI, METH_VARARGS, "Example Module"}, {"getToURI", ivrGetToURI, METH_VARARGS, "Example Module"}, {"getDomain", ivrGetDomain, METH_VARARGS, "Example Module"}, // call transfer functions {"redirect", ivrRedirect, METH_VARARGS, "Example Module"}, {"dialout", ivrDialout, METH_VARARGS, "Example Module"}, // setting callbacks {"setCallback", setCallback, METH_VARARGS, "Example Module"}, {"sleep", ivrSleep, METH_VARARGS, "Sleep n seconds, or until wakeUp"}, {"usleep", ivrUSleep, METH_VARARGS, "Sleep n microseconds, or until wakeUp"}, {"msleep", ivrmSleep, METH_VARARGS, "Sleep n milliseconds, or until wakeUp"}, {"wakeUp", ivrWakeUp, METH_VARARGS, "wake Up from sleep"}, // legacy from old ivr: sequential functions {"play", ivrPlay, METH_VARARGS, "play and wait for the end of the file (queue empty)"}, {"record", ivrRecord, METH_VARARGS, "record maximum of time secs. Parameter: filename : string, timeout = 0 : int"}, {"playAndDetect", ivrPlayAndDetect, METH_VARARGS, "play and wait for the end of the file (queue empty) or keypress"}, {"detect", ivrDetect, METH_VARARGS, "detect until timeout Parameter: timeout = 0 : int"}, // for jitter/clock skew generation test only // DONT CALL THIS FUNCTION {"mediaThreadUSleep", ivrMediaThreadUSleep, METH_VARARGS, "let mthr sleep, dont call this function"}, {NULL, NULL, 0, NULL}, }; if(!Py_IsInitialized()){ DBG("Start" SCRIPT_TYPE "\n"); Py_Initialize(); PyEval_InitThreads(); pyMainThreadState = PyEval_SaveThread(); } DBG("Start new" SCRIPT_TYPE "interpreter\n"); PyEval_AcquireLock(); // PyThreadState* pyThreadState; if ( (mainInterpreterThreadState = Py_NewInterpreter()) != NULL){ PyObject* ivrPyInitModule = Py_InitModule(PY_MOD_NAME, extIvrPython); PyObject* ivrPythonPointer = PyCObject_FromVoidPtr((void*)this,NULL); if (ivrPythonPointer != NULL) PyModule_AddObject(ivrPyInitModule, "ivrPythonPointer", ivrPythonPointer); Py_tracefunc tmp_t = pythonTrace; PyEval_SetTrace(tmp_t, PyCObject_FromVoidPtr((void*)this,NULL)); if(!PyRun_SimpleFile(fp,(char*)fileName)){ fclose(fp); retval = 0;// true; } else{ PyErr_Print(); ERROR("IVR" SCRIPT_TYPE "Error: Failed to run \"%s\"\n", (char*)fileName); retval = -1;// false; } Py_EndInterpreter(mainInterpreterThreadState); } else{ ERROR("IVR" SCRIPT_TYPE "Error: Failed to start new interpreter.\n"); } PyEval_ReleaseLock(); #else //IVR_PERL DBG("Start" SCRIPT_TYPE ", about to alloc\n"); my_perl_interp = perl_alloc(); printf("interp is %ld\n", (long) my_perl_interp); printf("filename is %s\n", fileName); DBG("finished alloc Perl, about to construct Perl\n"); perl_construct(my_perl_interp); PL_exit_flags |= PERL_EXIT_DESTRUCT_END; char *embedding[] = { "", (char*)fileName}; DBG("finished construct Perl, about to parse Perl\n"); perl_parse(my_perl_interp, xs_init, 2, embedding, (char **)NULL); DBG("finished parse Perl, about to run Perl\n"); SV *pivr = get_sv("Ivr::__ivrpointer__", TRUE); DBG("Ivr::__ivrpointer__ is %lx.\n", (unsigned long int) pivr); sv_setuv(pivr, (unsigned int) this); perl_run(my_perl_interp); DBG("finished run Perl, about to sleep 5 seconds to let callback event catch up\n"); sleep(5); DBG("after sleep, about to destruct\n"); perl_destruct(my_perl_interp); DBG("finished destruct Perl, about to free\n"); perl_free(my_perl_interp); #endif //IVR_PERL } else{ ERROR("IVR" SCRIPT_TYPE "Error: Can not open file \"%s\"\n",(char*) fileName); retval = -1;// false; } DBG("IVR: run finished. stopping rtp stream...\n"); pAmSession->rtp_str.pause(); }
void ffi_pl_closure_call(ffi_cif *ffi_cif, void *result, void **arguments, void *user) { dSP; ffi_pl_closure *closure = (ffi_pl_closure*) user; ffi_pl_type_extra_closure *extra = &closure->type->extra[0].closure; int flags = extra->flags; int i; int count; SV *sv; SV **svp; if(!(flags & G_NOARGS)) { ENTER; SAVETMPS; } PUSHMARK(SP); if(!(flags & G_NOARGS)) { for(i=0; i< ffi_cif->nargs; i++) { if(extra->argument_types[i]->platypus_type == FFI_PL_NATIVE) { switch(extra->argument_types[i]->ffi_type->type) { case FFI_TYPE_VOID: break; case FFI_TYPE_UINT8: sv = sv_newmortal(); sv_setuv(sv, *((uint8_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_SINT8: sv = sv_newmortal(); sv_setiv(sv, *((int8_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_UINT16: sv = sv_newmortal(); sv_setuv(sv, *((uint16_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_SINT16: sv = sv_newmortal(); sv_setiv(sv, *((int16_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_UINT32: sv = sv_newmortal(); sv_setuv(sv, *((uint32_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_SINT32: sv = sv_newmortal(); sv_setiv(sv, *((int32_t*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_UINT64: sv = sv_newmortal(); #ifdef HAVE_IV_IS_64 sv_setuv(sv, *((uint64_t*)arguments[i])); #else sv_setu64(sv, *((uint64_t*)arguments[i])); #endif XPUSHs(sv); break; case FFI_TYPE_SINT64: sv = sv_newmortal(); #ifdef HAVE_IV_IS_64 sv_setiv(sv, *((int64_t*)arguments[i])); #else sv_seti64(sv, *((int64_t*)arguments[i])); #endif XPUSHs(sv); break; case FFI_TYPE_FLOAT: sv = sv_newmortal(); sv_setnv(sv, *((float*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_DOUBLE: sv = sv_newmortal(); sv_setnv(sv, *((double*)arguments[i])); XPUSHs(sv); break; case FFI_TYPE_POINTER: sv = sv_newmortal(); if( *((void**)arguments[i]) != NULL) sv_setiv(sv, PTR2IV( *((void**)arguments[i]) )); XPUSHs(sv); break; } } else if(extra->argument_types[i]->platypus_type == FFI_PL_STRING) { sv = sv_newmortal(); if( *((char**)arguments[i]) != NULL) { if(extra->argument_types[i]->extra[0].string.platypus_string_type == FFI_PL_STRING_FIXED) sv_setpvn(sv, *((char**)arguments[i]), extra->argument_types[i]->extra[0].string.size); else sv_setpv(sv, *((char**)arguments[i])); } XPUSHs(sv); } } PUTBACK; } svp = hv_fetch((HV *)SvRV((SV *)closure->coderef), "code", 4, 0); if (svp) count = call_sv(*svp, flags | G_EVAL); else count = 0; if(SvTRUE(ERRSV)) { #ifdef warn_sv warn_sv(ERRSV); #else warn("%s", SvPV_nolen(ERRSV)); #endif } if(!(flags & G_DISCARD)) { SPAGAIN; if(count != 1) sv = &PL_sv_undef; else sv = POPs; if(extra->return_type->platypus_type == FFI_PL_NATIVE) { switch(extra->return_type->ffi_type->type) { case FFI_TYPE_UINT8: #ifdef FFI_PL_PROBE_BIGENDIAN ((uint8_t*)result)[3] = SvUV(sv); #else *((uint8_t*)result) = SvUV(sv); #endif break; case FFI_TYPE_SINT8: #ifdef FFI_PL_PROBE_BIGENDIAN ((int8_t*)result)[3] = SvIV(sv); #else *((int8_t*)result) = SvIV(sv); #endif break; case FFI_TYPE_UINT16: #ifdef FFI_PL_PROBE_BIGENDIAN ((uint16_t*)result)[1] = SvUV(sv); #else *((uint16_t*)result) = SvUV(sv); #endif break; case FFI_TYPE_SINT16: #ifdef FFI_PL_PROBE_BIGENDIAN ((int16_t*)result)[1] = SvIV(sv); #else *((int16_t*)result) = SvIV(sv); #endif break; case FFI_TYPE_UINT32: *((uint32_t*)result) = SvUV(sv); break; case FFI_TYPE_SINT32: *((int32_t*)result) = SvIV(sv); break; case FFI_TYPE_UINT64: #ifdef HAVE_IV_IS_64 *((uint64_t*)result) = SvUV(sv); #else *((uint64_t*)result) = SvU64(sv); #endif break; case FFI_TYPE_SINT64: #ifdef HAVE_IV_IS_64 *((int64_t*)result) = SvIV(sv); #else *((int64_t*)result) = SvI64(sv); #endif break; case FFI_TYPE_FLOAT: *((float*)result) = SvNV(sv); break; case FFI_TYPE_DOUBLE: *((double*)result) = SvNV(sv); break; case FFI_TYPE_POINTER: *((void**)result) = SvOK(sv) ? INT2PTR(void*, SvIV(sv)) : NULL; break; } } PUTBACK; }