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;
}
