Example #1
0
/*---------------------------------------------------------------------------*/
void LuaUtils_CheckParameter1(lua_State *L, uint16_t count, const char* usage)
{
  int n = lua_gettop(L);
  if (n != count) 
    luaL_error(L, "Got %d arguments expected %d (%s)", n, count, usage);
}
Example #2
0
/*
 * success,err = statement:execute(...)
 */
static int statement_execute(lua_State *L) {
    int n = lua_gettop(L);
    statement_t *statement = (statement_t *)luaL_checkudata(L, 1, DBD_MYSQL_STATEMENT); 
    int num_bind_params = n - 1;
    int expected_params;

    unsigned char *buffer = NULL;
    int offset = 0;
    
    MYSQL_BIND *bind = NULL;
    MYSQL_RES *metadata = NULL;

    char *error_message = NULL;
    char *errstr = NULL;

    int p;

    if (statement->metadata) {
		/*
		 * free existing metadata from any previous executions
			 */
		mysql_free_result(statement->metadata);
		statement->metadata = NULL;
    }

    if (!statement->stmt) {
		lua_pushboolean(L, 0);
		lua_pushstring(L, DBI_ERR_EXECUTE_INVALID);
		return 2;
    }

    expected_params = mysql_stmt_param_count(statement->stmt);

    if (expected_params != num_bind_params) {
		/*
			 * mysql_stmt_bind_param does not handle this condition,
			 * and the client library will segfault if these do no match
			 */ 
		lua_pushboolean(L, 0);
		lua_pushfstring(L, DBI_ERR_PARAM_MISCOUNT, expected_params, num_bind_params); 
		return 2;
    }

    if (num_bind_params > 0) {
        bind = malloc(sizeof(MYSQL_BIND) * num_bind_params);
        if (bind == NULL) {
            luaL_error(L, "Could not alloc bind params\n");
        }

        buffer = (unsigned char *)malloc(num_bind_params * sizeof(double));
        memset(bind, 0, sizeof(MYSQL_BIND) * num_bind_params);
    }

    for (p = 2; p <= n; p++) {
		int type = lua_type(L, p);
		int i = p - 2;

		const char *str = NULL;
		size_t *str_len = NULL;
		double *num = NULL;
		int *boolean = NULL;
		char err[64];

		switch(type) {
			case LUA_TNIL:
				bind[i].buffer_type = MYSQL_TYPE_NULL;
				bind[i].is_null = (my_bool*)1;
				break;

				case LUA_TBOOLEAN:
				boolean = (int *)(buffer + offset);
				offset += sizeof(int);
				*boolean = lua_toboolean(L, p);

				bind[i].buffer_type = MYSQL_TYPE_LONG;
				bind[i].is_null = (my_bool*)0;
				bind[i].buffer = (char *)boolean;
				bind[i].length = 0;
				break;

			case LUA_TNUMBER:
				/*
				 * num needs to be it's own 
				 * memory here
						 */
				num = (double *)(buffer + offset);
				offset += sizeof(double);
				*num = lua_tonumber(L, p);

				bind[i].buffer_type = MYSQL_TYPE_DOUBLE;
				bind[i].is_null = (my_bool*)0;
				bind[i].buffer = (char *)num;
				bind[i].length = 0;
				break;

			case LUA_TSTRING:
				str_len = (size_t *)(buffer + offset);
				offset += sizeof(size_t);
				str = lua_tolstring(L, p, str_len);

				bind[i].buffer_type = MYSQL_TYPE_STRING;
				bind[i].is_null = (my_bool*)0;
				bind[i].buffer = (char *)str;
				bind[i].length = str_len;
				break;

			default:
				snprintf(err, sizeof(err)-1, DBI_ERR_BINDING_TYPE_ERR, lua_typename(L, type));
				errstr = err;
				error_message = DBI_ERR_BINDING_PARAMS;
				goto cleanup;
		}
    }

    if (mysql_stmt_bind_param(statement->stmt, bind)) {
		error_message = DBI_ERR_BINDING_PARAMS;
		goto cleanup;
    }

    if (mysql_stmt_execute(statement->stmt)) {
		error_message = DBI_ERR_BINDING_EXEC;
		goto cleanup;
    }

    metadata = mysql_stmt_result_metadata(statement->stmt);

    if (metadata) {
        mysql_stmt_store_result(statement->stmt);
    }

cleanup:
    if (bind) { 
		free(bind);
    }

    if (buffer) {
        free(buffer);
    }

    if (error_message) {
		lua_pushboolean(L, 0);
		lua_pushfstring(L, error_message, errstr ? errstr : mysql_stmt_error(statement->stmt));
		return 2;
    }

    statement->metadata = metadata;

    lua_pushboolean(L, 1);
    return 1;
}
Example #3
0
static void loaderror(lua_State *L, const char *filename)
{
  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
	     lua_tostring(L, 1), filename, lua_tostring(L, -1));
}
Example #4
0
static int str_format (lua_State *L) {
  int top = lua_gettop(L);
  int arg = 1;
  size_t sfl;
  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
  const char *strfrmt_end = strfrmt+sfl;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  while (strfrmt < strfrmt_end) {
    if (*strfrmt != L_ESC)
      luaL_addchar(&b, *strfrmt++);
    else if (*++strfrmt == L_ESC)
      luaL_addchar(&b, *strfrmt++);  /* %% */
    else { /* format item */
      char form[MAX_FORMAT];  /* to store the format (`%...') */
      char buff[MAX_ITEM];  /* to store the formatted item */
      if (++arg > top)
        luaL_argerror(L, arg, "no value");
      strfrmt = scanformat(L, strfrmt, form);
      switch (*strfrmt++) {
        case 'c': {
          sprintf(buff, form, (int)luaL_checknumber(L, arg));
          break;
        }
        case 'd':  case 'i': {
          addintlen(form);
          sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
          break;
        }
        case 'o':  case 'u':  case 'x':  case 'X': {
          addintlen(form);
          sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
          break;
        }
        case 'e':  case 'E': case 'f':
        case 'g': case 'G': {
          sprintf(buff, form, (double)luaL_checknumber(L, arg));
          break;
        }
        case 'q': {
          addquoted(L, &b, arg);
          continue;  /* skip the 'addsize' at the end */
        }
        case 's': {
          size_t l;
          const char *s = luaL_checklstring(L, arg, &l);
          if (!strchr(form, '.') && l >= 100) {
            /* no precision and string is too long to be formatted;
               keep original string */
            lua_pushvalue(L, arg);
            luaL_addvalue(&b);
            continue;  /* skip the `addsize' at the end */
          }
          else {
            sprintf(buff, form, s);
            break;
          }
        }
        default: {  /* also treat cases `pnLlh' */
          return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
                               LUA_QL("format"), *(strfrmt - 1));
        }
      }
      luaL_addlstring(&b, buff, strlen(buff));
    }
  }
  luaL_pushresult(&b);
  return 1;
}
Example #5
0
int icu_case(lua_State *L) {
  size_t input_l;
  const char* input = luaL_checklstring(L, 1, &input_l);

  const char* locale = luaL_checkstring(L, 2);
  const char* recase = luaL_checkstring(L, 3);

  /* Convert input to ICU-friendly UChars */
  UChar *input_as_uchar;
  int32_t l;
  utf8_to_uchar(input, input_l, input_as_uchar, l);

  /* Now do the conversion */
  UChar *output;
  int32_t l2 = 0;

  UErrorCode err = U_ZERO_ERROR;

  if (strcmp(recase, "title") == 0) {
    l2 = u_strToTitle(NULL, 0, input_as_uchar, l, NULL, locale, &err);
    err = U_ZERO_ERROR;
    output = malloc(l2 * sizeof(UChar));
    u_strToTitle(output, l2, input_as_uchar, l, NULL, locale, &err);
  } else {
    conversion_function_t conversion;
    if (strcmp(recase, "upper") == 0) {
      conversion = u_strToUpper;
    } else if (strcmp(recase, "lower") == 0) {
      conversion = u_strToLower;
    } else {
      free(input_as_uchar);
      return luaL_error(L, "Unknown case conversion type %s", recase);
    }
    l2 = conversion(NULL, 0, input_as_uchar, l, locale, &err);
    err = U_ZERO_ERROR;
    output = malloc(l2 * sizeof(UChar));
    conversion(output, l2, input_as_uchar, l, locale, &err);
  }
  if (!U_SUCCESS(err)) {
    free(input_as_uchar);
    free(output);
    return luaL_error(L, "Error in case conversion %s", u_errorName(err));
  }

  int32_t l3 = 0;
  char possibleOutbuf[4096];
  u_strToUTF8(possibleOutbuf, 4096, &l3, output, l2, &err);
  if (U_SUCCESS(err)) {
    lua_pushstring(L, possibleOutbuf);
    free(input_as_uchar);
    free(output);
    return 1;
  }
  char *utf8output;
  if (err == U_BUFFER_OVERFLOW_ERROR) {
    utf8output = malloc(l3);
    u_strToUTF8(utf8output, l3, NULL, output, l2, &err);
    if (!U_SUCCESS(err)) goto fail;
    utf8output[l3] = '\0';
    lua_pushstring(L, utf8output);
    free(input_as_uchar);
    free(output);
    free(utf8output);
    return 1;
  }
  fail:
    return luaL_error(L, "Error in UTF8 conversion %s", u_errorName(err));
}
Example #6
0
static int check_capture (MatchState *ms, int l) {
  l -= '1';
  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
    return luaL_error(ms->L, "invalid capture index");
  return l;
}
Example #7
0
static const char *match (MatchState *ms, const char *s, const char *p) {
  init: /* using goto's to optimize tail recursion */
  switch (*p) {
    case '(': {  /* start capture */
      if (*(p+1) == ')')  /* position capture? */
        return start_capture(ms, s, p+2, CAP_POSITION);
      else
        return start_capture(ms, s, p+1, CAP_UNFINISHED);
    }
    case ')': {  /* end capture */
      return end_capture(ms, s, p+1);
    }
    case L_ESC: {
      switch (*(p+1)) {
        case 'b': {  /* balanced string? */
          s = matchbalance(ms, s, p+2);
          if (s == NULL) return NULL;
          p+=4; goto init;  /* else return match(ms, s, p+4); */
        }
        case 'f': {  /* frontier? */
          const char *ep; char previous;
          p += 2;
          if (*p != '[')
            luaL_error(ms->L, "missing " LUA_QL("[") " after "
                               LUA_QL("%%f") " in pattern");
          ep = classend(ms, p);  /* points to what is next */
          previous = (s == ms->src_init) ? '\0' : *(s-1);
          if (matchbracketclass(uchar(previous), p, ep-1) ||
             !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
          p=ep; goto init;  /* else return match(ms, s, ep); */
        }
        default: {
          if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
            s = match_capture(ms, s, uchar(*(p+1)));
            if (s == NULL) return NULL;
            p+=2; goto init;  /* else return match(ms, s, p+2) */
          }
          goto dflt;  /* case default */
        }
      }
    }
    case '\0': {  /* end of pattern */
      return s;  /* match succeeded */
    }
    case '$': {
      if (*(p+1) == '\0')  /* is the `$' the last char in pattern? */
        return (s == ms->src_end) ? s : NULL;  /* check end of string */
      else goto dflt;
    }
    default: dflt: {  /* it is a pattern item */
      const char *ep = classend(ms, p);  /* points to what is next */
      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
      switch (*ep) {
        case '?': {  /* optional */
          const char *res;
          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
            return res;
          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
        }
        case '*': {  /* 0 or more repetitions */
          return max_expand(ms, s, p, ep);
        }
        case '+': {  /* 1 or more repetitions */
          return (m ? max_expand(ms, s+1, p, ep) : NULL);
        }
        case '-': {  /* 0 or more repetitions (minimum) */
          return min_expand(ms, s, p, ep);
        }
        default: {
          if (!m) return NULL;
          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
        }
      }
    }
  }
}
static int rjson_parse_message(lua_State *lua)
{
  lua_getfield(lua, LUA_REGISTRYINDEX, LSB_HEKA_THIS_PTR);
  lsb_heka_sandbox *hsb =
    static_cast<lsb_heka_sandbox *>(lua_touserdata(lua, -1));
  lua_pop(lua, 1); // remove this ptr
  if (!hsb) {
    return luaL_error(lua, "parse_message() invalid " LSB_HEKA_THIS_PTR);
  }
  int n = lua_gettop(lua);
  int idx = 1;

  const lsb_heka_message *msg = NULL;
  if (lsb_heka_get_type(hsb) == 'i') {
    luaL_argcheck(lua, n >= 2 && n <= 4, 0, "invalid number of arguments");
    heka_stream_reader *hsr = static_cast<heka_stream_reader *>
        (luaL_checkudata(lua, 1, LSB_HEKA_STREAM_READER));
    msg = &hsr->msg;
    idx = 2;
  } else {
    luaL_argcheck(lua, n >= 1 && n <= 3, 0, "invalid number of arguments");
    const lsb_heka_message *hm = lsb_heka_get_message(hsb);
    if (!hm ||  !hm->raw.s) {
      return luaL_error(lua, "parse_message() no active message");
    }
    msg = hm;
  }

  lsb_const_string json = read_message(lua, idx, msg);
  if (!json.s) return luaL_error(lua, "field not found");

  char *inflated = NULL;
#ifdef HAVE_ZLIB
  // automatically handle gzipped strings (optimization for Mozilla telemetry
  // messages)
  if (json.len > 2) {
    if (json.s[0] == 0x1f && (unsigned char)json.s[1] == 0x8b) {
      size_t mms = (size_t)lua_tointeger(lua, lua_upvalueindex(1));
      inflated = ungzip(json.s, json.len, mms, NULL);
      if (!inflated) return luaL_error(lua, "ungzip failed");
    }
  }
#endif

  rjson *j = static_cast<rjson *>(lua_newuserdata(lua, sizeof*j));
  j->doc = new rj::Document;
  j->val = NULL;
  j->insitu = inflated;
  j->refs =  new std::set<rj::Value *>;
  luaL_getmetatable(lua, mozsvc_rjson);
  lua_setmetatable(lua, -2);

  if (!j->doc || !j->refs) {
    lua_pushstring(lua, "memory allocation failed");
    return lua_error(lua);
  }

  bool err = false;
  if (j->insitu) {
    if (j->doc->ParseInsitu<rj::kParseStopWhenDoneFlag>(j->insitu)
        .HasParseError()) {
      err = true;
      lua_pushfstring(lua, "failed to parse offset:%f %s",
                      (lua_Number)j->doc->GetErrorOffset(),
                      rj::GetParseError_En(j->doc->GetParseError()));
    }
  } else {
    rj::MemoryStream ms(json.s, json.len);
    if (j->doc->ParseStream<0, rj::UTF8<> >(ms).HasParseError()) {
      err = true;
      lua_pushfstring(lua, "failed to parse offset:%f %s",
                      (lua_Number)j->doc->GetErrorOffset(),
                      rj::GetParseError_En(j->doc->GetParseError()));
    }
  }

  if (err) return lua_error(lua);
  j->refs->insert(j->doc);
  return 1;
}
Example #9
0
static size_t dump_writer(void *ud, const char *s, size_t len) {
    lonL_Dumper *D = (lonL_Dumper*)ud;
    if (!lon_addlstring(&D->B, s, len))
        luaL_error(D->L, "out of memory");
    return len;
}
Example #10
0
int luax_assert_function(lua_State *L, int n)
{
	if (!lua_isfunction(L, n))
		return luaL_error(L, "Argument must be of type \"function\".");
	return 0;
}
Example #11
0
static int str_format (lua_State *L) {
  int top = lua_gettop(L);
  int arg = 1;
  size_t sfl;
  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
  const char *strfrmt_end = strfrmt+sfl;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  while (strfrmt < strfrmt_end) {
    if (*strfrmt != L_ESC)
      luaL_addchar(&b, *strfrmt++);
    else if (*++strfrmt == L_ESC)
      luaL_addchar(&b, *strfrmt++);  /* %% */
    else { /* format item */
      char form[MAX_FORMAT];  /* to store the format (`%...') */
      char *buff = luaL_prepbuffsize(&b, MAX_ITEM);  /* to put formatted item */
      int nb = 0;  /* number of bytes in added item */
      if (++arg > top)
        luaL_argerror(L, arg, "no value");
      strfrmt = scanformat(L, strfrmt, form);
      switch (*strfrmt++) {
        case 'c': {
          nb = sprintf(buff, form, luaL_checkint(L, arg));
          break;
        }
        case 'd':  case 'i': {
          lua_Number n = luaL_checknumber(L, arg);
          luaL_argcheck(L, (MIN_INTFRM - 1) < n && n < (MAX_INTFRM + 1), arg,
                        "not a number in proper range");
          addlenmod(form, LUA_INTFRMLEN);
          nb = sprintf(buff, form, (LUA_INTFRM_T)n);
          break;
        }
        case 'o':  case 'u':  case 'x':  case 'X': {
          lua_Number n = luaL_checknumber(L, arg);
          luaL_argcheck(L, 0 <= n && n < (MAX_UINTFRM + 1), arg,
                        "not a non-negative number in proper range");
          addlenmod(form, LUA_INTFRMLEN);
          nb = sprintf(buff, form, (unsigned LUA_INTFRM_T)n);
          break;
        }
        case 'e':  case 'E': case 'f':
#if defined(LUA_USE_AFORMAT)
        case 'a': case 'A':
#endif
        case 'g': case 'G': {
          addlenmod(form, LUA_FLTFRMLEN);
          nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));
          break;
        }
        case 'q': {
          addquoted(L, &b, arg);
          break;
        }
        case 's': {
          size_t l;
          const char *s = luaL_tolstring(L, arg, &l);
          if (!strchr(form, '.') && l >= 100) {
            /* no precision and string is too long to be formatted;
               keep original string */
            luaL_addvalue(&b);
            break;
          }
          else {
            nb = sprintf(buff, form, s);
            lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
            break;
          }
        }
        default: {  /* also treat cases `pnLlh' */
          return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
                               LUA_QL("format"), *(strfrmt - 1));
        }
      }
      luaL_addsize(&b, nb);
    }
  }
  luaL_pushresult(&b);
  return 1;
}
Example #12
0
static int luaB_assert (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_toboolean(L, 1))
    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
  return lua_gettop(L);
}
Example #13
0
LUA_API int luafan_objectbuf_decode(lua_State *L)
{
  size_t len;
  const char *buf = luaL_checklstring(L, 1, &len);
  BYTEARRAY input;
  bytearray_wrap_buffer(&input, (uint8_t *)buf, len); // will not change buf.

  int sym_idx = 0;
  if (lua_istable(L, 2))
  {
    sym_idx = 2;
  }

  uint8_t flag = 0;
  bytearray_read8(&input, &flag);

  switch (flag)
  {
  case 0:
    lua_pushboolean(L, false);
    return 1;
  case 1:
    lua_pushboolean(L, true);
    return 1;
  default:
    break;
  }

  lua_newtable(L);
  int index_map_idx = lua_gettop(L);

  uint32_t index = 2;

  if (!sym_idx)
  {
    lua_newtable(L);
  }
  else
  {
    lua_rawgeti(L, sym_idx, SYM_INDEX_INDEX);
    index = lua_tointeger(L, -1);
    lua_pop(L, 1);

    lua_rawgeti(L, sym_idx, SYM_INDEX_MAP_VK);
  }
  int sym_map_vk_idx = lua_gettop(L);

  int last_top = index + 1;

  if (!sym_idx)
  {
    lua_pushboolean(L, false);
    lua_rawseti(L, index_map_idx, FALSE_INDEX);
    lua_pushboolean(L, true);
    lua_rawseti(L, index_map_idx, TRUE_INDEX);
  }

  if (flag & HAS_NUMBER_MASK)
  {
    last_top = index + 1;
    uint32_t count = 0;
    if (!ffi_stream_get_u30(&input, &count))
    {
      lua_pushnil(L);
      lua_pushliteral(L, "decode failed, can't get `number` count.");
      return 2;
    }
    uint32_t i = 1;
    for (; i <= count; i++)
    {
      double result = 0;
      if (!ffi_stream_get_d64(&input, &result))
      {
        lua_pushnil(L);
        lua_pushfstring(L, "decode failed, can't decode `number`, %d/%d", i, count);
        return 2;
      }
      lua_pushnumber(L, result);
      lua_rawseti(L, index_map_idx, ++index);
    }
  }

  if (flag & HAS_U30_MASK)
  {
    last_top = index + 1;
    uint32_t count = 0;
    if (!ffi_stream_get_u30(&input, &count))
    {
      lua_pushnil(L);
      lua_pushliteral(L, "decode failed.");
      return 2;
    }
    uint32_t i = 1;
    for (; i <= count; i++)
    {
      uint32_t count = 0;
      if (!ffi_stream_get_u30(&input, &count))
      {
        lua_pushnil(L);
        lua_pushliteral(L, "decode failed.");
        return 2;
      }
      lua_pushinteger(L, count);
      lua_rawseti(L, index_map_idx, ++index);
    }
  }

  if (flag & HAS_STRING_MASK)
  {
    last_top = index + 1;
    uint32_t count = 0;
    if (!ffi_stream_get_u30(&input, &count))
    {
      lua_pushnil(L);
      lua_pushliteral(L, "decode failed.");
      return 2;
    }
    uint32_t i = 1;
    for (; i <= count; i++)
    {
      uint8_t *buff = NULL;
      size_t buflen = 0;
      ffi_stream_get_string(&input, &buff, &buflen);
      if (!buff)
      {
        lua_pushnil(L);
        lua_pushliteral(L, "decode failed.");
        return 2;
      }
      lua_pushlstring(L, (const char *)buff, buflen);
      lua_rawseti(L, index_map_idx, ++index);
    }
  }

  if (flag & HAS_TABLE_MASK)
  {
    last_top = index + 1;
    uint32_t count = 0;
    if (!ffi_stream_get_u30(&input, &count))
    {
      lua_pushnil(L);
      lua_pushliteral(L, "decode failed.");
      return 2;
    }
    uint32_t i = 1;
    for (; i <= count; i++)
    {
      lua_newtable(L);
      lua_rawseti(L, index_map_idx, index + i);
    }

    i = 1;
    for (; i <= count; i++)
    {
      uint8_t *buff = NULL;
      size_t buflen = 0;
      ffi_stream_get_string(&input, &buff, &buflen);
      if (!buff)
      {
        lua_pushnil(L);
        lua_pushliteral(L, "decode failed.");
        return 2;
      }
      BYTEARRAY d = {0};
      bytearray_wrap_buffer(&d, buff, buflen);

      lua_rawgeti(L, index_map_idx, index + i);
      while (bytearray_read_available(&d) > 0)
      {
        uint32_t ki = 0;
        if (!ffi_stream_get_u30(&d, &ki))
        {
          lua_pushnil(L);
          lua_pushliteral(L, "decode failed.");
          return 2;
        }
        uint32_t vi = 0;
        if (!ffi_stream_get_u30(&d, &vi))
        {
          lua_pushnil(L);
          lua_pushliteral(L, "decode failed.");
          return 2;
        }

        lua_rawgeti(L, sym_map_vk_idx, ki);
        if (lua_isnil(L, -1))
        {
          lua_pop(L, 1);
          lua_rawgeti(L, index_map_idx, ki);

          if (lua_isnil(L, -1))
          {
            luaL_error(L, "ki=%d not found.", ki);
          }
        }

        lua_rawgeti(L, sym_map_vk_idx, vi);
        if (lua_isnil(L, -1))
        {
          lua_pop(L, 1);
          lua_rawgeti(L, index_map_idx, vi);

          if (lua_isnil(L, -1))
          {
            luaL_error(L, "vi=%d not found.", vi);
          }
        }

        lua_rawset(L, -3);
      }
      lua_pop(L, 1);
    }
  }

  lua_rawgeti(L, sym_map_vk_idx, last_top);
  if (lua_isnil(L, -1))
  {
    lua_rawgeti(L, index_map_idx, last_top);
  }
  // return sym_map_vk[last_top] or index_map[last_top]
  // lua_pushvalue(L, index_map_idx);
  // lua_pushinteger(L, last_top);
  return 1;
}
Example #14
0
LUA_API int luafan_objectbuf_encode(lua_State *L)
{
  int obj_index = 1;
  int sym_idx = 0;
  if (lua_isnoneornil(L, 1))
  {
    luaL_error(L, "no argument.");
    return 0;
  }
  if (lua_istable(L, 2))
  {
    sym_idx = 2;
  }

  if (lua_isboolean(L, 1))
  {
    int value = lua_toboolean(L, 1);
    lua_pushstring(L, value ? "\x01" : "\x00");
    return 1;
  }

  CTX ctx = {0};
  ctx_init(&ctx, L);

  packer(L, &ctx, obj_index);

  uint8_t flag = 0;
  BYTEARRAY bodystream;
  bytearray_alloc(&bodystream, 64);
  bytearray_write8(&bodystream, flag); // place holder.

  lua_newtable(L);
  int index_map_idx = lua_gettop(L);
  uint32_t index = 2;

  if (!sym_idx)
  {
    lua_newtable(L);
  }
  else
  {
    lua_rawgeti(L, sym_idx, SYM_INDEX_INDEX);
    index = lua_tointeger(L, -1);
    lua_pop(L, 1);

    lua_rawgeti(L, sym_idx, SYM_INDEX_MAP);
  }
  int sym_map_idx = lua_gettop(L);

  lua_pushboolean(L, false);
  lua_pushinteger(L, FALSE_INDEX);
  lua_rawset(L, index_map_idx);

  lua_pushboolean(L, true);
  lua_pushinteger(L, TRUE_INDEX);
  lua_rawset(L, index_map_idx);

  // ---------------------------------------------------------------------------
  if (ctx.number_count > 0)
  {
    flag |= HAS_NUMBER_MASK;
    uint32_t realcount = 0;

    BYTEARRAY d;
    bytearray_alloc(&d, 0);

    lua_rawgeti(L, ctx.index, CTX_INDEX_NUMBERS);
    int i = 1;
    for (; i <= ctx.number_count; i++)
    {
      lua_rawgeti(L, -1, i);

      lua_pushvalue(L, -1);
      lua_rawget(L, sym_map_idx);
      if (lua_isnil(L, -1))
      {
        lua_pop(L, 1);
        ffi_stream_add_d64(&d, lua_tonumber(L, -1));
        lua_pushinteger(L, index + (++realcount));
        lua_rawset(L, index_map_idx);
      }
      else
      {
        lua_pop(L, 2); // pop sym number idx & number
      }
    }
    lua_pop(L, 1);

    ffi_stream_add_u30(&bodystream, realcount);
    bytearray_read_ready(&d);
    bytearray_writebuffer(&bodystream, d.buffer, d.total);

    bytearray_dealloc(&d);

    index += realcount;
  }

  // ---------------------------------------------------------------------------
  if (ctx.u30_count > 0)
  {
    flag |= HAS_U30_MASK;
    uint32_t realcount = 0;

    BYTEARRAY d;
    bytearray_alloc(&d, 0);

    lua_rawgeti(L, ctx.index, CTX_INDEX_U30S);
    int i = 1;
    for (; i <= ctx.u30_count; i++)
    {
      lua_rawgeti(L, -1, i);

      lua_pushvalue(L, -1);
      lua_rawget(L, sym_map_idx);
      if (lua_isnil(L, -1))
      {
        lua_pop(L, 1);
        ffi_stream_add_u30(&d, lua_tointeger(L, -1));
        lua_pushinteger(L, index + (++realcount));
        lua_rawset(L, index_map_idx);
      }
      else
      {
        lua_pop(L, 2); // pop sym u30 idx & u30
      }
    }
    lua_pop(L, 1);

    ffi_stream_add_u30(&bodystream, realcount);
    bytearray_read_ready(&d);
    bytearray_writebuffer(&bodystream, d.buffer, d.total);

    bytearray_dealloc(&d);

    index += realcount;
  }

  // ---------------------------------------------------------------------------
  if (ctx.string_count > 0)
  {
    flag |= HAS_STRING_MASK;
    uint32_t realcount = 0;

    BYTEARRAY d;
    bytearray_alloc(&d, 0);

    lua_rawgeti(L, ctx.index, CTX_INDEX_STRINGS);
    int i = 1;
    for (; i <= ctx.string_count; i++)
    {
      lua_rawgeti(L, -1, i);

      lua_pushvalue(L, -1);
      lua_rawget(L, sym_map_idx);
      if (lua_isnil(L, -1))
      {
        lua_pop(L, 1);
        size_t len;
        const char *buf = lua_tolstring(L, -1, &len);
        ffi_stream_add_string(&d, buf, len);
        lua_pushinteger(L, index + (++realcount));
        lua_rawset(L, index_map_idx);
      }
      else
      {
        lua_pop(L, 2); // pop sym u30 idx & u30
      }
    }
    lua_pop(L, 1);

    ffi_stream_add_u30(&bodystream, realcount);
    bytearray_read_ready(&d);
    bytearray_writebuffer(&bodystream, d.buffer, d.total);

    bytearray_dealloc(&d);

    index += realcount;
  }
  // ---------------------------------------------------------------------------
  if (ctx.table_count)
  {
    flag |= HAS_TABLE_MASK;
    ffi_stream_add_u30(&bodystream, ctx.table_count);

    lua_rawgeti(L, ctx.index, CTX_INDEX_TABLES);
    int i = 1;
    for (; i <= ctx.table_count; i++)
    {
      lua_rawgeti(L, -1, i);
      lua_pushinteger(L, index + i);
      lua_rawset(L, index_map_idx);
    }

    for (i = 1; i <= ctx.table_count; i++)
    {
      lua_rawgeti(L, -1, i);
      int tb_idx = lua_gettop(L);

      BYTEARRAY d;
      bytearray_alloc(&d, 0);

      lua_pushnil(L);
      while (lua_next(L, tb_idx) != 0)
      {
        int value_idx = lua_gettop(L);
        int key_idx = lua_gettop(L) - 1;

        // d:AddU30(sym_map[k] or index_map[k])
        lua_pushvalue(L, key_idx);
        lua_rawget(L, sym_map_idx);
        if (lua_isnil(L, -1))
        {
          lua_pop(L, 1);
          lua_pushvalue(L, key_idx);
          lua_rawget(L, index_map_idx);
        }
        ffi_stream_add_u30(&d, lua_tointeger(L, -1));
        lua_pop(L, 1);

        // d:AddU30(sym_map[v] or index_map[v])
        lua_pushvalue(L, value_idx);
        lua_rawget(L, sym_map_idx);
        if (lua_isnil(L, -1))
        {
          lua_pop(L, 1);
          lua_pushvalue(L, value_idx);
          lua_rawget(L, index_map_idx);
        }
        ffi_stream_add_u30(&d, lua_tointeger(L, -1));
        lua_pop(L, 1);

        lua_pop(L, 1);
      }

      lua_pop(L, 1);

      bytearray_read_ready(&d);
      ffi_stream_add_string(&bodystream, (const char *)d.buffer, d.total);
      bytearray_dealloc(&d);
    }
    lua_pop(L, 1);
  }

  bytearray_read_ready(&bodystream);
  *((uint8_t *)bodystream.buffer) = flag;
  lua_pushlstring(L, (const char *)bodystream.buffer, bodystream.total);

  bytearray_dealloc(&bodystream);
  return 1;
}
int Thermal::help(lua_State* L)
{
	if(lua_gettop(L) == 0)
	{
		lua_pushstring(L, "Generates a the random thermal field of a *SpinSystem*");
		lua_pushstring(L, "1 *3Vector* or *SpinSystem*, 1 Optional *Random*: System Size and built in RNG"); 
		lua_pushstring(L, ""); //output, empty
		return 3;
	}
	
	if(lua_istable(L, 1))
	{
		return 0;
	}
	
	if(!lua_iscfunction(L, 1))
	{
		return luaL_error(L, "help expect zero arguments or 1 function.");
	}
	
	lua_CFunction func = lua_tocfunction(L, 1);
	
	if(func == l_apply)
	{
		lua_pushstring(L, "Generates a the random thermal field of a *SpinSystem*");
		lua_pushstring(L, "1 *SpinSystem*, 1 Optional *Random*,: The first argument is the spin system which will receive the field. The second optional argument is a random number generator that is used as a source of random values, if absent then the RNG supplied in the constructor will be used.");
		lua_pushstring(L, "");
		return 3;
	}

	if(func == l_scalesite)
	{
		lua_pushstring(L, "Scale the thermal field at a site. This allows non-uniform thermal effects over a lattice.");
		lua_pushstring(L, "1 *3Vector*, 1 Number: The vectors define the lattice sites that will have a scaled thermal effect, the number is the how the thermal field is scaled.");
		lua_pushstring(L, "");
		return 3;
	}
	
	if(func == l_settemp)
	{
		lua_pushstring(L, "Sets the base value of the temperature. ");
		lua_pushstring(L, "1 number: temperature of the system.");
		lua_pushstring(L, "");
		return 3;
	}
	
	if(func == l_gettemp)
	{
		lua_pushstring(L, "Gets the base value of the temperature. ");
		lua_pushstring(L, "");
		lua_pushstring(L, "1 number: temperature of the system.");
		return 3;
	}
	
	if(func == l_getscalearray)
	{
		lua_pushstring(L, "Get an array representing the thermal scale at each site. This array is connected to the Operator so changes to the returned array will change the Operator.");
		lua_pushstring(L, "");
		lua_pushstring(L, "1 Array: The thermal scale of the sites.");
		return 3;
	}
	if(func == l_setscalearray)
	{
		lua_pushstring(L, "Set an array representing the new thermal scale at each site.");
		lua_pushstring(L, "1 Array: The thermal scale of the sites.");
		lua_pushstring(L, "");
		return 3;
	}

	if(func == l_rng)
	{
		lua_pushstring(L, "Get the *Random* number generator supplied at initialization");
		lua_pushstring(L, "");
		lua_pushstring(L, "1 *Random* or 1 nil: RNG");
		return 3;
	}

	return SpinOperation::help(L);
}
Example #16
0
static int lua_new_packet(lua_State *L,int packettype){
	int argtype = lua_type(L,1); 
	if(packettype == WPACKET){
		if(argtype == LUA_TNUMBER || argtype == LUA_TNIL || argtype == LUA_TNONE){
			//参数为数字,构造一个初始大小为len的wpacket
			size_t len = 0;
			if(argtype == LUA_TNUMBER) len = size_of_pow2(lua_tointeger(L,1));
			if(len < 64) len = 64;
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);
			p->_packet = (packet_t)wpk_create(len);
			return 1;			
		}else if(argtype == LUA_TSTRING){
			size_t len;
			char *data = (char*)lua_tolstring(L,1,&len);
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);
			p->_packet = (packet_t)wpk_create_by_bin((int8_t*)data,len);
			return 1;				
		}else if(argtype ==  LUA_TUSERDATA){
			lua_packet_t other = lua_getluapacket(L,1);
			if(!other)
				return luaL_error(L,"invaild opration for arg1");
			if(other->_packet->type == RAWPACKET)
				return luaL_error(L,"invaild opration for arg1");
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);
			p->_packet = make_writepacket(other->_packet);//(packet_t)wpk_copy_create(other->_packet);
			return 1;												
		}else if(argtype == LUA_TTABLE){
			wpacket_t wpk = wpk_create(512);
			if(0 != lua_pack_table(wpk,L,-1)){
				destroy_packet((packet_t)wpk);
				return luaL_error(L,"table should not hava metatable");	
				//lua_pushnil(L);
			}else{
				lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
				luaL_getmetatable(L, LUAPACKET_METATABLE);
				lua_setmetatable(L, -2);
				p->_packet = (packet_t)wpk;		
			}
			return 1;
		}
		else	
			return luaL_error(L,"invaild opration for arg1");		
	}else if(packettype == RAWPACKET){
		if(argtype == LUA_TSTRING){
			//参数为string,构造一个函数数据data的rawpacket
			size_t len;
			char *data = (char*)lua_tolstring(L,1,&len);
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);				
			p->_packet = (packet_t)rawpacket_create2(data,len);
			return 1;
		}else if(argtype ==  LUA_TUSERDATA){
			lua_packet_t other = lua_getluapacket(L,1);
			if(!other)
				return luaL_error(L,"invaild opration for arg1");
			if(other->_packet->type != RAWPACKET)
				return luaL_error(L,"invaild opration for arg1");
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);
			p->_packet = clone_packet(other->_packet);
			return 1;							
		}else
			return luaL_error(L,"invaild opration for arg1");
	}else if(packettype == RPACKET){
		if(argtype ==  LUA_TUSERDATA){
			lua_packet_t other = lua_getluapacket(L,1);
			if(!other)
				return luaL_error(L,"invaild opration for arg1");
			if(other->_packet->type == RAWPACKET)
				return luaL_error(L,"invaild opration for arg1");
			lua_packet_t p = (lua_packet_t)lua_newuserdata(L, sizeof(*p));
			luaL_getmetatable(L, LUAPACKET_METATABLE);
			lua_setmetatable(L, -2);
			p->_packet = make_readpacket(other->_packet);
			return 1;					
		}else
			return luaL_error(L,"invaild opration for arg1");	
	}else
		return luaL_error(L,"invaild packet type");
}
Example #17
0
static int laura_do_async_call(lua_State *L)
{
	struct laura_node *lnode = NULL;
	const char *name;
	struct aura_buffer *buf;
	struct aura_object *o;
	int ret;
	int callback_ref;

	TRACE();

	/* Sanity */
	lnode = lua_fetch_node(L, 1);
	if (!lnode) {
		lua_stackdump(L);
		return aura_typeerror(L, 1, "userdata (node)");
	}

	if (!lua_isstring(L, 2)) {
		lua_stackdump(L);
		return aura_typeerror(L, 2, "string (object name)");
	}

	if (!lua_isfunction(L, 3)) {
		lua_stackdump(L);
		return aura_typeerror(L, 3, "function (callback)");
	}

	name = lua_tostring(L, 2);

	o = aura_etable_find(lnode->node->tbl, name);
	if (!o)
		return luaL_error(L, "Attempt to call non-existend method");

	if (!object_is_method(o)) {
		lua_stackdump(L);
		return luaL_error(L, "Attempt to call an event");
	}


	/* Now we're sane! */
	buf = lua_to_buffer(L, lnode->node, 5, o);
	if (!buf)
		return luaL_error(L, "Serializer failed!");

	/* Let's create a table to store our callback and arg */
	lua_newtable(L);

	/* Push the callback function there */
	lua_pushnumber(L, 1);
	lua_pushvalue(L, 3);
	lua_settable(L, -3);

	/* And the user argument */
	lua_pushnumber(L, 2);
	lua_pushvalue(L, 4);
	lua_settable(L, -3);

	/* And fetch the reference to out table that we'll use in callback */
	callback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
	slog(4, SLOG_DEBUG, "Callback tbl reference: %d", callback_ref);

	ret = aura_core_start_call(lnode->node, o, calldone_cb, (void *)(long)callback_ref, buf);
	if (ret != 0) {
		aura_buffer_release(buf);
		return luaL_error(L, "Async call for %s failed: %s code (%d)", o->name, strerror(-ret), ret);
	}

	return 0;
}
Example #18
0
File: upb.c Project: google/upb
bool lupb_checkbool(lua_State *L, int narg) {
  if (!lua_isboolean(L, narg)) {
    luaL_error(L, "must be true or false");
  }
  return lua_toboolean(L, narg);
}
Example #19
0
static int capture_to_close (MatchState *ms) {
  int level = ms->level;
  for (level--; level>=0; level--)
    if (ms->capture[level].len == CAP_UNFINISHED) return level;
  return luaL_error(ms->L, "invalid pattern capture");
}
Example #20
0
static FILE *tofile (lua_State *L, int findex) {
  FILE **f = topfile(L, findex);
  if (*f == NULL)
    luaL_error(L, "attempt to use a closed file");
  return *f;
}
Example #21
0
static int gfind_nodef (lua_State *L) {
  return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
                       LUA_QL("string.gmatch"));
}
Example #22
0
static int player_set(lua_State *L)
{
	player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
	const char *field = luaL_checkstring(L, 2);
	if (!plr)
		return LUA_ErrInvalid(L, "player_t");

	if (hud_running)
		return luaL_error(L, "Do not alter player_t in HUD rendering code!");

	if (fastcmp(field,"mo")) {
		mobj_t *newmo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
		plr->mo->player = NULL; // remove player pointer from old mobj
		(newmo->player = plr)->mo = newmo; // set player pointer for new mobj, and set new mobj as the player's mobj
	}
	else if (fastcmp(field,"cmd"))
		return NOSET;
	else if (fastcmp(field,"playerstate"))
		plr->playerstate = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"viewz"))
		plr->viewz = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"viewheight"))
		plr->viewheight = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"deltaviewheight"))
		plr->deltaviewheight = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"bob"))
		plr->bob = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"aiming")) {
		plr->aiming = luaL_checkangle(L, 3);
		if (plr == &players[consoleplayer])
			localaiming = plr->aiming;
		else if (plr == &players[secondarydisplayplayer])
			localaiming2 = plr->aiming;
	}
	else if (fastcmp(field,"health"))
		plr->health = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"pity"))
		plr->pity = (SINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"currentweapon"))
		plr->currentweapon = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"ringweapons"))
		plr->ringweapons = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"powers"))
		return NOSET;
	else if (fastcmp(field,"pflags"))
		plr->pflags = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"panim"))
		plr->panim = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"flashcount"))
		plr->flashcount = (UINT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"flashpal"))
		plr->flashpal = (UINT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"skincolor"))
	{
		UINT8 newcolor = (UINT8)luaL_checkinteger(L,3);
		if (newcolor >= MAXSKINCOLORS)
			return luaL_error(L, "player.skincolor %d out of range (0 - %d).", newcolor, MAXSKINCOLORS-1);
		plr->skincolor = newcolor;
	}
	else if (fastcmp(field,"score"))
		plr->score = (UINT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"dashspeed"))
		plr->dashspeed = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"dashtime"))
		plr->dashtime = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"normalspeed"))
		plr->normalspeed = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"runspeed"))
		plr->runspeed = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"thrustfactor"))
		plr->thrustfactor = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"accelstart"))
		plr->accelstart = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"acceleration"))
		plr->acceleration = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"charability"))
		plr->charability = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"charability2"))
		plr->charability2 = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"charflags"))
		plr->charflags = (UINT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"thokitem"))
		plr->thokitem = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"spinitem"))
		plr->spinitem = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"revitem"))
		plr->revitem = luaL_checkinteger(L, 3);
	else if (fastcmp(field,"actionspd"))
		plr->actionspd = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"mindash"))
		plr->mindash = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"maxdash"))
		plr->maxdash = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"jumpfactor"))
		plr->jumpfactor = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"lives"))
		plr->lives = (SINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"continues"))
		plr->continues = (SINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"xtralife"))
		plr->xtralife = (SINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"gotcontinue"))
		plr->gotcontinue = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"speed"))
		plr->speed = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"jumping"))
		plr->jumping = luaL_checkboolean(L, 3);
	else if (fastcmp(field,"secondjump"))
		plr->secondjump = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"fly1"))
		plr->fly1 = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"scoreadd"))
		plr->scoreadd = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"glidetime"))
		plr->glidetime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"climbing"))
		plr->climbing = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"deadtimer"))
		plr->deadtimer = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"exiting"))
		plr->exiting = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"homing"))
		plr->homing = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"skidtime"))
		plr->skidtime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"cmomx"))
		plr->cmomx = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"cmomy"))
		plr->cmomy = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"rmomx"))
		plr->rmomx = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"rmomy"))
		plr->rmomy = luaL_checkfixed(L, 3);
	else if (fastcmp(field,"numboxes"))
		plr->numboxes = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"totalring"))
		plr->totalring = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"realtime"))
		plr->realtime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"laps"))
		plr->laps = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"ctfteam"))
		plr->ctfteam = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"gotflag"))
		plr->gotflag = (UINT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"weapondelay"))
		plr->weapondelay = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"tossdelay"))
		plr->tossdelay = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starpostx"))
		plr->starpostx = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starposty"))
		plr->starposty = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starpostz"))
		plr->starpostz = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starpostnum"))
		plr->starpostnum = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starposttime"))
		plr->starposttime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"starpostangle"))
		plr->starpostangle = luaL_checkangle(L, 3);
	else if (fastcmp(field,"angle_pos"))
		plr->angle_pos = luaL_checkangle(L, 3);
	else if (fastcmp(field,"old_angle_pos"))
		plr->old_angle_pos = luaL_checkangle(L, 3);
	else if (fastcmp(field,"axis1"))
		P_SetTarget(&plr->axis1, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)));
	else if (fastcmp(field,"axis2"))
		P_SetTarget(&plr->axis2, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)));
	else if (fastcmp(field,"bumpertime"))
		plr->bumpertime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"flyangle"))
		plr->flyangle = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"drilltimer"))
		plr->drilltimer = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"linkcount"))
		plr->linkcount = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"linktimer"))
		plr->linktimer = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"anotherflyangle"))
		plr->anotherflyangle = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"nightstime"))
		plr->nightstime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"drillmeter"))
		plr->drillmeter = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"drilldelay"))
		plr->drilldelay = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"bonustime"))
		plr->bonustime = luaL_checkboolean(L, 3);
	else if (fastcmp(field,"capsule"))
	{
		mobj_t *mo = NULL;
		if (!lua_isnil(L, 3))
			mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
		P_SetTarget(&plr->capsule, mo);
	}
	else if (fastcmp(field,"mare"))
		plr->mare = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"marebegunat"))
		plr->marebegunat = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"startedtime"))
		plr->startedtime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"finishedtime"))
		plr->finishedtime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"finishedrings"))
		plr->finishedrings = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"marescore"))
		plr->marescore = (UINT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"lastmarescore"))
		plr->lastmarescore = (UINT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"lastmare"))
		plr->lastmare = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"maxlink"))
		plr->maxlink = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"texttimer"))
		plr->texttimer = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"textvar"))
		plr->textvar = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"lastsidehit"))
		plr->lastsidehit = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"lastlinehit"))
		plr->lastlinehit = (INT16)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"losstime"))
		plr->losstime = (tic_t)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"timeshit"))
		plr->timeshit = (UINT8)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"onconveyor"))
		plr->onconveyor = (INT32)luaL_checkinteger(L, 3);
	else if (fastcmp(field,"awayviewmobj"))
	{
		mobj_t *mo = NULL;
		if (!lua_isnil(L, 3))
			mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
		P_SetTarget(&plr->awayviewmobj, mo);
	}
	else if (fastcmp(field,"awayviewtics"))
	{
		plr->awayviewtics = (INT32)luaL_checkinteger(L, 3);
		if (plr->awayviewtics && !plr->awayviewmobj) // awayviewtics must ALWAYS have an awayviewmobj set!!
			P_SetTarget(&plr->awayviewmobj, plr->mo); // but since the script might set awayviewmobj immediately AFTER setting awayviewtics, use player mobj as filler for now.
	}
	else if (fastcmp(field,"awayviewaiming"))
		plr->awayviewaiming = luaL_checkangle(L, 3);
	else if (fastcmp(field,"spectator"))
		plr->spectator = lua_toboolean(L, 3);
	else if (fastcmp(field,"bot"))
		return NOSET;
	else if (fastcmp(field,"jointime"))
		plr->jointime = (tic_t)luaL_checkinteger(L, 3);
