int ModApiMainMenu::l_get_table_index(lua_State *L)
{
GUIEngine* engine = getGuiEngine(L);
sanity_check(engine != NULL);
std::string tablename(luaL_checkstring(L, 1));
GUITable *table = engine->m_menu->getTable(tablename);
s32 selection = table ? table->getSelected() : 0;
if (selection >= 1)
lua_pushinteger(L, selection);
else
lua_pushnil(L);
return 1;
}
void CodeAlloc::free(NIns* start, NIns *end) {
CodeList *blk = getBlock(start, end);
if (verbose)
avmplus::AvmLog("free %p-%p %d\n", start, end, (int)blk->size());
AvmAssert(!blk->isFree);
// coalesce
if (blk->lower && blk->lower->isFree) {
// combine blk into blk->lower (destroy blk)
CodeList* lower = blk->lower;
CodeList* higher = blk->higher;
lower->higher = higher;
higher->lower = lower;
debug_only( sanity_check();)
// set_timeofday(val)
// val = 0...1
int ModApiEnvMod::l_set_timeofday(lua_State *L)
{
GET_ENV_PTR;
// Do it
float timeofday_f = luaL_checknumber(L, 1);
sanity_check(timeofday_f >= 0.0 && timeofday_f <= 1.0);
int timeofday_mh = (int)(timeofday_f * 24000.0);
// This should be set directly in the environment but currently
// such changes aren't immediately sent to the clients, so call
// the server instead.
//env->setTimeOfDay(timeofday_mh);
getServer(L)->setTimeOfDay(timeofday_mh);
return 0;
}
SWITCH_DECLARE(int) CoreSession::setAutoHangup(bool val)
{
this_check(-1);
sanity_check(-1);
if (!session) {
return SWITCH_STATUS_FALSE;
}
if (val) {
switch_set_flag(this, S_HUP);
} else {
switch_clear_flag(this, S_HUP);
}
return SWITCH_STATUS_SUCCESS;
}
void Schematic::placeOnMap(ServerMap *map, v3s16 p, u32 flags,
Rotation rot, bool force_place)
{
std::map<v3s16, MapBlock *> lighting_modified_blocks;
std::map<v3s16, MapBlock *> modified_blocks;
std::map<v3s16, MapBlock *>::iterator it;
assert(map != NULL);
assert(schemdata != NULL);
sanity_check(m_ndef != NULL);
//// Determine effective rotation and effective schematic dimensions
if (rot == ROTATE_RAND)
rot = (Rotation)myrand_range(ROTATE_0, ROTATE_270);
v3s16 s = (rot == ROTATE_90 || rot == ROTATE_270) ?
v3s16(size.Z, size.Y, size.X) : size;
//// Adjust placement position if necessary
if (flags & DECO_PLACE_CENTER_X)
p.X -= (s.X + 1) / 2;
if (flags & DECO_PLACE_CENTER_Y)
p.Y -= (s.Y + 1) / 2;
if (flags & DECO_PLACE_CENTER_Z)
p.Z -= (s.Z + 1) / 2;
//// Create VManip for effected area, emerge our area, modify area
//// inside VManip, then blit back.
v3s16 bp1 = getNodeBlockPos(p);
v3s16 bp2 = getNodeBlockPos(p + s - v3s16(1,1,1));
MMVManip vm(map);
vm.initialEmerge(bp1, bp2);
blitToVManip(&vm, p, rot, force_place);
voxalgo::blit_back_with_light(map, &vm, &modified_blocks);
//// Carry out post-map-modification actions
//// Create & dispatch map modification events to observers
MapEditEvent event;
event.type = MEET_OTHER;
for (it = modified_blocks.begin(); it != modified_blocks.end(); ++it)
event.modified_blocks.insert(it->first);
map->dispatchEvent(&event);
}
SWITCH_DECLARE(int) CoreSession::flushEvents()
{
switch_event_t *event;
this_check(-1);
sanity_check(-1);
if (!session) {
return SWITCH_STATUS_FALSE;
}
while (switch_core_session_dequeue_event(session, &event, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
switch_event_destroy(&event);
}
return SWITCH_STATUS_SUCCESS;
}
void LuaLBM::trigger(ServerEnvironment *env, v3s16 p, MapNode n)
{
GameScripting *scriptIface = env->getScriptIface();
auto _script_lock = RecursiveMutexAutoLock(scriptIface->m_luastackmutex, std::try_to_lock);
if (!_script_lock.owns_lock()) {
return;
}
scriptIface->realityCheck();
lua_State *L = scriptIface->getStack();
sanity_check(lua_checkstack(L, 20));
StackUnroller stack_unroller(L);
int error_handler = PUSH_ERROR_HANDLER(L);
// Get registered_lbms
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_lbms");
luaL_checktype(L, -1, LUA_TTABLE);
lua_remove(L, -2); // Remove core
// Get registered_lbms[m_id]
lua_pushnumber(L, m_id);
lua_gettable(L, -2);
//FATAL_ERROR_IF(lua_isnil(L, -1), "Entry with given id not found in registered_lbms table");
if (lua_isnil(L, -1)) {
errorstream << "Entry with given id " << m_id << " not found in registered_lbms table" << std::endl;
return;
}
lua_remove(L, -2); // Remove registered_lbms
scriptIface->setOriginFromTable(-1);
// Call action
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, "action");
luaL_checktype(L, -1, LUA_TFUNCTION);
lua_remove(L, -2); // Remove registered_lbms[m_id]
push_v3s16(L, p);
pushnode(L, n, env->getGameDef()->ndef());
int result = lua_pcall(L, 2, 0, error_handler);
if (result)
scriptIface->scriptError(result, "LuaLBM::trigger");
lua_pop(L, 1); // Pop error handler
}
void editor_map::resize(int width, int height, int x_offset, int y_offset,
t_translation::t_terrain filler)
{
int old_w = w();
int old_h = h();
if (old_w == width && old_h == height && x_offset == 0 && y_offset == 0) {
return;
}
// Determine the amount of resizing is required
const int left_resize = -x_offset;
const int right_resize = (width - old_w) + x_offset;
const int top_resize = -y_offset;
const int bottom_resize = (height - old_h) + y_offset;
if(right_resize > 0) {
expand_right(right_resize, filler);
} else if(right_resize < 0) {
shrink_right(-right_resize);
}
if(bottom_resize > 0) {
expand_bottom(bottom_resize, filler);
} else if(bottom_resize < 0) {
shrink_bottom(-bottom_resize);
}
if(left_resize > 0) {
expand_left(left_resize, filler);
} else if(left_resize < 0) {
shrink_left(-left_resize);
}
if(top_resize > 0) {
expand_top(top_resize, filler);
} else if(top_resize < 0) {
shrink_top(-top_resize);
}
// fix the starting positions
if(x_offset || y_offset) {
for(size_t i = 0; i < MAX_PLAYERS+1; ++i) {
if(startingPositions_[i] != map_location()) {
startingPositions_[i].x -= x_offset;
startingPositions_[i].y -= y_offset;
}
}
}
sanity_check();
}
static int __init check_header(void)
{
const char * reason = NULL;
int error;
if ((error = bio_read_page(swp_offset(swsusp_header.swsusp_info), &swsusp_info)))
return error;
/* Is this same machine? */
if ((reason = sanity_check())) {
printk(KERN_ERR "swsusp: Resume mismatch: %s\n",reason);
return -EPERM;
}
nr_copy_pages = swsusp_info.image_pages;
pagedir_order = get_bitmask_order(SUSPEND_PD_PAGES(nr_copy_pages));
return error;
}
status_t create_libxs_wrapper(xen_instance_t *xen)
{
libxs_wrapper_t *wrapper = &xen->libxsw;
wrapper->handle = dlopen ("libxenstore.so", RTLD_NOW | RTLD_GLOBAL);
if ( !wrapper->handle ) {
fprintf(stderr, "Failed to find a suitable libxenstore.so at any of the standard paths!\n");
return VMI_FAILURE;
}
wrapper->xs_open = dlsym(wrapper->handle, "xs_open");
wrapper->xs_close = dlsym(wrapper->handle, "xs_close");
wrapper->xs_directory = dlsym(wrapper->handle, "xs_directory");
wrapper->xs_read = dlsym(wrapper->handle, "xs_read");
return sanity_check(xen);
}
int ModApiMainMenu::l_update_formspec(lua_State *L)
{
GUIEngine* engine = getGuiEngine(L);
sanity_check(engine != NULL);
if (engine->m_startgame)
return 0;
//read formspec
std::string formspec(luaL_checkstring(L, 1));
if (engine->m_formspecgui != 0) {
engine->m_formspecgui->setForm(formspec);
}
return 0;
}
SWITCH_DECLARE(char *) CoreSession::getXMLCDR()
{
switch_xml_t cdr;
this_check((char *)"");
sanity_check((char *)"");
switch_safe_free(xml_cdr_text);
if (switch_ivr_generate_xml_cdr(session, &cdr) == SWITCH_STATUS_SUCCESS) {
xml_cdr_text = switch_xml_toxml(cdr, SWITCH_FALSE);
switch_xml_free(cdr);
}
return (char *) (xml_cdr_text ? xml_cdr_text : "");
}
void Schematic::placeStructure(Map *map, v3s16 p, u32 flags,
Rotation rot, bool force_place)
{
assert(schemdata != NULL); // Pre-condition
sanity_check(m_ndef != NULL);
MMVManip *vm = new MMVManip(map);
if (rot == ROTATE_RAND)
rot = (Rotation)myrand_range(ROTATE_0, ROTATE_270);
v3s16 s = (rot == ROTATE_90 || rot == ROTATE_270) ?
v3s16(size.Z, size.Y, size.X) : size;
if (flags & DECO_PLACE_CENTER_X)
p.X -= (s.X + 1) / 2;
if (flags & DECO_PLACE_CENTER_Y)
p.Y -= (s.Y + 1) / 2;
if (flags & DECO_PLACE_CENTER_Z)
p.Z -= (s.Z + 1) / 2;
v3s16 bp1 = getNodeBlockPos(p);
v3s16 bp2 = getNodeBlockPos(p + s - v3s16(1,1,1));
vm->initialEmerge(bp1, bp2);
blitToVManip(p, vm, rot, force_place);
std::map<v3s16, MapBlock *> lighting_modified_blocks;
std::map<v3s16, MapBlock *> modified_blocks;
vm->blitBackAll(&modified_blocks);
// TODO: Optimize this by using Mapgen::calcLighting() instead
lighting_modified_blocks.insert(modified_blocks.begin(), modified_blocks.end());
map->updateLighting(lighting_modified_blocks, modified_blocks);
MapEditEvent event;
event.type = MEET_OTHER;
for (std::map<v3s16, MapBlock *>::iterator
it = modified_blocks.begin();
it != modified_blocks.end(); ++it)
event.modified_blocks.insert(it->first);
map->dispatchEvent(&event);
}
void LuaABM::trigger(ServerEnvironment *env, v3s16 p, MapNode n,
u32 active_object_count, u32 active_object_count_wider)
{
GameScripting *scriptIface = env->getScriptIface();
scriptIface->realityCheck();
lua_State *L = scriptIface->getStack();
sanity_check(lua_checkstack(L, 20));
StackUnroller stack_unroller(L);
lua_pushcfunction(L, script_error_handler);
int errorhandler = lua_gettop(L);
// Get registered_abms
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_abms");
luaL_checktype(L, -1, LUA_TTABLE);
lua_remove(L, -2); // Remove core
// Get registered_abms[m_id]
lua_pushnumber(L, m_id);
lua_gettable(L, -2);
if(lua_isnil(L, -1))
FATAL_ERROR("");
lua_remove(L, -2); // Remove registered_abms
scriptIface->setOriginFromTable(-1);
// Call action
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, "action");
luaL_checktype(L, -1, LUA_TFUNCTION);
lua_remove(L, -2); // Remove registered_abms[m_id]
push_v3s16(L, p);
pushnode(L, n, env->getGameDef()->ndef());
lua_pushnumber(L, active_object_count);
lua_pushnumber(L, active_object_count_wider);
int result = lua_pcall(L, 4, 0, errorhandler);
if (result)
scriptIface->scriptError(result, "LuaABM::trigger");
lua_pop(L, 1); // Pop error handler
}
void ftl_open(void)
{
// debugging example 1 - use breakpoint statement!
/* *(UINT32*)0xFFFFFFFE = 10; */
/* UINT32 volatile g_break = 0; */
/* while (g_break == 0); */
led(0);
sanity_check();
//----------------------------------------
// read scan lists from NAND flash
// and build bitmap of bad blocks
//----------------------------------------
build_bad_blk_list();
//----------------------------------------
// If necessary, do low-level format
// format() should be called after loading scan lists, because format() calls is_bad_block().
//----------------------------------------
/* if (check_format_mark() == FALSE) */
if (TRUE)
{
uart_print("do format");
format();
uart_print("end format");
}
// load FTL metadata
else
{
load_metadata();
}
g_ftl_read_buf_id = 0;
g_ftl_write_buf_id = 0;
// This example FTL can handle runtime bad block interrupts and read fail (uncorrectable bit errors) interrupts
flash_clear_irq();
SETREG(INTR_MASK, FIRQ_DATA_CORRUPT | FIRQ_BADBLK_L | FIRQ_BADBLK_H);
SETREG(FCONF_PAUSE, FIRQ_DATA_CORRUPT | FIRQ_BADBLK_L | FIRQ_BADBLK_H);
enable_irq();
}
static int __init check_header(void)
{
const char * reason = NULL;
int error;
init_header();
if ((error = read_page(swp_offset(pmdisk_header.pmdisk_info),
&pmdisk_info)))
return error;
/* Is this same machine? */
if ((reason = sanity_check())) {
printk(KERN_ERR "pmdisk: Resume mismatch: %s\n",reason);
return -EPERM;
}
pmdisk_pages = pmdisk_info.image_pages;
return error;
}
std::vector<core::vector3d<u32> > getSupportedVideoModes()
{
IrrlichtDevice *nulldevice = createDevice(video::EDT_NULL);
sanity_check(nulldevice != NULL);
std::vector<core::vector3d<u32> > mlist;
video::IVideoModeList *modelist = nulldevice->getVideoModeList();
u32 num_modes = modelist->getVideoModeCount();
for (u32 i = 0; i != num_modes; i++) {
core::dimension2d<u32> mode_res = modelist->getVideoModeResolution(i);
s32 mode_depth = modelist->getVideoModeDepth(i);
mlist.push_back(core::vector3d<u32>(mode_res.Width, mode_res.Height, mode_depth));
}
nulldevice->drop();
return mlist;
}
int ModApiMainMenu::l_show_file_open_dialog(lua_State *L)
{
GUIEngine* engine = getGuiEngine(L);
sanity_check(engine != NULL);
const char *formname= luaL_checkstring(L, 1);
const char *title = luaL_checkstring(L, 2);
GUIFileSelectMenu* fileOpenMenu =
new GUIFileSelectMenu(engine->m_device->getGUIEnvironment(),
engine->m_parent,
-1,
engine->m_menumanager,
title,
formname);
fileOpenMenu->setTextDest(engine->m_buttonhandler);
fileOpenMenu->drop();
return 0;
}
int ModApiMainMenu::l_set_background(lua_State *L)
{
GUIEngine* engine = getGuiEngine(L);
sanity_check(engine != NULL);
std::string backgroundlevel(luaL_checkstring(L, 1));
std::string texturename(luaL_checkstring(L, 2));
bool tile_image = false;
bool retval = false;
unsigned int minsize = 16;
if (!lua_isnone(L, 3)) {
tile_image = lua_toboolean(L, 3);
}
if (!lua_isnone(L, 4)) {
minsize = lua_tonumber(L, 4);
}
if (backgroundlevel == "background") {
retval |= engine->setTexture(TEX_LAYER_BACKGROUND, texturename,
tile_image, minsize);
}
if (backgroundlevel == "overlay") {
retval |= engine->setTexture(TEX_LAYER_OVERLAY, texturename,
tile_image, minsize);
}
if (backgroundlevel == "header") {
retval |= engine->setTexture(TEX_LAYER_HEADER, texturename,
tile_image, minsize);
}
if (backgroundlevel == "footer") {
retval |= engine->setTexture(TEX_LAYER_FOOTER, texturename,
tile_image, minsize);
}
lua_pushboolean(L,retval);
return 1;
}
/* option_parse(): parse a configuration file
* @opts -> the options struct
* @path -> an absolute pathname to the file
* $return -> 1 on success, 0 otherwise
*
* This is the exported function to allow caller to parse a configuration
* file and populate the provided options structure.
*/
int option_parse(struct options *opts, char *path)
{
journal_strace("option_parse");
FILE *fp;
int i;
if ((fp = fopen(path, "r")) == NULL) {
journal_notice("%s: %s\n", path, strerror(errno));
return 1;
}
for (i = 0; opts[i].tag != NULL; i++)
*(void **)opts[i].value = NULL;
/* XXX This is a proof-of-concept */
switch(parse(opts, fp)) {
case ERR_SYNTAX:
journal_notice("option]> syntax error\n");
fclose(fp);
return ERR_SYNTAX;
case ERR_DUPLICATE:
journal_notice("option]> duplicate\n");
fclose(fp);
return ERR_DUPLICATE;
case ERR_ERRNO:
perror("unexpected error");
fclose(fp);
return ERR_ERRNO;
case ERR_TYPE:
journal_notice("option]> invalid option type\n");
fclose(fp);
return ERR_TYPE;
}
fclose(fp);
return sanity_check(opts);
/* XXX In all error case, option_free() should be call to free() memory */
}
/* option_parse(): parse a configuration file
* @opts -> the options struct
* @path -> an absolute pathname to the file
* $return -> 1 on success, 0 otherwise
*
* This is the exported function to allow caller to parse a configuration
* file and populate the provided options structure.
*/
int option_parse(struct options *opts, char *path)
{
FILE *fp;
int i;
if ((fp = fopen(path, "r")) == NULL) {
jlog(L_NOTICE, "%s: %s", path, strerror(errno));
return 1;
}
for (i = 0; opts[i].tag != NULL; i++)
*(void **)opts[i].value = NULL;
switch(parse(opts, fp)) {
case ERR_SYNTAX:
jlog(L_NOTICE, "option]> syntax error :: %s:%i", __FILE__, __LINE__);
option_free(opts);
fclose(fp);
return ERR_SYNTAX;
case ERR_DUPLICATE:
jlog(L_NOTICE, "option]> duplicate :: %s:%i", __FILE__, __LINE__);
option_free(opts);
fclose(fp);
return ERR_DUPLICATE;
case ERR_ERRNO:
jlog(L_NOTICE, "option]> unexpected error %s :: %s:%i", strerror(errno), __FILE__, __LINE__);
option_free(opts);
fclose(fp);
return ERR_ERRNO;
case ERR_TYPE:
jlog(L_NOTICE, "option]> invalid option type :: %s:%i", __FILE__, __LINE__);
option_free(opts);
fclose(fp);
return ERR_TYPE;
}
fclose(fp);
return sanity_check(opts);
}
static bool read_config_file(const Settings &cmd_args)
{
// Path of configuration file in use
sanity_check(g_settings_path == ""); // Sanity check
if (cmd_args.exists("config")) {
bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
if (!r) {
errorstream << "Could not read configuration from \""
<< cmd_args.get("config") << "\"" << std::endl;
return false;
}
g_settings_path = cmd_args.get("config");
} else {
std::vector<std::string> filenames;
filenames.push_back(porting::path_user + DIR_DELIM + "minetest.conf");
// Legacy configuration file location
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#if RUN_IN_PLACE
// Try also from a lower level (to aid having the same configuration
// for many RUN_IN_PLACE installs)
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#endif
for (size_t i = 0; i < filenames.size(); i++) {
bool r = g_settings->readConfigFile(filenames[i].c_str());
if (r) {
g_settings_path = filenames[i];
break;
}
}
// If no path found, use the first one (menu creates the file)
if (g_settings_path == "")
g_settings_path = filenames[0];
}
return true;
}
int main(int argc, char *argv[]) {
FILE * f_pretty = fopen("pretty.h", "w");
FILE * f_charset = fopen("font.c", "w");
FILE * f_charmap = fopen("charmap.c", "w");
FILE * f_translate = fopen("translate.c", "w");
gen_pretty(f_pretty);
fclose(f_pretty);
gen_charset(f_charset);
fclose(f_charset);
gen_charmap(f_charmap);
fclose(f_charmap);
gen_translate(f_translate);
fclose(f_translate);
return sanity_check();
}
static liAction* core_throttle_pool(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
liThrottlePool *pool = NULL;
gint64 rate, burst;
UNUSED(wrk); UNUSED(p); UNUSED(userdata);
val = li_value_get_single_argument(val);
if (LI_VALUE_NUMBER != li_value_type(val)) {
ERROR(srv, "'io.throttle_pool' action expects a number as parameter, %s given", li_value_type_string(val));
return NULL;
}
rate = val->data.number;
burst = rate;
if (!sanity_check(srv, rate, burst)) return NULL;
pool = li_throttle_pool_new(srv, rate, burst);
return li_action_new_function(core_handle_throttle_pool, NULL, core_throttle_pool_free, pool);
}
static liAction* core_throttle_ip(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
gint64 rate, burst = 0;
guint masklen_ipv4 = 32, masklen_ipv6 = 56;
throttle_ip_pools *pools;
UNUSED(wrk); UNUSED(p); UNUSED(userdata);
val = li_value_get_single_argument(val);
if (LI_VALUE_NUMBER != li_value_type(val)) {
ERROR(srv, "'io.throttle_ip' action expects a positiv integer as parameter, %s given", li_value_type_string(val));
return NULL;
}
rate = val->data.number;
burst = rate;
if (!sanity_check(srv, rate, burst)) return NULL;
pools = ip_pools_new(p->id, rate, burst, masklen_ipv4, masklen_ipv6);
return li_action_new_function(core_handle_throttle_ip, NULL, core_throttle_ip_free, pools);
}
virtual void onSetConstants(video::IMaterialRendererServices *services,
bool is_highlevel)
{
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver);
// set inverted world matrix
core::matrix4 invWorld = driver->getTransform(video::ETS_WORLD);
invWorld.makeInverse();
if(is_highlevel)
services->setVertexShaderConstant("mInvWorld", invWorld.pointer(), 16);
else
services->setVertexShaderConstant(invWorld.pointer(), 0, 4);
// set clip matrix
core::matrix4 worldViewProj;
worldViewProj = driver->getTransform(video::ETS_PROJECTION);
worldViewProj *= driver->getTransform(video::ETS_VIEW);
worldViewProj *= driver->getTransform(video::ETS_WORLD);
if(is_highlevel)
services->setVertexShaderConstant("mWorldViewProj", worldViewProj.pointer(), 16);
else
services->setVertexShaderConstant(worldViewProj.pointer(), 4, 4);
// set transposed world matrix
core::matrix4 transWorld = driver->getTransform(video::ETS_WORLD);
transWorld = transWorld.getTransposed();
if(is_highlevel)
services->setVertexShaderConstant("mTransWorld", transWorld.pointer(), 16);
else
services->setVertexShaderConstant(transWorld.pointer(), 8, 4);
// set world matrix
core::matrix4 world = driver->getTransform(video::ETS_WORLD);
if(is_highlevel)
services->setVertexShaderConstant("mWorld", world.pointer(), 16);
else
services->setVertexShaderConstant(world.pointer(), 8, 4);
}
char *
content_get(char *path, int *content_len)
{
char *resp;
int content_fd, amnt_read = 0;
struct stat s;
#ifdef THINK_TIME
sleep(1);
#endif
/* Bad path? No file? Too large? */
if (sanity_check(path) ||
stat(path, &s) ||
s.st_size > MAX_CONTENT_SZ) goto err;
content_fd = open(path, O_RDONLY);
if (content_fd < 0) goto err;
resp = malloc(s.st_size);
if (!resp) goto err_close;
while (amnt_read < s.st_size) {
int ret = read(content_fd, resp + amnt_read,
s.st_size - amnt_read);
if (ret < 0) goto err_free;
amnt_read += ret;
}
*content_len = s.st_size;
close(content_fd);
return resp;
err_free:
free(resp);
err_close:
close(content_fd);
err:
return error_resp(path, content_len);
}
gboolean
g_hash_table_lookup_extended (GHashTable *hash, gconstpointer key, gpointer *orig_key, gpointer *value)
{
GEqualFunc equal;
Slot *s;
guint hashcode;
g_return_val_if_fail (hash != NULL, FALSE);
sanity_check (hash);
equal = hash->key_equal_func;
hashcode = ((*hash->hash_func) (key)) % hash->table_size;
for (s = hash->table [hashcode]; s != NULL; s = s->next){
if ((*equal)(s->key, key)){
*orig_key = s->key;
*value = s->value;
return TRUE;
}
}
return FALSE;
}
int main(int argc, char * argv[1])
{
/* if a filename is given take it as: "check this db" */
if (argc > 1) {
int i;
verbose = 1;
for (i = 1 ; i < argc ; ++i)
sanity_check(argv[i]);
return 0;
}
remove(TEST_FILENAME);
do_test();
do_speed_test();
if (nr_error)
printf("%d error occured\n", nr_error);
return nr_error ? EXIT_FAILURE : EXIT_SUCCESS;
}
// Get closest extrusion mesh for given image dimensions
// Caller must drop the returned pointer
scene::IMesh* create(core::dimension2d<u32> dim)
{
// handle non-power of two textures inefficiently without cache
if (!is_power_of_two(dim.Width) || !is_power_of_two(dim.Height)) {
return createExtrusionMesh(dim.Width, dim.Height);
}
int maxdim = MYMAX(dim.Width, dim.Height);
std::map<int, scene::IMesh*>::iterator
it = m_extrusion_meshes.lower_bound(maxdim);
if (it == m_extrusion_meshes.end()) {
// no viable resolution found; use largest one
it = m_extrusion_meshes.find(MAX_EXTRUSION_MESH_RESOLUTION);
sanity_check(it != m_extrusion_meshes.end());
}
scene::IMesh *mesh = it->second;
mesh->grab();
return mesh;
}
