/* 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
}