#ifdef HWRENDER
	else if (fastcmp(field,"fovadd"))
		plr->fovadd = luaL_checkfixed(L, 3);
#endif
	else {
		lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS);
		I_Assert(lua_istable(L, -1));
		lua_pushlightuserdata(L, plr);
		lua_rawget(L, -2);
		if (lua_isnil(L, -1)) {
			// This index doesn't have a table for extra values yet, let's make one.
			lua_pop(L, 1);
			CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; adding it as Lua data.\n"), "player_t", field);
			lua_newtable(L);
			lua_pushlightuserdata(L, plr);
			lua_pushvalue(L, -2); // ext value table
			lua_rawset(L, -4); // LREG_EXTVARS table
		}
		lua_pushvalue(L, 3); // value to store
		lua_setfield(L, -2, field);
		lua_pop(L, 2);
	}

	return 0;
}
Example #23
0
int icu_bidi_runs(lua_State *L) {
  size_t input_l;
  const char* input = luaL_checklstring(L, 1, &input_l);
  const char* direction = luaL_checkstring(L, 2);

  UChar *input_as_uchar;
  int32_t l;
  utf8_to_uchar(input, input_l, input_as_uchar, l);

  UBiDiLevel paraLevel = 0;
  if (strncasecmp(direction, "RTL", 3) == 0) {
    paraLevel = 1;
  }
  /* Now let's bidi! */
  UBiDi* bidi = ubidi_open();
  UErrorCode err = U_ZERO_ERROR;
  ubidi_setPara(bidi, input_as_uchar, l, paraLevel, NULL, &err);
  if (!U_SUCCESS(err)) {
    free(input_as_uchar);
    ubidi_close(bidi);
    return luaL_error(L, "Error in bidi %s", u_errorName(err));
  }

  int count = ubidi_countRuns(bidi,&err);
  int start, length;

  lua_checkstack(L,count);
  for (int i=0; i < count; i++) {
    UBiDiDirection dir = ubidi_getVisualRun(bidi, i, &start, &length);
    lua_newtable(L);
    // Convert back to UTF8...
    int32_t l3 = 0;
    char* possibleOutbuf = malloc(4*length);
    if(!possibleOutbuf) {
      return luaL_error(L, "Couldn't malloc");
    }
    u_strToUTF8(possibleOutbuf, 4 * length, &l3, input_as_uchar+start, length, &err);
    if (!U_SUCCESS(err)) {
      free(possibleOutbuf);
      return luaL_error(L, "Bidi run too big? %s", u_errorName(err));
    }
    lua_pushstring(L, "run");
    lua_pushstring(L, possibleOutbuf);
    free(possibleOutbuf);
    lua_settable(L, -3);

    lua_pushstring(L, "start");
    int32_t new_start = start;
    // Length/start is given in terms of UTF16 codepoints.
    // But we want a count of Unicode characters. This means
    // surrogate pairs need to be counted as 1.
    for (int j=0; j< start; j++) {
      if (U_IS_TRAIL(*(input_as_uchar+j))) new_start--;
    }
    lua_pushinteger(L, new_start);
    lua_settable(L, -3);

    lua_pushstring(L, "length");
    for (int j=start; j< start+length; j++) {
      if (U_IS_TRAIL(*(input_as_uchar+j))) length--;
    }
    lua_pushinteger(L, length);
    lua_settable(L, -3);

    lua_pushstring(L, "dir");
    lua_pushstring(L, dir == UBIDI_RTL ? "RTL" : "LTR");
    lua_settable(L, -3);

    lua_pushstring(L, "level");
    lua_pushinteger(L, ubidi_getLevelAt(bidi, start));
    lua_settable(L, -3);
  }

  free(input_as_uchar);
  ubidi_close(bidi);
  return count;
}
static int
ngx_http_lua_ngx_get(lua_State *L)
{
    ngx_http_request_t          *r;
    u_char                      *p;
    size_t                       len;
    ngx_http_lua_ctx_t          *ctx;

    lua_pushlightuserdata(L, &ngx_http_lua_request_key);
    lua_rawget(L, LUA_GLOBALSINDEX);
    r = lua_touserdata(L, -1);
    lua_pop(L, 1);

    if (r == NULL) {
        return luaL_error(L, "no request object found");
    }

    p = (u_char *) luaL_checklstring(L, -1, &len);

    dd("ngx get %s", p);

    if (len == sizeof("status") - 1
        && ngx_strncmp(p, "status", sizeof("status") - 1) == 0)
    {
        ngx_http_lua_check_fake_request(L, r);
        lua_pushnumber(L, (lua_Number) r->headers_out.status);
        return 1;
    }

    if (len == sizeof("ctx") - 1
        && ngx_strncmp(p, "ctx", sizeof("ctx") - 1) == 0)
    {
        return ngx_http_lua_ngx_get_ctx(L);
    }

    if (len == sizeof("is_subrequest") - 1
        && ngx_strncmp(p, "is_subrequest", sizeof("is_subrequest") - 1) == 0)
    {
        lua_pushboolean(L, r != r->main);
        return 1;
    }

    if (len == sizeof("headers_sent") - 1
        && ngx_strncmp(p, "headers_sent", sizeof("headers_sent") - 1) == 0)
    {
        ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
        if (ctx == NULL) {
            return luaL_error(L, "no ctx");
        }

        ngx_http_lua_check_fake_request2(L, r, ctx);

        dd("headers sent: %d", ctx->headers_sent);

        lua_pushboolean(L, ctx->headers_sent ? 1 : 0);
        return 1;
    }

    dd("key %s not matched", p);

    lua_pushnil(L);
    return 1;
}
Example #25
0
int icu_breakpoints(lua_State *L) {
  const char* input = luaL_checkstring(L, 1);
  int input_l = strlen(input);
  const char* locale = luaL_checkstring(L, 2);
  UChar *buffer;
  int32_t l, breakcount = 0;
  UErrorCode err = U_ZERO_ERROR;
  u_strFromUTF8(NULL, 0, &l, input, input_l, &err);
  /* Above call returns an error every time. */
  err = U_ZERO_ERROR;
  buffer = malloc(l * sizeof(UChar));
  u_strFromUTF8(buffer, l, &l, input, input_l, &err);

  UBreakIterator* wordbreaks, *linebreaks;
  int32_t i, previous;
  wordbreaks = ubrk_open(UBRK_WORD, locale, buffer, l, &err);
  if(U_FAILURE(err)) {
    luaL_error(L, "Word break parser failure: %s", u_errorName(err));
  }

  linebreaks = ubrk_open(UBRK_LINE, locale, buffer, l, &err);
  if(U_FAILURE(err)) {
    luaL_error(L, "Line break parser failure: %s", u_errorName(err));
  }

  previous = 0;
  i = 0;
  while (i <= l) {
    int32_t out_l;
    int32_t type;
    if (!ubrk_isBoundary(linebreaks, i) && !ubrk_isBoundary(wordbreaks,i)) {
      i++; continue;
    }
    lua_checkstack(L, 3);
    /* At some kind of boundary */
    lua_newtable(L);
    lua_pushstring(L, "type");
    lua_pushstring(L, ubrk_isBoundary(linebreaks,i) ? "line" : "word");
    lua_settable(L, -3);

    int32_t utf8_index = 0;
    err = U_ZERO_ERROR;
    u_strToUTF8(NULL, 0, &utf8_index, buffer, i, &err);
    assert(U_SUCCESS(err) || err == U_BUFFER_OVERFLOW_ERROR);

    lua_pushstring(L, "index");
    lua_pushinteger(L, utf8_index);
    lua_settable(L, -3);

    if (ubrk_isBoundary(linebreaks, i)) {
      lua_pushstring(L, "subtype");
      type = ubrk_getRuleStatus(linebreaks);
      if (type >= UBRK_LINE_SOFT && type < UBRK_LINE_SOFT_LIMIT) {
        lua_pushstring(L, "soft");
      } else {
        lua_pushstring(L, "hard");
      }
      lua_settable(L, -3);
    }
    lua_pushstring(L, "token");
    lua_pushlstring(L, input+previous, utf8_index-previous);

    lua_settable(L, -3);

    previous = utf8_index;
    breakcount++;
    i++;
  }
  ubrk_close(wordbreaks);
  ubrk_close(linebreaks);
  return breakcount;
}
Example #26
0
static int uart_read( lua_State* L )
{
  int id, res, mode, issign;
  unsigned timer_id = 0;
  s32 timeout = PLATFORM_UART_INFINITE_TIMEOUT, maxsize = 0, count = 0;
  const char *fmt;
  luaL_Buffer b;
  char cres;
  
  id = luaL_checkinteger( L, 1 );
  MOD_CHECK_ID( uart, id );

  // Check format
  if( lua_isnumber( L, 2 ) )
  {
    if( ( maxsize = ( s32 )lua_tointeger( L, 2 ) ) < 0 )
      return luaL_error( L, "invalid max size" );
    mode = UART_READ_MODE_MAXSIZE;
  }
  else
  {
    fmt = luaL_checkstring( L, 2 );
    if( !strcmp( fmt, "*l" ) )
      mode = UART_READ_MODE_LINE;
    else if( !strcmp( fmt, "*n" ) )
      mode = UART_READ_MODE_NUMBER;
    else if( !strcmp( fmt, "*s" ) )
      mode = UART_READ_MODE_SPACE;
    else
      return luaL_error( L, "invalid format" );
  }

  // Check timeout and timer id
  if( lua_gettop( L ) >= 3 )
  {
    timeout = luaL_checkinteger( L, 3 );
    if( ( timeout < 0 ) && ( timeout != PLATFORM_UART_INFINITE_TIMEOUT ) )
      return luaL_error( L, "invalid timeout value" );      
    if( ( timeout != PLATFORM_UART_INFINITE_TIMEOUT ) && ( timeout != 0 ) )
      timer_id = luaL_checkinteger( L, 4 );    
  }

  // Read data
  luaL_buffinit( L, &b );
  while( 1 )
  {
    if( ( res = platform_uart_recv( id, timer_id, timeout ) ) == -1 )
      break; 
    cres = ( char )res;
    count ++;
    issign = ( count == 1 ) && ( ( res == '-' ) || ( res == '+' ) );
    if( ( cres == '\n' ) && ( mode == UART_READ_MODE_LINE ) )
      break;
    if( !isdigit( cres ) && !issign && ( mode == UART_READ_MODE_NUMBER ) )
      break;
    if( isspace( cres ) && ( mode == UART_READ_MODE_SPACE ) )
      break;
    luaL_putchar( &b, cres );
    if( ( count == maxsize ) && ( mode == UART_READ_MODE_MAXSIZE ) )
      break;
  }
  luaL_pushresult( &b );

  // Return an integer if needed
  if( mode == UART_READ_MODE_NUMBER )
  {
    res = lua_tointeger( L, -1 );
    lua_pop( L, 1 );
    lua_pushinteger( L, res );
  }
  return 1;  
}
Example #27
0
static int statement_fetch_impl(lua_State *L, statement_t *statement, int named_columns) {
    int column_count;
    MYSQL_BIND *bind = NULL;
    const char *error_message = NULL;

    if (!statement->stmt) {
		luaL_error(L, DBI_ERR_FETCH_INVALID);
		return 0;
    }

    if (!statement->metadata) {
		luaL_error(L, DBI_ERR_FETCH_NO_EXECUTE);
		return 0;
    }

    column_count = mysql_num_fields(statement->metadata);

    if (column_count > 0) {
		int i;
		MYSQL_FIELD *fields;

        bind = malloc(sizeof(MYSQL_BIND) * column_count);
        memset(bind, 0, sizeof(MYSQL_BIND) * column_count);

		fields = mysql_fetch_fields(statement->metadata);

		for (i = 0; i < column_count; i++) {
			unsigned int length = mysql_buffer_size(&fields[i]);
			char *buffer = (char *) malloc(length);
			memset(buffer, 0, length);

			bind[i].buffer_type = fields[i].type; 
			bind[i].buffer = buffer;
			bind[i].buffer_length = length;
		}

		if (mysql_stmt_bind_result(statement->stmt, bind)) {
			error_message = DBI_ERR_BINDING_RESULTS;
			goto cleanup;
		}

		if (!mysql_stmt_fetch(statement->stmt)) {
			int d = 1;

			lua_newtable(L);
			for (i = 0; i < column_count; i++) {
				lua_push_type_t lua_push = mysql_to_lua_push(fields[i].type);
				const char *name = fields[i].name;

				if (lua_push == LUA_PUSH_NIL) {
					if (named_columns) {
						LUA_PUSH_ATTRIB_NIL(name);
					} else {
						LUA_PUSH_ARRAY_NIL(d);
					}
				} else if (lua_push == LUA_PUSH_INTEGER) {
					if (fields[i].type == MYSQL_TYPE_YEAR || fields[i].type == MYSQL_TYPE_SHORT) {
						if (named_columns) {
							LUA_PUSH_ATTRIB_INT(name, *(short *)(bind[i].buffer)); 
						} else {
							LUA_PUSH_ARRAY_INT(d, *(short *)(bind[i].buffer)); 
						}
					} else if (fields[i].type == MYSQL_TYPE_TINY) {
						if (named_columns) {
							LUA_PUSH_ATTRIB_INT(name, (int)*(char *)(bind[i].buffer)); 
						} else {
							LUA_PUSH_ARRAY_INT(d, (int)*(char *)(bind[i].buffer)); 
						}
					} else {
						if (named_columns) {
							LUA_PUSH_ATTRIB_INT(name, *(int *)(bind[i].buffer)); 
						} else {
							LUA_PUSH_ARRAY_INT(d, *(int *)(bind[i].buffer)); 
						}
					}
				} else if (lua_push == LUA_PUSH_NUMBER) {
					if (named_columns) {
						LUA_PUSH_ATTRIB_FLOAT(name, *(double *)(bind[i].buffer));
					} else {
						LUA_PUSH_ARRAY_FLOAT(d, *(double *)(bind[i].buffer));
					}
				} else if (lua_push == LUA_PUSH_STRING) {
					if (fields[i].type == MYSQL_TYPE_TIMESTAMP || fields[i].type == MYSQL_TYPE_DATETIME) {
						char str[20];
						struct st_mysql_time *t = bind[i].buffer;

						snprintf(str, 20, "%d-%02d-%02d %02d:%02d:%02d", t->year, t->month, t->day, t->hour, t->minute, t->second);

						if (named_columns) {
							LUA_PUSH_ATTRIB_STRING(name, str);
						} else {
							LUA_PUSH_ARRAY_STRING(d, str);
						}
					} else if (fields[i].type == MYSQL_TYPE_TIME) {
						char str[9];
						struct st_mysql_time *t = bind[i].buffer;

						snprintf(str, 9, "%02d:%02d:%02d", t->hour, t->minute, t->second);

						if (named_columns) {
							LUA_PUSH_ATTRIB_STRING(name, str);
						} else {
							LUA_PUSH_ARRAY_STRING(d, str);
						}
						} else if (fields[i].type == MYSQL_TYPE_DATE) {
						char str[20];
						struct st_mysql_time *t = bind[i].buffer;

						snprintf(str, 11, "%d-%02d-%02d", t->year, t->month, t->day);

						if (named_columns) {
							LUA_PUSH_ATTRIB_STRING(name, str);
						} else {
							LUA_PUSH_ARRAY_STRING(d, str);
						}
					} else {
						size_t length = bind[i].buffer_length;
						//
						//  hack for strings. have no idea what 8 means but it is different from value for binary blobs, which is good enough
						//
						if (fields[i].charsetnr == 8) {
							length = min(bind[i].buffer_length, strlen(bind[i].buffer));
						}
						if (named_columns) {
							LUA_PUSH_ATTRIB_LSTRING(name, bind[i].buffer, length);
						} else {
							LUA_PUSH_ARRAY_LSTRING(d, bind[i].buffer, length);
						}
					}
				} else if (lua_push == LUA_PUSH_BOOLEAN) {
					if (named_columns) {
						LUA_PUSH_ATTRIB_BOOL(name, *(int *)(bind[i].buffer));
					} else {
						LUA_PUSH_ARRAY_BOOL(d, *(int *)(bind[i].buffer));
					}
				} else {
					luaL_error(L, DBI_ERR_UNKNOWN_PUSH);
				}
			}
		} else {
			lua_pushnil(L);	    
		}
    }

cleanup:
    if (bind) {
	int i;

	for (i = 0; i < column_count; i++) {
	    free(bind[i].buffer);
	}

	free(bind);
    }

    if (error_message) {
        luaL_error(L, error_message, mysql_stmt_error(statement->stmt));
        return 0;
    }

    return 1;    
}
Example #28
0
static void push_invalid (lua_State *L, STAT_STRUCT *info) {
  luaL_error(L, "invalid attribute name");
#ifndef _WIN32
  info->st_blksize = 0; /* never reached */
#endif
}
Example #29
0
int libmcache::lua_mcache_open(lua_State* L)
{
    size_t l=0;

    const char* p=luaL_checklstring(L,1,&l);
    
    int fd=-1;

    if(*p=='/')
    {
	if(l>=UNIX_PATH_MAX)
	    return luaL_error(L,err_socket_path_too_long);

        sockaddr_un sun;
        sun.sun_family=AF_UNIX;
	strcpy(sun.sun_path,p);
	
	fd=socket(sun.sun_family,SOCK_STREAM,0);
	
	if(fd==-1)
	    return luaL_error(L,err_errno,strerror(errno));

	if(connect(fd,(sockaddr*)&sun,sizeof(sun)))
	{
	    close(fd);
	    return luaL_error(L,err_errno,strerror(errno));
	}				    
    }else
    {
	const char* p2=strchr(p,':');
	
	if(!p2)
	    return luaL_error(L,err_invalid_address_format);
	
	char tmp[128];
	
	size_t l=p2-p;
	
	if(l>sizeof(tmp)-1)
	    return luaL_error(L,err_invalid_address_length);
	
	memcpy(tmp,p,l);
	tmp[l]=0;
	
	sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(atoi(p2+1));
	sin.sin_addr.s_addr=inet_addr(tmp);

	if(sin.sin_addr.s_addr==INADDR_NONE)
        {
	    hostent* he=gethostbyname(tmp);
            if(!he)
		return luaL_error(L,err_host_is_not_found,tmp);
            memcpy((char*)&sin.sin_addr.s_addr,he->h_addr,sizeof(sin.sin_addr.s_addr));
        }

	fd=socket(sin.sin_family,SOCK_STREAM,0);
	
	if(fd==-1)
	    return luaL_error(L,err_errno,strerror(errno));

	if(connect(fd,(sockaddr*)&sin,sizeof(sin)))
	{
	    close(fd);
	    return luaL_error(L,err_errno,strerror(errno));
	}				    

    }

    int on=1;
    setsockopt(fd,IPPROTO_TCP,TCP_NODELAY,&on,sizeof(on));
    
    FILE* fp=fdopen(fd,"r+");
    
    if(!fp)
    {
	close(fd);
        return luaL_error(L,err_errno,strerror(errno));
    }

    LMCACHE* mcache=(LMCACHE*)lua_newuserdata(L,sizeof(LMCACHE));

    luaL_getmetatable(L,LUA_MCACHE);
    lua_setmetatable(L,-2);

    mcache->fp=fp;
	    
    return 1;
}
Example #30
0
static int queryuserdata_mtcall(lua_State *l) {
	lua_settop(l, 1);	//[u]
	assert(lua_type(l, 1) == LUA_TUSERDATA);

	struct queryuserdata *ud =
	 (struct queryuserdata *)lua_touserdata(l, 1);
	assert(ud != NULL);

	if(ud->stmt == NULL) {
		lua_pushnil(l);	//[u_]
		return 1;
	}

	int rc = sqlite3_step(ud->stmt);
	if(rc == SQLITE_DONE) {
		sqlite3_finalize(ud->stmt);
		ud->stmt = NULL;
		lua_pushnil(l);	//[u_]
		return 1;
	}

	if(rc != SQLITE_ROW) {
		lua_pushfstring(l, 
		 "Failed to execute statement: %s",
		 sqlite3_errmsg(sqlite3_db_handle(ud->stmt)));
		sqlite3_finalize(ud->stmt);
		ud->stmt = NULL;
		return lua_error(l);
	}

	assert(rc == SQLITE_ROW);
	
	lua_newtable(l);	//[ut]
	int col = sqlite3_column_count(ud->stmt) - 1;
	while(col >= 0) {
		switch(sqlite3_column_type(ud->stmt, col)) {
			case SQLITE_NULL:
				lua_pushnil(l);
				break;

			case SQLITE_INTEGER:
			case SQLITE_FLOAT:
				lua_pushnumber(l, sqlite3_column_double(ud->stmt, col));
				break;

			case SQLITE_TEXT:
				lua_pushlstring(l,
				 (const char *)sqlite3_column_text(ud->stmt, col),
				 sqlite3_column_bytes(ud->stmt, col));
				break;

			case SQLITE_BLOB:
				lua_pushlstring(l,
				 (const char *)sqlite3_column_blob(ud->stmt, col),
				 sqlite3_column_bytes(ud->stmt, col));
				break;

			default:
				assert(0);
				return luaL_error(l, "Logic Error: unknown col type");
		}
		//[ut?]

		lua_pushvalue(l, -1);	//[ut??]
		if(ud->intkey) {
			lua_rawseti(l, -3, col+1);	//[ut?]
		} else {
			lua_pop(l, 1);	//[ut?]
		}

		if(ud->assockey) {
			lua_setfield(l, -2, sqlite3_column_name(ud->stmt, col));	//[ut]
		} else {
			lua_pop(l, 1);	//[ut]
		}

		--col;
	}

	return 1;
}