void kp_obj_show(ktap_state_t *ks, const ktap_val_t *v) { switch (itype(v)) { case KTAP_TNIL: kp_puts(ks, "nil"); break; case KTAP_TTRUE: kp_puts(ks, "true"); break; case KTAP_TFALSE: kp_puts(ks, "false"); break; case KTAP_TNUM: kp_printf(ks, "%ld", nvalue(v)); break; case KTAP_TLIGHTUD: kp_printf(ks, "lightud 0x%lx", (unsigned long)pvalue(v)); break; case KTAP_TCFUNC: kp_printf(ks, "cfunction 0x%lx", (unsigned long)fvalue(v)); break; case KTAP_TFUNC: kp_printf(ks, "function 0x%lx", (unsigned long)gcvalue(v)); break; case KTAP_TSTR: kp_puts(ks, svalue(v)); break; case KTAP_TTAB: kp_printf(ks, "table 0x%lx", (unsigned long)hvalue(v)); break; #ifdef CONFIG_KTAP_FFI case KTAP_TCDATA: kp_cdata_dump(ks, cdvalue(v)); break; #endif case KTAP_TEVENTSTR: /* check event context */ if (!ks->current_event) { kp_error(ks, "cannot stringify event str in invalid context\n"); return; } kp_transport_event_write(ks, ks->current_event); break; case KTAP_TKSTACK: kp_transport_print_kstack(ks, v->val.stack.depth, v->val.stack.skip); break; default: kp_error(ks, "print unknown value type: %d\n", itype(v)); break; } }
/* Compare two objects without calling metamethods. */ int lj_obj_equal(cTValue *o1, cTValue *o2) { if (itype(o1) == itype(o2)) { if (tvispri(o1)) return 1; if (!tvisnum(o1)) return gcrefeq(o1->gcr, o2->gcr); } else if (!tvisnumber(o1) || !tvisnumber(o2)) { return 0; } return numberVnum(o1) == numberVnum(o2); }
const ktap_val_t *kp_tab_get(ktap_tab_t *t, const ktap_val_t *key) { int i; switch (itype(key)) { case KTAP_TNIL: return niltv; case KTAP_TNUM: for (i = 0; i <= t->hmask; i++) { ktap_val_t *v = gkey(gnode(t, i)); if (is_number(v) && nvalue(key) == nvalue(v)) return gval(gnode(t, i)); } break; case KTAP_TSTR: for (i = 0; i <= t->hmask; i++) { ktap_val_t *v = gkey(gnode(t, i)); if (is_string(v) && (rawtsvalue(key) == rawtsvalue(v))) return gval(gnode(t, i)); } break; default: for (i = 0; i <= t->hmask; i++) { if (kp_obj_equal(key, gkey(gnode(t, i)))) return gval(gnode(t, i)); } break; } return niltv; }
void luaL_setcdatagc(struct lua_State *L, int idx) { /* Calculate absolute value in the stack. */ if (idx < 0) idx = lua_gettop(L) + idx + 1; /* Code below is based on ffi_gc() from luajit/src/lib_ffi.c */ /* Get cdata from the stack */ assert(lua_type(L, idx) == LUA_TCDATA); GCcdata *cd = cdataV(L->base + idx - 1); /* Get finalizer from the stack */ TValue *fin = lj_lib_checkany(L, lua_gettop(L)); #if !defined(NDEBUG) CTState *cts = ctype_cts(L); CType *ct = ctype_raw(cts, cd->ctypeid); (void) ct; assert(ctype_isptr(ct->info) || ctype_isstruct(ct->info) || ctype_isrefarray(ct->info)); #endif /* !defined(NDEBUG) */ /* Set finalizer */ lj_cdata_setfin(L, cd, gcval(fin), itype(fin)); /* Pop finalizer */ lua_pop(L, 1); }
STCalEnum::InterpolationType CalibrationManager::stringToInterpolationEnum(const string &s) { String itype(s); itype.upcase(); const Char *c = itype.c_str(); String::size_type len = itype.size(); Regex nearest("^NEAREST(NEIGHBOR)?$"); Regex linear("^LINEAR$"); Regex spline("^(C(UBIC)?)?SPLINE$"); Regex poly("^POLY(NOMIAL)?$"); if (nearest.match(c, len) != String::npos) { return STCalEnum::NearestInterpolation; } else if (linear.match(c, len) != String::npos) { return STCalEnum::LinearInterpolation; } else if (spline.match(c, len) != String::npos) { return STCalEnum::CubicSplineInterpolation; } else if (poly.match(c, len) != String::npos) { return STCalEnum::PolynomialInterpolation; } os_.origin(LogOrigin("CalibrationManager","stringToInterpolationEnum",WHERE)); os_ << LogIO::WARN << "Interpolation type " << s << " is not available. Use default interpolation method." << LogIO::POST; return STCalEnum::DefaultInterpolation; }
void kp_obj_dump(ktap_state_t *ks, const ktap_val_t *v) { switch (itype(v)) { case KTAP_TNIL: kp_puts(ks, "NIL"); break; case KTAP_TTRUE: kp_printf(ks, "true"); break; case KTAP_TFALSE: kp_printf(ks, "false"); break; case KTAP_TNUM: kp_printf(ks, "NUM %ld", nvalue(v)); break; case KTAP_TLIGHTUD: kp_printf(ks, "LIGHTUD 0x%lx", (unsigned long)pvalue(v)); break; case KTAP_TFUNC: kp_printf(ks, "FUNCTION 0x%lx", (unsigned long)fvalue(v)); break; case KTAP_TSTR: kp_printf(ks, "STR #%s", svalue(v)); break; case KTAP_TTAB: kp_printf(ks, "TABLE 0x%lx", (unsigned long)hvalue(v)); break; default: kp_printf(ks, "GCVALUE 0x%lx", (unsigned long)gcvalue(v)); break; } }
/* Helper for ordered comparisons. String compare, __lt/__le metamethods. */ TValue *lj_meta_comp(lua_State *L, cTValue *o1, cTValue *o2, int op) { if (LJ_HASFFI && (tviscdata(o1) || tviscdata(o2))) { ASMFunction cont = (op & 1) ? lj_cont_condf : lj_cont_condt; MMS mm = (op & 2) ? MM_le : MM_lt; cTValue *mo = lj_meta_lookup(L, tviscdata(o1) ? o1 : o2, mm); if (LJ_UNLIKELY(tvisnil(mo))) goto err; return mmcall(L, cont, mo, o1, o2); } else if (LJ_52 || itype(o1) == itype(o2)) { /* Never called with two numbers. */ if (tvisstr(o1) && tvisstr(o2)) { int32_t res = lj_str_cmp(strV(o1), strV(o2)); return (TValue *)(intptr_t)(((op&2) ? res <= 0 : res < 0) ^ (op&1)); } else { trymt: while (1) { ASMFunction cont = (op & 1) ? lj_cont_condf : lj_cont_condt; MMS mm = (op & 2) ? MM_le : MM_lt; cTValue *mo = lj_meta_lookup(L, o1, mm); #if LJ_52 if (tvisnil(mo) && tvisnil((mo = lj_meta_lookup(L, o2, mm)))) #else cTValue *mo2 = lj_meta_lookup(L, o2, mm); if (tvisnil(mo) || !lj_obj_equal(mo, mo2)) #endif { if (op & 2) { /* MM_le not found: retry with MM_lt. */ cTValue *ot = o1; o1 = o2; o2 = ot; /* Swap operands. */ op ^= 3; /* Use LT and flip condition. */ continue; } goto err; } return mmcall(L, cont, mo, o1, o2); } } } else if (tvisbool(o1) && tvisbool(o2)) { goto trymt; } else { err: lj_err_comp(L, o1, o2); return NULL; } }
static int kplib_stringof(ktap_state_t *ks) { ktap_val_t *v = kp_arg(ks, 1); const ktap_str_t *ts = NULL; if (itype(v) == KTAP_TEVENTSTR) { ts = kp_event_stringify(ks); } else if (itype(v) == KTAP_TKIP) { char str[KSYM_SYMBOL_LEN]; SPRINT_SYMBOL(str, nvalue(v)); ts = kp_str_newz(ks, str); } if (unlikely(!ts)) return -1; set_string(ks->top++, ts); return 1; }
static int doisrch(BW *bw, int dir) { /* Create a struct isrch */ struct isrch *isrch = (struct isrch *) joe_malloc(SIZEOF(struct isrch)); izque(IREC, link, &isrch->irecs); isrch->pattern = vsncpy(NULL, 0, NULL, 0); isrch->dir = dir; isrch->quote = 0; isrch->prompt = vsncpy(NULL, 0, sz(joe_gettext(_("I-find: ")))); isrch->ofst = sLen(isrch->prompt); return itype(bw->parent, -1, isrch, NULL); }
int kp_obj_equal(const ktap_val_t *t1, const ktap_val_t *t2) { switch (itype(t1)) { case KTAP_TNIL: return 1; case KTAP_TNUM: return nvalue(t1) == nvalue(t2); case KTAP_TTRUE: case KTAP_TFALSE: return itype(t1) == itype(t2); case KTAP_TLIGHTUD: return pvalue(t1) == pvalue(t2); case KTAP_TFUNC: return fvalue(t1) == fvalue(t2); case KTAP_TSTR: return rawtsvalue(t1) == rawtsvalue(t2); default: return gcvalue(t1) == gcvalue(t2); } return 0; }
/* * ktap will not use lua's length operator for table, * also # is not for length operator any more in ktap. */ int kp_obj_len(ktap_state_t *ks, const ktap_val_t *v) { switch(itype(v)) { case KTAP_TTAB: return kp_tab_len(ks, hvalue(v)); case KTAP_TSTR: return rawtsvalue(v)->len; default: kp_printf(ks, "cannot get length of type %d\n", v->type); return -1; } return 0; }
void op_itype2() { /* Stack: |=============================|=============================| | BEFORE | AFTER | |=============================|=============================| top | TOTAL() accumulator base | Result | |-----------------------------|-----------------------------| | ADDR to object code | | |=============================|=============================| */ DESCRIPTOR * descr; descr = e_stack - 1; GetInt(descr); tbase = (short int)(descr->data.value); k_pop(1); itype(); }
int ursrch(W *w, int k) { BW *bw; WIND_BW(bw, w); if (smode && lastisrch) { struct isrch *isrch = lastisrch; lastisrch = 0; return itype(bw->parent, 'R' - '@', isrch, NULL); } else { if (globalsrch) { rmsrch(globalsrch); globalsrch = 0; } if (lastisrch) { lastpat = vstrunc(lastpat, 0); lastpat = vsncpy(lastpat, 0, lastisrch->pattern, sLen(lastisrch->pattern)); rmisrch(lastisrch); lastisrch = 0; } return doisrch(bw, 1); } }
void op_itype() { tbase = 0; itype(); }
/*===================================== * iistype -- Check type of interp node *===================================*/ BOOLEAN iistype (PNODE node, INT type) { return itype(node) == type; }
void triangleMesher(const Vector3d& v1, const Vector3d& v2, const Vector3d& v3, const int nArcDiv, MV3& vertex) { M3 xyz(3,27,4); IA1 ixstr(4), ixend(4), iystr(4), iyend(4), izstr(4), izend(4), nzsti(4), itype(4); itype(1)=itype(2)=itype(3)=itype(4)=1; const int ndiv = ((nArcDiv+1)/2)*2; ixstr(1)=iystr(1)=izstr(1)=1; ixend(1)=iyend(1)=ndiv+1; izend(1)=1; const int izn = 1; const int lengx=ixend(izn)-ixstr(izn); const int lengy=iyend(izn)-iystr(izn); const int lengz=izend(izn)-izstr(izn); ixstr(izn)=ixstr(izn); ixend(izn)=ixstr(izn)+lengx/2; iystr(izn)=iystr(izn); iyend(izn)=iystr(izn)+lengy/2; izstr(izn)=izstr(izn); izend(izn)=izend(izn); const int izn1=izn+1; ixstr(izn1)=ixstr(izn)+lengx/2; ixend(izn1)=ixstr(izn)+lengx; iystr(izn1)=iystr(izn); iyend(izn1)=iystr(izn)+lengy/2; izstr(izn1)=izstr(izn); izend(izn1)=izend(izn); const int izn2=izn+2; ixstr(izn2)=ixstr(izn)+lengx/2; ixend(izn2)=ixstr(izn)+lengx; iystr(izn2)=iystr(izn)+lengy/2; iyend(izn2)=iystr(izn)+lengy; izstr(izn2)=izstr(izn); izend(izn2)=izend(izn); const int nx=ixend(1)-ixstr(1)+1; const int nz=izend(1)-izstr(1)+1; nzsti(1)=1; nzsti(2)=nzsti(1)+nx; nzsti(3)=nzsti(2)+nx; vertex.reSize(nx*3, nx, nz); const Vector3d v123 = (v1+v2+v3)*(1.0/3); const Vector3d v12 = (v1+v2)*0.5; const Vector3d v23 = (v2+v3)*0.5; const Vector3d v13 = (v1+v3)*0.5; //zone 1 Vector3dToFMatrix(v1, xyz, 1, izn); Vector3dToFMatrix(v12, xyz, 2, izn); Vector3dToFMatrix(v123, xyz, 3, izn); Vector3dToFMatrix(v13, xyz, 4, izn); Vector3dToFMatrix(v1, xyz, 5, izn); Vector3dToFMatrix(v12, xyz, 6, izn); Vector3dToFMatrix(v123, xyz, 7, izn); Vector3dToFMatrix(v13, xyz, 8, izn); //zone 2 Vector3dToFMatrix(v2, xyz, 1, izn1); Vector3dToFMatrix(v23, xyz, 2, izn1); Vector3dToFMatrix(v123, xyz, 3, izn1); Vector3dToFMatrix(v12, xyz, 4, izn1); Vector3dToFMatrix(v2, xyz, 5, izn1); Vector3dToFMatrix(v23, xyz, 6, izn1); Vector3dToFMatrix(v123, xyz, 7, izn1); Vector3dToFMatrix(v12, xyz, 8, izn1); //zone 3 Vector3dToFMatrix(v3, xyz, 1, izn2); Vector3dToFMatrix(v13, xyz, 2, izn2); Vector3dToFMatrix(v123, xyz, 3, izn2); Vector3dToFMatrix(v23, xyz, 4, izn2); Vector3dToFMatrix(v3, xyz, 5, izn2); Vector3dToFMatrix(v13, xyz, 6, izn2); Vector3dToFMatrix(v123, xyz, 7, izn2); Vector3dToFMatrix(v23, xyz, 8, izn2); for (int iz=izn; iz<=3; iz++){ MV3 mat=vertex(nzsti(iz)); mesh8zn(mat,ixstr,ixend,iystr,iyend,izstr,izend,xyz,iz,itype); } }
// ============================================================================ // pxpByteCode // ============================================================================ pxpByteCode::pxpByteCode( pkgDecompiler* decompiler ) : Decompiler(decompiler) , CToken(NULL) , CTokenTree(NULL) , CTokenGroup(NULL) , CTokenGroupTree(NULL) , CTokenItem(NULL) , CTokenItemTree(NULL) , CTokenGroupCnd(NULL) , CTokenGroupCndTree(NULL) , unXmlParser() { // temp tree nodes unXmlParseTree bytecode ( wxT("bytecode") ); unXmlParseTree bgroup ( wxT("group") ); unXmlParseTree gname ( wxT("name") ); unXmlParseTree gmemo ( wxT("memo") ); unXmlParseTree gtoken ( wxT("token") ); unXmlParseTree tcode ( wxT("code") ); unXmlParseTree tname ( wxT("name") ); unXmlParseTree tdesc ( wxT("desc") ); unXmlParseTree tdata ( wxT("data") ); unXmlParseTree titem ( wxT("item") ); unXmlParseTree itype ( wxT("type") ); unXmlParseTree iname ( wxT("name") ); unXmlParseTree ttext ( wxT("text") ); unXmlParseTree gcond ( wxT("gcond") ); unXmlParseTree cif ( wxT("if") ); unXmlParseTree ceq ( wxT("eq") ); unXmlParseTree cthen ( wxT("then") ); unXmlParseTree cleft ( wxT("left") ); unXmlParseTree cright ( wxT("right") ); unXmlParseTree ctstream ( wxT("tstream") ); unXmlParseTree cnum ( wxT("num") ); unXmlParseTree nfunc ( wxT("nativefunctions") ); unXmlParseTree ffirst ( wxT("first") ); unXmlParseTree fextended ( wxT("extended") ); // token group - pre bgroup.AddCommand( new_xpObjCreate<pkgTokenGroup>(txpParseTree) ); bgroup.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenGroup, txpTokenGroupObject ) ); bgroup.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenGroupTree, txpParseTree ) ); gname.AddCommand( new_xpFunc1( txpTokenGroup, &pkgTokenGroup::SetName, txpNodeName(txpParseTree) ) ); gname.AddPostCommand( new_xpFunc1( Decompiler, &pkgDecompiler::AddTokenGroup, txpTokenGroup ) ); // token group - post bgroup.AddPostCommand( new_xpObjClear(txpParseTree) ); bgroup.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenGroup ) ); bgroup.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenGroupTree ) ); // gcond = pre gcond.AddCommand( new_xpObjCreate<pkgTokenCondition>(txpParseTree) ); gcond.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenGroupCnd, txpTokenGroupCndObject ) ); gcond.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenGroupCndTree, txpParseTree ) ); // gcond = post gcond.AddPostCommand( new_xpObjClear(txpParseTree) ); gcond.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenGroupCnd ) ); gcond.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenGroupCndTree ) ); // token - pre gtoken.AddCommand( new_xpObjCreate<dtToken>(txpParseTree) ); gtoken.AddCommand( new_xpFunc1( this, &pxpByteCode::SetToken, txpTokenObject ) ); gtoken.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenTree, txpParseTree ) ); tcode.AddCommand( new_xpFunc1( txpTokenTreeObject, &dtToken::SetTokenData, txpNodeData(txpParseTree) ) ); tname.AddCommand( new_xpFunc1( txpTokenTreeObject, &dtToken::SetTokenName, txpNodeName(txpParseTree) ) ); tdesc.AddCommand( new_xpFunc1( txpTokenTreeObject, &dtToken::SetDesc, txpNodeName(txpParseTree) ) ); tdesc.AddCommand( new_xpFunc1( txpTokenGroup, &pkgTokenGroup::AddToken, txpToken ) ); tdesc.AddCommand( new_xpFunc2( Decompiler, &pkgDecompiler::AddToken, txpToken, txpTokenGroupCnd ) ); // token - post gtoken.AddPostCommand( new_xpFunc0( txpToken, &dtToken::DumpInfo ) ); gtoken.AddPostCommand( new_xpObjClear(txpParseTree) ); gtoken.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearToken ) ); gtoken.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenTree ) ); // titem - pre titem.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenItemTree, txpParseTree ) ); itype.AddCommand( new_xpObjFactory( txpTokenItemTree, &GDataTypeFactory, &pkgDataTypeFactory::Create, txpNodeName(txpParseTree) ) ); itype.AddCommand( new_xpFunc1( this, &pxpByteCode::SetTokenItem, txpTokenItemTreeObject ) ); iname.AddCommand( new_xpFunc1( txpTokenItem, &pkgDataType::SetDesc, txpNodeName(txpParseTree) ) ); // titem - post titem.AddPostCommand( new_xpFunc1( txpToken, &dtToken::AddItem, txpTokenItem ) ); titem.AddPostCommand( new_xpObjClear(txpParseTree) ); titem.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenItem ) ); titem.AddPostCommand( new_xpFunc0( this, &pxpByteCode::ClearTokenItemTree ) ); ffirst.AddCommand( new_xpFunc1( Decompiler, &pkgDecompiler::SetFunctionIdFirst, txpNodeData(txpParseTree) ) ); fextended.AddCommand( new_xpFunc1( Decompiler, &pkgDecompiler::SetFunctionIdExtended, txpNodeData(txpParseTree) ) ); // construct tree starting from leaves // ie: node on right side *cannot* appear anywhere below on left side // token gtoken.AddChild( tcode, pl::one ); gtoken.AddChild( tname, pl::one ); gtoken.AddChild( tdesc, pl::one ); titem.AddChild( itype, pl::one ); titem.AddChild( iname, pl::one ); tdata.AddChild( titem, pl::minone ); tdata.AddChild( ttext, pl::maxone ); gtoken.AddChild( tdata, pl::maxone ); // if cleft.AddChild( ctstream, pl::maxone ); cleft.AddChild( cnum, pl::maxone ); cright.AddChild( ctstream, pl::maxone ); cright.AddChild( cnum, pl::maxone ); ceq.AddChild( cleft, pl::one ); ceq.AddChild( cright, pl::one ); cif.AddChild( ceq, pl::one ); // then cthen.AddChild( gtoken, pl::any ); // group bgroup.AddChild( gname, pl::one ); bgroup.AddChild( gmemo, pl::any ); gcond.AddChild( cif, pl::one ); gcond.AddChild( cthen, pl::one ); bgroup.AddChild( gcond, pl::maxone ); bgroup.AddChild( gtoken, pl::any ); // native functions nfunc.AddChild( fextended, pl::one ); nfunc.AddChild( ffirst, pl::one ); // bytecode bytecode.AddChild( bgroup, pl::minone ); bytecode.AddChild( nfunc, pl::maxone ); ParseTree = new unXmlParseTree( bytecode ); }
int main ( int, char ** ) try { // Prepare the interpreter.a const py::Library library; // Build input stream class for 'wsgi.input' object. py::TypeBuilder itype("istream"); itype.init(py::ctor<&exports::init>()); itype.add(py::Method("read", py::vararg<&exports::read>())); itype.add(py::Method("readline", py::noargs<&exports::readline>())); itype.add(py::Method("readlines", py::vararg<&exports::readlines>())); itype.iterable(py::noargs<&exports::iter>(), py::noargs<&exports::next>()); itype.finish(); // Have 'wsgi.input' object read from standard input stream. py::Object istream = itype(); py::TypeBuilder::set_baton (istream, static_cast<std::istream*>(&std::cin)); // Build output stream class for 'wsgi.errors' object. py::TypeBuilder otype("ostream"); otype.init(py::ctor<&exports::init>()); otype.add(py::Method("flush", py::noargs<&exports::flush>())); otype.add(py::Method("write", py::vararg<&exports::write>())); otype.add(py::Method("writelines", py::vararg<&exports::writelines>())); otype.finish(); // Have 'wsgi.errors' object write to standard output stream. py::Object ostream = otype(); py::TypeBuilder::set_baton (ostream, static_cast<std::ostream*>(&std::cout)); // WSGI bootstrap code. wsgi::Runner execute("wsgi-bootstrap.py"); // WSGI application handler. wsgi::Application application("sample", "wsgi-application.py"); // Prepare application execution context. py::Map environment; // Required CGI-style variables. environment.put("REQUEST_METHOD", "GET"); // "GET", "POST", ... #if 0 environment.put("SCRIPT_NAME", ""); // Path to application script. environment.put("PATH_INFO", ""); // URL delegated to application. environment.put("QUERY_STRING", ""); // URL query string. environment.put("SERVER_NAME", ""); // environment.put("SERVER_PORT", ""); // environment.put("SERVER_PROTOCOL", ""); // "HTTP/1.x" // Optional CGI-style variables. environment.put("CONTENT_TYPE", ""); environment.put("CONTENT_LENGTH", ""); #endif #if 0 // HTTP headers. environment.put("HTTP_HOST", ""); //environment.put(...); #endif // WSGI variables. py::Tuple version(2); version[0] = py::Int(1); version[1] = py::Int(0); environment.put("wsgi.version", version); environment.put("wsgi.url_scheme", "http"); environment.put("wsgi.input", istream); environment.put("wsgi.errors", ostream); environment.put("wsgi.multithread", py::False()); environment.put("wsgi.multiprocess", py::False()); environment.put("wsgi.run_once", py::True()); // Execute application and print HTTP response to "cout". wsgi::http_response(execute(application, environment), wsgi::ostream_handler(std::cout)); } catch ( const py::SystemError& error ) { std::cerr << "Error: '" << error.message() << "'." << std::endl; return (EXIT_FAILURE); } catch ( const py::Error& ) { std::cerr << "Error: 'some python error'." << std::endl; return (EXIT_FAILURE); } catch ( const std::exception& error ) { std::cerr << "Error: '" << error.what() << "'." << std::endl; return (EXIT_FAILURE); }