/* lpty_read * * read data from the master side of a pty. * * Arguments: * L Lua State * * Lua Stack: * 1 lpty userdata * 2 (optional) timeout in seconds * * Lua Returns: * +1 the data read from the master side of the pty, or nil if the read timed * out * * Note: * you also read back the stuff written to the pty with lpty_write() below! */ static int lpty_read(lua_State *L) { lPty *pty = lpty_checkLPty(L, 1); double timeo = (double)luaL_optnumber(L, 2, -1); char buf[READER_BUFSIZ]; // should probably be more flexible int readn = -1; int ok = 1; if (timeo >= 0) ok = _lpty_waitfordata(pty, timeo, 0); if (ok > 0) readn = read(pty->m_fd, buf, READER_BUFSIZ); if (readn >= 0) { buf[readn] = 0; lua_pushstring(L, buf); /* we don't consider EINTR and ECHILD errors */ } else if (errno && (errno != EINTR) && (errno != ECHILD)) return _lpty_error(L, pty->flags.throwerrors, "lpty read failed: (%d) %s", errno, strerror(errno)); else lua_pushnil(L); return 1; }
int MatrixBinder::create(lua_State* L) { StackChecker checker(L, "MatrixBinder::create", 1); Binder binder(L); lua_Number m11 = luaL_optnumber(L, 1, 1); lua_Number m12 = luaL_optnumber(L, 2, 0); lua_Number m21 = luaL_optnumber(L, 3, 0); lua_Number m22 = luaL_optnumber(L, 4, 1); lua_Number tx = luaL_optnumber(L, 5, 0); lua_Number ty = luaL_optnumber(L, 6, 0); binder.pushInstance("Matrix", new Matrix2D(m11, m12, m21, m22, tx, ty)); return 1; }
static int io_date (lua_State *L) { #if 0 const char *s = luaL_optstring(L, 1, "%c"); time_t t = (time_t)(luaL_optnumber(L, 2, -1)); struct tm *stm; if (t == (time_t)(-1)) /* no time given? */ t = time(NULL); /* use current time */ if (*s == '!') { /* UTC? */ stm = gmtime(&t); s++; /* skip `!' */ } else stm = localtime(&t); if (stm == NULL) /* invalid date? */ lua_pushnil(L); else if (strcmp(s, "*t") == 0) { lua_newtable(L); setfield(L, "sec", stm->tm_sec); setfield(L, "min", stm->tm_min); setfield(L, "hour", stm->tm_hour); setfield(L, "day", stm->tm_mday); setfield(L, "month", stm->tm_mon+1); setfield(L, "year", stm->tm_year+1900); setfield(L, "wday", stm->tm_wday+1); setfield(L, "yday", stm->tm_yday+1); setboolfield(L, "isdst", stm->tm_isdst); } else { char b[256]; if (strftime(b, sizeof(b), s, stm)) lua_pushstring(L, b); else return luaL_error(L, "`date' format too long"); } #endif lua_pushnil(L); return 1; }
static int cdf_qf (lua_State *L) { /* stack should contain p, dfn, dfd and opt. phonc */ lua_Number p = luaL_checknumber(L, 1); lua_Number dfn = luaL_checknumber(L, 2); lua_Number dfd = luaL_checknumber(L, 3); lua_Number phonc = luaL_optnumber(L, 4, 0); lua_Number f; check_f(L, 2, p, dfn, dfd); if (p==0 || p==1) f = (p==0) ? 0 : HUGE_VAL; else { lua_Number q = 1-p; lua_Number bound; int which = 2; int status; if (phonc == 0) /* central? */ cdff(&which, &p, &q, &f, &dfn, &dfd, &status, &bound); else /* non-central */ cdffnc(&which, &p, &q, &f, &dfn, &dfd, &phonc, &status, &bound); check_status(status, bound); } lua_pushnumber(L, f); return 1; }
/*-------------------------------------------------------------------------*\ * Receives data and sender from a UDP socket \*-------------------------------------------------------------------------*/ static int meth_receivefrom(lua_State *L) { p_udp udp = (p_udp) auxiliar_checkclass(L, "udp{unconnected}", 1); struct sockaddr_in addr; socklen_t addr_len = sizeof(addr); char buffer[UDP_DATAGRAMSIZE]; size_t got, count = (size_t) luaL_optnumber(L, 2, sizeof(buffer)); int err; p_timeout tm = &udp->tm; timeout_markstart(tm); count = MIN(count, sizeof(buffer)); err = socket_recvfrom(&udp->sock, buffer, count, &got, (SA *) &addr, &addr_len, tm); if (err == IO_DONE) { lua_pushlstring(L, buffer, got); lua_pushstring(L, inet_ntoa(addr.sin_addr)); lua_pushnumber(L, ntohs(addr.sin_port)); return 3; } else { lua_pushnil(L); lua_pushstring(L, udp_strerror(err)); return 2; } }
static int db_open(lua_State *T) { const char *filename = luaL_checkstring(T, 1); #if SQLITE_VERSION_NUMBER >= 3005000 int flags = luaL_optnumber(T, 2, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); #endif struct db *db; db = lem_xmalloc(sizeof(struct db)); db->T = T; db->handle = NULL; db->refs = 1; db->req.open.filename = filename; #if SQLITE_VERSION_NUMBER >= 3005000 db->req.open.flags = flags; #endif lem_async_do(&db->a, db_open_work, db_open_reap); lua_settop(T, 1); lua_pushvalue(T, lua_upvalueindex(1)); return lua_yield(T, 2); }
int w_File_setBuffer(lua_State *L) { File *file = luax_checkfile(L, 1); const char *str = luaL_checkstring(L, 2); int64 size = (int64) luaL_optnumber(L, 3, 0.0); File::BufferMode bufmode; if (!File::getConstant(str, bufmode)) return luaL_error(L, "Incorrect file buffer mode: %s", str); bool success = false; try { success = file->setBuffer(bufmode, size); } catch (love::Exception &e) { return luax_ioError(L, "%s", e.what()); } luax_pushboolean(L, success); return 1; }
static void readVertex(lua_State* state, graphics_Vertex* out, bool *hasVertexColor) { if(!lua_istable(state, -1) || lua_objlen(state, -1) < 4) { lua_pushstring(state, "Table entry is not a vertex"); lua_error(state); // does not return return; // hint the compiler } _Static_assert(sizeof(graphics_Vertex) == 8*sizeof(float), ""); float *t = (float*)out; for(int i = 0; i < 4; ++i) { lua_rawgeti(state, -1, i+1); t[i] = l_tools_toNumberOrError(state, -1); lua_pop(state, 1); } for(int i = 4; i < 8; ++i) { lua_rawgeti(state, -1, i+1); t[i] = luaL_optnumber(state, -1, 255.0f) / 255.0f; *hasVertexColor = (*hasVertexColor) || t[i] != 1.0f; lua_pop(state, 1); } }
/*-------------------------------------------------------------------------*\ * Waits for a set of sockets until a condition is met or timeout. \*-------------------------------------------------------------------------*/ static int global_select(lua_State *L) { int rtab, wtab, itab, ret, ndirty; t_socket max_fd; fd_set rset, wset; t_timeout tm; double t = luaL_optnumber(L, 3, -1); FD_ZERO(&rset); FD_ZERO(&wset); lua_settop(L, 3); lua_newtable(L); itab = lua_gettop(L); lua_newtable(L); rtab = lua_gettop(L); lua_newtable(L); wtab = lua_gettop(L); max_fd = collect_fd(L, 1, SOCKET_INVALID, itab, &rset); ndirty = check_dirty(L, 1, rtab, &rset); t = ndirty > 0? 0.0: t; timeout_init(&tm, t, -1); timeout_markstart(&tm); max_fd = collect_fd(L, 2, max_fd, itab, &wset); ret = socket_select(max_fd+1, &rset, &wset, NULL, &tm); if (ret > 0 || ndirty > 0) { return_fd(L, &rset, max_fd+1, itab, rtab, ndirty); return_fd(L, &wset, max_fd+1, itab, wtab, 0); make_assoc(L, rtab); make_assoc(L, wtab); return 2; } else if (ret == 0) { lua_pushstring(L, "timeout"); return 3; #ifndef WIN32 } else if (ret < 0 && errno == EINTR) { lua_pushstring(L, "signal"); return 3; #endif } else { lua_pushstring(L, "error"); return 3; } }
int l_physics_newCircleBody(lua_State* state) { l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space"); l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1); const char* type = luaL_optstring(state, 2, "dynamic"); float outer_radius = luaL_optnumber(state, 3, 1.0f); cpVect offset = cpvzero; offset.x = luaL_optnumber(state, 4, 0.0f); offset.y = luaL_optnumber(state, 5, 0.0f); float mass = luaL_optnumber(state, 6, 1.0f); float moment = luaL_optnumber(state, 7, 0.0f); float inner_radius = luaL_optnumber(state, 8, 0.0f); moduleData.body = (l_physics_Body*)lua_newuserdata(state, sizeof(l_physics_Body)); moduleData.body->physics = malloc(sizeof(physics_PhysicsData)); moduleData.body->physics = physics->physics; cpFloat _moment = moment; if (_moment == 0) _moment = cpMomentForCircle(mass, inner_radius, outer_radius, offset); if (strcmp(type, "dynamic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewDynamic()); else if (strcmp(type, "kinematic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewKinematic()); else if (strcmp(type, "static") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewStatic()); else { moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNew(mass, _moment)); /* const char* err = util_concatenate("Undefined type: ", type); l_tools_trowError(state, err); return -1; */ } lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.bodyMT); lua_setmetatable(state, -2); return 1; }
/* lsocket_sock_recv * * reads data from a socket * * Arguments: * L Lua State * * Lua Stack: * 1 the lSocket userdata * 2 (optional) the length of the buffer to use for reading, defaults * to some internal value * * Lua Returns: * +1 a string containing the data read * or +1 false if nonblocking socket returned EAGAIN (no data available) * or +1 nil if the remote end has closed the socket * or +1 nil, +2 error message on error */ static int lsocket_sock_recv(lua_State *L) { lSocket *sock = lsocket_checklSocket(L, 1); uint32_t howmuch = luaL_optnumber(L, 2, READER_BUFSIZ); if (lua_tonumber(L, 2) > UINT_MAX) return luaL_error(L, "bad argument #1 to 'recv' (invalid number)"); char *buf = malloc(howmuch); int nrd = recv(sock->sockfd, buf, howmuch, 0); if (nrd < 0) { free(buf); if (errno == EAGAIN || errno == EWOULDBLOCK) lua_pushboolean(L, 0); else return lsocket_error(L, strerror(errno)); } else if (nrd == 0) lua_pushnil(L); else { lua_pushlstring(L, buf, nrd); free(buf); } return 1; }
static int nn_(SpatialConvolutionMM_accGradParameters)(lua_State *L) { THTensor *input = luaT_checkudata(L, 2, torch_Tensor); THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); real scale = luaL_optnumber(L, 4, 1); int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); THTensor *finput = luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); THTensor *gradWeight = luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); THTensor *gradBias = luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); THArgCheck( nOutputPlane == gradOutput->size[input->nDimension == 4 ? 1 : 0], 1, "Number of output features is not equal to nOutputPlane" ); if(input->nDimension == 3) { nn_(SpatialConvolutionMM_accGradParameters_frame)(gradOutput, gradWeight, gradBias, finput, scale); } else { long T = input->size[0]; long t; for(t = 0; t < T; t++) { THTensor *gradOutput_t = THTensor_(newSelect)(gradOutput, 0, t); THTensor *finput_t = THTensor_(newSelect)(finput, 0, t); nn_(SpatialConvolutionMM_accGradParameters_frame)(gradOutput_t, gradWeight, gradBias, finput_t, scale); THTensor_(free)(gradOutput_t); THTensor_(free)(finput_t); } } return 0; }
static int l_graphics_print(lua_State* state) { if(!moduleData.currentFont) { l_graphics_loadDefaultFont(); } char const* text = lua_tostring(state, 1); if(!text) { lua_pushstring(state, "need string"); return lua_error(state); } int x = l_tools_toNumberOrError(state, 2); int y = l_tools_toNumberOrError(state, 3); float r = luaL_optnumber(state, 4, 0); float sx = luaL_optnumber(state, 5, 1.0f); float sy = luaL_optnumber(state, 6, sx); float ox = luaL_optnumber(state, 7, 0); float oy = luaL_optnumber(state, 8, 0); float kx = luaL_optnumber(state, 9, 0); float ky = luaL_optnumber(state, 10, 0); graphics_Font_render(moduleData.currentFont, text, x, y, r, sx, sy, ox, oy, kx, ky); return 0; }
static int math_atan(lua_State *L) { lua_Number y = luaL_checknumber(L, 1); lua_Number x = luaL_optnumber(L, 2, 1); lua_pushnumber(L, l_mathop(atan2)(y, x)); return 1; }
/** * Move internal result pointer */ static int Lmysql_data_seek (lua_State *L) { lua_Number offset = luaL_optnumber(L, 2, 0); mysql_data_seek(Mget_res(L)->res, offset); return 0; }
int luatpt_set_property(lua_State* l) { char *prop, *name; int i, x, y, w, h, t, format, nx, ny, partsel = 0, acount; float f; size_t offset; acount = lua_gettop(l); prop = luaL_optstring(l, 1, ""); if(lua_isnumber(l, 3)) i = luaL_optint(l, 3, -1); else i = -1; if(lua_isnumber(l, 4)) y = luaL_optint(l, 4, -1); else y = -1; if(lua_isnumber(l, 5)) w = luaL_optint(l, 5, -1); else w = -1; if(lua_isnumber(l, 6)) h = luaL_optint(l, 6, -1); else h = -1; if (strcmp(prop,"type")==0){ offset = offsetof(particle, type); format = 3; } else if (strcmp(prop,"life")==0){ offset = offsetof(particle, life); format = 1; } else if (strcmp(prop,"ctype")==0){ offset = offsetof(particle, ctype); format = 3; } else if (strcmp(prop,"temp")==0){ offset = offsetof(particle, temp); format = 2; } else if (strcmp(prop,"tmp")==0){ offset = offsetof(particle, tmp); format = 1; } else if (strcmp(prop,"vy")==0){ offset = offsetof(particle, vy); format = 2; } else if (strcmp(prop,"vx")==0){ offset = offsetof(particle, vx); format = 2; } else if (strcmp(prop,"x")==0){ offset = offsetof(particle, x); format = 2; } else if (strcmp(prop,"y")==0){ offset = offsetof(particle, y); format = 2; } else { lua_pushstring(l, "invalid property"); lua_error(l); } if(acount>2){ if(!lua_isnumber(l, acount) && lua_isstring(l, acount)){ name = luaL_optstring(l, acount, "none"); if (name[0]!=0) console_parse_type(name, &partsel, console_error); } } if(lua_isnumber(l, 2)){ if(format==2){ f = luaL_optnumber(l, 2, 0); } else { t = luaL_optint(l, 2, 0); } if(t >= PT_NUM && format == 3) return -1; } else { name = luaL_optstring(l, 2, "dust"); if (name[0]!=0) console_parse_type(name, &t, console_error); } if(i == -1 || (w != -1 && h != -1)){ // Got a region if(i == -1){ i = 0; y = 0; w = XRES; h = YRES; } x = i; for (nx = x; nx<x+w; nx++) for (ny = y; ny<y+h; ny++){ i = pmap[ny][nx]>>8; if (i < 0 || i >= NPART || (partsel && partsel != parts[i].type)) continue; if(format==2){ *((float*)(((void*)&parts[i])+offset)) = f; } else { *((int*)(((void*)&parts[i])+offset)) = t; } } } else { // Got coords or particle index if(i != -1 && y != -1){
static int nnconv1d_(HorizontalConvolution_accGradParameters)(lua_State *L) { THTensor *input = luaT_checkudata(L, 2, torch_Tensor); THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); real scale = luaL_optnumber(L, 4, 1); int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); int kL = luaT_getfieldcheckint(L, 1, "kL"); THTensor *ones = luaT_getfieldcheckudata(L, 1, "ones", torch_Tensor); THTensor *gradWeight = luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); THTensor *gradBias = luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); THArgCheck(nOutputPlane == gradOutput->size[input->nDimension == 4 ? 1 : 0], 1, "Number of output features is not equal to nOutputPlane" ); // change to batch mode int batch = 1; if (input->nDimension == 3) { batch = 0; THTensor_(resize4d)(input, 1, input->size[0], input->size[1], input->size[2]); THTensor_(resize4d)(gradOutput, 1, gradOutput->size[0], gradOutput->size[1], gradOutput->size[2]); } long batchSize = input->size[0]; long inputHeight = input->size[2]; long inputWidth = input->size[3]; long outputHeight = inputHeight; long outputWidth = inputWidth - kL + 1; if (ones->nDimension != 1 || ones->size[0] < outputHeight*outputWidth) { THTensor_(resize1d)(ones, outputHeight*outputWidth); THTensor_(fill)(ones, 1); } int elt; for (elt = 0; elt < batchSize; elt++) { // select each batch in 2D THTensor *input_t = THTensor_(newSelect)(input, 0, elt); THTensor *gradOutput_t = THTensor_(newSelect)(gradOutput, 0, elt); THTensor *gradOutput2d = THTensor_(newWithStorage2d)(gradOutput->storage, gradOutput->storageOffset, nOutputPlane, -1, outputWidth*outputHeight, -1); // dot products int i, j, k; for (i = 0; i < nInputPlane; i++) { for (k = 0; k < kL; k++) { for (j = 0; j < outputHeight; j++) { *(gradWeight->storage->data + gradWeight->storageOffset + i*gradWeight->stride[0] + k) += scale*THBlas_(dot) (outputWidth, gradOutput_t->storage->data + gradOutput_t->storageOffset + i*gradOutput_t->stride[0] + j*gradOutput_t->stride[1], gradOutput_t->stride[2], input_t->storage->data + input_t->storageOffset + i*input_t->stride[0] + j*input_t->stride[1] + k, input_t->stride[2]); } } } // fill biases THTensor_(addmv)(gradBias, 1, gradBias, scale, gradOutput2d, ones); THTensor_(free)(gradOutput2d); THTensor_(free)(input_t); THTensor_(free)(gradOutput_t); } // revert to single batch if (batch == 0) { THTensor_(resize3d)(input, nInputPlane, inputHeight, inputWidth); THTensor_(resize3d)(gradOutput, nOutputPlane, outputHeight, outputWidth); } return 0; }
static int os_difftime (lua_State *L) { lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)), (time_t)(luaL_optnumber(L, 2, 0)))); return 1; }
JNIEXPORT jdouble JNICALL Java_m_lua_Lua_LoptNumber (JNIEnv* env, jobject thiz, jlong nativeObj, jint numArg, jdouble def) { pushJNIEnv(env, nativeObj); return (jdouble) luaL_optnumber((lua_State*) nativeObj, numArg, (lua_Number) def); }
lua_Number LuaState::OptNumber(int nArg, lua_Number def) { return luaL_optnumber(m_state, nArg, def); }
static int noit_lua_set_metric_f(lua_State *L, mtev_boolean allow_whence, void(*set)(noit_check_t *, const char *, metric_type_t, const void *, const struct timeval *)) { noit_check_t *check; const char *metric_name; metric_type_t metric_type; struct timeval whence = { 0UL, 0UL }; double __n = 0.0; int32_t __i = 0; uint32_t __I = 0; int64_t __l = 0; uint64_t __L = 0; if(lua_gettop(L) < 2 || lua_gettop(L) > 4) luaL_error(L, "need 2-4 arguments: <metric_name> <value> [whence_s] [whence_us]"); check = lua_touserdata(L, lua_upvalueindex(1)); if(!lua_isstring(L, 1)) luaL_error(L, "argument #1 must be a string"); metric_name = lua_tostring(L, 1); metric_type = lua_tointeger(L, lua_upvalueindex(2)); if(allow_whence == mtev_true && lua_gettop(L) >= 3) { whence.tv_sec = lua_tointeger(L, 3); if(lua_gettop(L) == 4) { whence.tv_usec = lua_tointeger(L, 4); } if(whence.tv_sec < 0) whence.tv_sec = 0; if(whence.tv_usec < 0 || whence.tv_usec >= 1000000) whence.tv_usec = 0; } else { gettimeofday(&whence, NULL); } if(lua_isnil(L, 2)) { set(check, metric_name, metric_type, NULL, &whence); lua_pushboolean(L, 1); return 1; } switch(metric_type) { case METRIC_INT32: case METRIC_UINT32: case METRIC_INT64: case METRIC_UINT64: case METRIC_DOUBLE: if(!lua_isnumber(L, 2)) { set(check, metric_name, metric_type, NULL, &whence); lua_pushboolean(L, 0); return 1; } default: break; } switch(metric_type) { case METRIC_GUESS: case METRIC_STRING: set(check, metric_name, metric_type, (void *)lua_tostring(L, 2), &whence); break; case METRIC_INT32: __i = strtol(lua_tostring(L, 2), NULL, 10); set(check, metric_name, metric_type, &__i, &whence); break; case METRIC_UINT32: __I = strtoul(lua_tostring(L, 2), NULL, 10); set(check, metric_name, metric_type, &__I, &whence); break; case METRIC_INT64: __l = strtoll(lua_tostring(L, 2), NULL, 10); set(check, metric_name, metric_type, &__l, &whence); break; case METRIC_UINT64: __L = strtoull(lua_tostring(L, 2), NULL, 10); set(check, metric_name, metric_type, &__L, &whence); break; case METRIC_DOUBLE: __n = luaL_optnumber(L, 2, 0); set(check, metric_name, metric_type, &__n, &whence); break; case METRIC_ABSENT: luaL_error(L, "illegal metric type: %d", metric_type); } lua_pushboolean(L, 1); return 1; }
template<> float Eluna::CHECKVAL<float>(lua_State* L, int narg, float def) { if (lua_isnoneornil(L, narg) || !lua_isnumber(L, narg)) return def; return luaL_optnumber(L, narg, def); }
static int ngx_http_lua_socket_udp_receive(lua_State *L) { ngx_http_request_t *r; ngx_http_lua_socket_udp_upstream_t *u; ngx_int_t rc; ngx_http_lua_ctx_t *ctx; ngx_http_lua_co_ctx_t *coctx; size_t size; int nargs; ngx_http_lua_loc_conf_t *llcf; nargs = lua_gettop(L); if (nargs != 1 && nargs != 2) { return luaL_error(L, "expecting 1 or 2 arguments " "(including the object), but got %d", nargs); } lua_pushlightuserdata(L, &ngx_http_lua_request_key); lua_rawget(L, LUA_GLOBALSINDEX); r = lua_touserdata(L, -1); lua_pop(L, 1); ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "lua udp socket calling receive() method"); luaL_checktype(L, 1, LUA_TTABLE); lua_rawgeti(L, 1, SOCKET_CTX_INDEX); u = lua_touserdata(L, -1); lua_pop(L, 1); if (u == NULL || u->udp_connection.connection == NULL) { llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module); if (llcf->log_socket_errors) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "attempt to receive data on a closed socket: u:%p, " "c:%p", u, u ? u->udp_connection.connection : NULL); } lua_pushnil(L); lua_pushliteral(L, "closed"); return 2; } if (u->ft_type) { u->ft_type = 0; } #if 1 if (u->waiting) { lua_pushnil(L); lua_pushliteral(L, "socket busy"); return 2; } #endif ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "lua udp socket read timeout: %M", u->read_timeout); size = (size_t) luaL_optnumber(L, 2, UDP_MAX_DATAGRAM_SIZE); size = ngx_min(size, UDP_MAX_DATAGRAM_SIZE); u->recv_buf_size = size; ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "lua udp socket receive buffer size: %uz", u->recv_buf_size); rc = ngx_http_lua_socket_udp_read(r, u); if (rc == NGX_ERROR) { dd("read failed: %d", (int) u->ft_type); rc = ngx_http_lua_socket_udp_receive_retval_handler(r, u, L); dd("udp receive retval returned: %d", (int) rc); return rc; } if (rc == NGX_OK) { ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "lua udp socket receive done in a single run"); return ngx_http_lua_socket_udp_receive_retval_handler(r, u, L); } /* n == NGX_AGAIN */ u->read_event_handler = ngx_http_lua_socket_udp_read_handler; ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ctx == NULL) { return luaL_error(L, "no request ctx found"); } ctx->cur_co_ctx->cleanup = ngx_http_lua_udp_socket_cleanup; if (ctx->entered_content_phase) { r->write_event_handler = ngx_http_lua_content_wev_handler; } else { r->write_event_handler = ngx_http_core_run_phases; } u->co_ctx = ctx->cur_co_ctx; u->waiting = 1; u->prepare_retvals = ngx_http_lua_socket_udp_receive_retval_handler; coctx = ctx->cur_co_ctx; coctx->data = u; return lua_yield(L, 0); }
template<> double Eluna::CHECKVAL<double>(lua_State* L, int narg, double def) { if (lua_isnoneornil(L, narg) || !lua_isnumber(L, narg)) return def; return luaL_optnumber(L, narg, def); }
lua_Number lu_table_optnumber(lua_State *L, int narg, const char *fname, lua_Number d) { lua_getfield(L, narg, fname); lua_Number r = luaL_optnumber(L,-1,d); lua_pop(L,1); return r; }
static int CBaseCombatWeapon_WeaponSound (lua_State *L) { luaL_checkweapon(L, 1)->WeaponSound((WeaponSound_t)luaL_checkint(L, 2), luaL_optnumber(L, 2, 0.0f)); return 0; }
double LuaState::CheckNumber(int index, double defValue) const { return luaL_optnumber(m_state, index, defValue); }
static int nn_(SpatialFullConvolution_accGradParameters)(lua_State *L) { // Inputs THTensor *input = (THTensor *)luaT_checkudata(L, 2, torch_Tensor); THTensor *gradOutput = (THTensor *)luaT_checkudata(L, 3, torch_Tensor); // Params int dW = luaT_getfieldcheckint(L, 1, "dW"); int dH = luaT_getfieldcheckint(L, 1, "dH"); int kW = luaT_getfieldcheckint(L, 1, "kW"); int kH = luaT_getfieldcheckint(L, 1, "kH"); int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); int padW = luaT_getfieldcheckint(L, 1, "padW"); int padH = luaT_getfieldcheckint(L, 1, "padH"); int adjW = luaT_getfieldcheckint(L, 1, "adjW"); int adjH = luaT_getfieldcheckint(L, 1, "adjH"); float scale = luaL_optnumber(L, 4, 1); THTensor *gradWeight = (THTensor *)luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); THTensor *gradBias = (THTensor *)luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); THTensor *columns = (THTensor*)luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); THTensor *ones = (THTensor*)luaT_getfieldcheckudata(L, 1, "fgradInput", torch_Tensor); luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); int batch = 1; if (input->nDimension == 3) { // Force batch batch = 0; THTensor_(resize4d)(input, 1, input->size[0], input->size[1], input->size[2]); THTensor_(resize4d)(gradOutput, 1, gradOutput->size[0], gradOutput->size[1], gradOutput->size[2]); } long inputWidth = input->size[3]; long inputHeight = input->size[2]; long outputWidth = (inputWidth - 1) * dW - 2*padW + kW + adjW; long outputHeight = (inputHeight - 1) * dH - 2*padH + kH + adjH; // Batch size + input planes long batchSize = input->size[0]; // Define a buffer of ones, for bias accumulation if (ones->nDimension != 2 || ones->size[0]*ones->size[1] < outputHeight*outputWidth) { // Resize plane and fill with ones... THTensor_(resize2d)(ones, outputHeight, outputWidth); THTensor_(fill)(ones, 1); } // Resize temporary columns THTensor_(resize2d)(columns, nOutputPlane*kW*kH, inputHeight*inputWidth); // Helpers THTensor *input_n = THTensor_(new)(); THTensor *gradOutput_n = THTensor_(new)(); int elt; // For each elt in batch, do: for (elt = 0; elt < batchSize; elt ++) { // Matrix mulitply per output: THTensor_(select)(input_n, input, 0, elt); THTensor_(select)(gradOutput_n, gradOutput, 0, elt); // Extract columns: nn_(im2col)( THTensor_(data)(gradOutput_n), nOutputPlane, outputHeight, outputWidth, kH, kW, padH, padW, dH, dW, THTensor_(data)(columns) ); // M,N,K are dims of matrix A and B // (see http://docs.nvidia.com/cuda/cublas/#cublas-lt-t-gt-gemm) long n = columns->size[0]; // nOutputPlane * kh * kw long m = input_n->size[0]; // nInputPlane long k = columns->size[1]; // inputHeight * inputWidth // Do GEMM (note: this is a bit confusing because gemm assumes column-major matrices) THBlas_(gemm)( 't', 'n', n, m, k, scale, THTensor_(data)(columns), k, THTensor_(data)(input_n), k, 1, THTensor_(data)(gradWeight), n ); // Do Bias: // M,N,K are dims of matrix A and B // (see http://docs.nvidia.com/cuda/cublas/#cublas-lt-t-gt-gemm) long m_ = nOutputPlane; long k_ = outputHeight * outputWidth; // Do GEMV (note: this is a bit confusing because gemv assumes column-major matrices) THBlas_(gemv)( 't', k_, m_, scale, THTensor_(data)(gradOutput_n), k_, THTensor_(data)(ones), 1, 1, THTensor_(data)(gradBias), 1 ); } // Free THTensor_(free)(input_n); THTensor_(free)(gradOutput_n); // Resize if (batch == 0) { THTensor_(resize3d)(gradOutput, nOutputPlane, outputHeight, outputWidth); THTensor_(resize3d)(input, nInputPlane, inputHeight, inputWidth); } // Return nothing return 0; }
static int nn_(SpatialConvolution_accGradParameters)(lua_State *L) { THTensor *input = luaT_checkudata(L, 2, torch_Tensor); THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); real scale = luaL_optnumber(L, 4, 1); int dW = luaT_getfieldcheckint(L, 1, "dW"); int dH = luaT_getfieldcheckint(L, 1, "dH"); int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); THTensor *gradWeight = luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); THTensor *gradBias = luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); int dimw = 2; int dimh = 1; real *gradBias_data; real *gradOutput_data; long noutSlice; THArgCheck( nOutputPlane == gradOutput->size[input->nDimension == 4 ? 1 : 0], 1, "Number of output features is not equal to nOutputPlane" ); if (input->nDimension == 4) { dimw++; dimh++; } /* gradient to bias */ gradBias_data = THTensor_(data)(gradBias); gradOutput_data = THTensor_(data)(gradOutput); noutSlice = gradOutput->size[dimh]*gradOutput->size[dimw]; /*THTensor* gradOutSlice = THTensor_(new)();*/ if (input->nDimension == 3) { long k; #pragma omp parallel for private(k) for(k = 0; k < nOutputPlane; k++) { /*THTensor_(select)(gradOutSlice, gradOutput, 0, k);*/ real *ptr_gradOutput = gradOutput_data + k*noutSlice; long l; for(l = 0; l < noutSlice; l++) gradBias_data[k] += scale*ptr_gradOutput[l]; } /* gradient to kernels */ THTensor_(conv2DRevger)(gradWeight, 1.0, scale, input, gradOutput, dH, dW); } else { long k; #pragma omp parallel for private(k) for(k = 0; k < nOutputPlane; k++) { long p; for(p = 0; p < input->size[0]; p++) { /* BIAS */ real *ptr_gradOutput = gradOutput_data + p*nOutputPlane*noutSlice + k*noutSlice; long l; for(l = 0; l < noutSlice; l++) gradBias_data[k] += scale*ptr_gradOutput[l]; } } /* gradient to kernels */ THTensor_(conv2DRevgerm)(gradWeight, 1.0, scale, input, gradOutput, dH, dW); } return 0; }
int SpriteBinder::setColorTransform(lua_State* L) { #if 0 StackChecker checker(L, "setColorTransform", 0); Binder binder(L); Sprite* sprite = static_cast<Sprite*>(binder.getInstance("Sprite", 1)); ColorTransform* colorTransform = static_cast<ColorTransform*>(binder.getInstance("ColorTransform", 2)); lua_getfield(L, 2, "redMultiplier"); lua_Number redMultiplier = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "greenMultiplier"); lua_Number greenMultiplier = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "blueMultiplier"); lua_Number blueMultiplier = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "alphaMultiplier"); lua_Number alphaMultiplier = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "redOffset"); lua_Number redOffset = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "greenOffset"); lua_Number greenOffset = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "blueOffset"); lua_Number blueOffset = luaL_checknumber(L, -1); lua_pop(L, 1); lua_getfield(L, 2, "alphaOffset"); lua_Number alphaOffset = luaL_checknumber(L, -1); lua_pop(L, 1); sprite->setColorTransform(ColorTransform(redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier, redOffset, greenOffset, blueOffset, alphaOffset)); return 0; #else StackChecker checker(L, "SpriteBinder::setColorTransform", 0); Binder binder(L); Sprite* sprite = static_cast<Sprite*>(binder.getInstance("Sprite", 1)); lua_Number redMultiplier = luaL_optnumber(L, 2, 1.0); lua_Number greenMultiplier = luaL_optnumber(L, 3, 1.0); lua_Number blueMultiplier = luaL_optnumber(L, 4, 1.0); lua_Number alphaMultiplier = luaL_optnumber(L, 5, 1.0); sprite->setColorTransform(ColorTransform(redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier)); return 0; #endif }