static void set_game_filename(const char *name) { n_free(game_filename); game_filename = 0; #if defined(_GNU_SOURCE) game_filename = canonicalize_file_name(name); #else #if defined(_BSD_SOURCE) || defined(_XOPEN_SOURCE) game_filename = (char *) n_malloc(PATH_MAX); if(!realpath(name, game_filename)) { n_free(game_filename); game_filename = 0; } #else #ifdef __DJGPP__ game_filename = (char *) n_malloc(FILENAME_MAX); _fixpath(name, game_filename); #endif #endif #endif if(!game_filename) game_filename = n_strdup(name); }
void init_stack(offset initialstack_stack_size, zword initialframe_size) { n_free(stack_stack); stack_stack = (zword *) n_malloc(sizeof(*stack_stack) * initialstack_stack_size); stack_pointer = 0; stack_min = 0; stack_max = initialstack_stack_size; n_free(stack_frames); stack_frames = (Stack_frame *) n_malloc(sizeof(*stack_frames) * initialframe_size); frame_count = 0; if(stacklimit && initialframe_size > stacklimit) frame_max = stacklimit; else frame_max = initialframe_size; stack_frames[frame_count].stack_stack_start = 0; stack_frames[frame_count].return_PC = 0; stack_frames[frame_count].num_locals = 0; stack_frames[frame_count].arguments = 0; stack_frames[frame_count].result_variable = -2; local_vars = stack_stack + stack_frames[frame_count].stack_stack_start; }
BOOL fast_saveundo(void) { strid_t stack; glui32 stack_size; /* Avoids realloc() in hopes that'll make it a teensy bit faster */ if(automap_undoslot.z_memsize < dynamic_size) { n_free(automap_undoslot.z_mem); automap_undoslot.z_mem = n_malloc(dynamic_size); automap_undoslot.z_memsize = dynamic_size; } n_memcpy(automap_undoslot.z_mem, z_memory, dynamic_size); automap_undoslot.PC = oldPC; automap_undoslot.stacklength = stack_size = get_quetzal_stack_size(); if(automap_undoslot.stackchunksize < stack_size) { free(automap_undoslot.stackchunk); automap_undoslot.stackchunk = (zbyte *) n_malloc(stack_size); automap_undoslot.stackchunksize = stack_size; } stack = glk_stream_open_memory((char *) automap_undoslot.stackchunk, automap_undoslot.stacklength, filemode_Write, 0); if(!stack) return FALSE; if(!quetzal_stack_save(stack)) { glk_stream_close(stack, NULL); return FALSE; } glk_stream_close(stack, NULL); return TRUE; }
bool CMeshShape::LoadFromFile(nMeshLoader& MeshLoader) { n_assert(FileName.IsValid()); n_assert(pVBuffer); n_assert(pIBuffer); // open file and read header data MeshLoader.SetFilename(FileName.Get()); MeshLoader.SetIndexType(nMeshLoader::Index32); if (!MeshLoader.Open()) { n_error("CMeshShape: Failed to open file '%Sphere'!", FileName.Get()); FAIL; } // transfer mesh attributes VertexCount = MeshLoader.GetNumVertices(); IndexCount = MeshLoader.GetNumIndices(); VertexWidth = MeshLoader.GetVertexWidth(); // allocate vertex and index buffer int VBSize = MeshLoader.GetNumVertices() * MeshLoader.GetVertexWidth() * sizeof(float); int IBSize = MeshLoader.GetNumIndices() * sizeof(uint); pVBuffer = (float*)n_malloc(VBSize); pIBuffer = (int*)n_malloc(IBSize); // read vertices and indices MeshLoader.ReadVertices(pVBuffer, VBSize); MeshLoader.ReadIndices(pIBuffer, IBSize); // close mesh loader MeshLoader.Close(); OK; }
void mymap_init(int width, int height) { int i; int max; mapwidth = width * 2; mapheight = height * 2; max = mapwidth * mapheight; n_free(mymap); n_free(mymapnode); mymap = (char *) n_malloc(max); mymapnode = (loc_node **) n_malloc(max * sizeof(*mymapnode)); for(i = 0; i < max; i++) { mymap[i] = ' '; mymapnode[i] = NULL; } }
bool CDataServer::CopyFile(const nString& SrcPath, const nString& DestPath) { //???mangle here for perf reasons? if (IsFileReadOnly(DestPath)) SetFileReadOnly(DestPath, false); CFileStream Src, Dest; if (!Src.Open(SrcPath, SAM_READ, SAP_SEQUENTIAL)) FAIL; if (!Dest.Open(DestPath, SAM_WRITE, SAP_SEQUENTIAL)) { Src.Close(); FAIL; } int Size = Src.GetSize(); char* pBuffer = (char*)n_malloc(Size); int RealSize = Src.Read(pBuffer, Size); n_assert(RealSize == Size); Src.Close(); RealSize = Dest.Write(pBuffer, Size); n_assert(RealSize == Size); Dest.Close(); n_free(pBuffer); OK; }
/* Stolen from su for GNU. Copyright (C) 1992-2004 Free Software Foundation, Inc. License: GPL v2 or later. */ static void modify_environment(const struct passwd *pw) { char *term; char *display; char *path; term = getenv("TERM"); display = getenv("DISPLAY"); path = getenv("PATH"); #if HAVE_CLEARENV clearenv(); #else extern char **environ; environ = n_malloc(2 * sizeof (char *)); environ[0] = 0; #endif if (term) do_putenv("TERM", term); if (display) do_putenv("DISPLAY", display); if (path) do_putenv("PATH", path); do_putenv("HOME", pw->pw_dir); do_putenv("SHELL", pw->pw_shell); do_putenv("USER", pw->pw_name); do_putenv("LOGNAME", pw->pw_name); }
static char *parse_cmdl_pathspec(const char *pathspec, const char **path) { const char *p; char *type; int len, seplen = 1; p = pathspec; while (isalnum(*p)) p++; if (p == pathspec) return NULL; if (*p != '#' && (seplen = strspn(p, ",")) != 2) return NULL; len = p - pathspec + 1; type = n_malloc(len); memcpy(type, pathspec, len - 1); type[len - 1] = '\0'; *path = p + seplen; return type; }
static error_t parse_opt(int key, char *arg, struct argp_state *state) { struct poclidek_opgroup_rt *rt; struct arg_s *arg_s; rt = state->input; if (rt->_opdata) { arg_s = rt->_opdata; } else { arg_s = n_malloc(sizeof(*arg_s)); arg_s->cnflags = 0; arg_s->size = arg_s->first_free_space = 0; arg_s->prefix = NULL; rt->_opdata = arg_s; rt->_opdata_free = arg_s_free; rt->run = oprun; } switch (key) { case OPT_SPLITSIZE: { char *p; int rc; if ((p = strrchr(arg, ':'))) { rc = sscanf(arg, "%d:%d", &arg_s->size, &arg_s->first_free_space); rc = (rc == 2); } else { rc = sscanf(arg, "%d", &arg_s->size); rc = (rc == 1); } if (rc) arg_s->cnflags |= DO_SPLIT; else { logn(LOGERR, _("split: bad option argument")); exit(EXIT_FAILURE); } } break; case OPT_SPLITCONF: poldek_configure(rt->ctx, POLDEK_CONF_PRIFILE, arg); break; case OPT_SPLITPREFIX: arg_s->prefix = n_strdup(arg); break; default: return ARGP_ERR_UNKNOWN; } return 0; }
tn_array *capreq_arr_restore(tn_alloc *na, tn_buf *nbuf) { struct capreq *cr; tn_buf_it nbufi; int16_t arr_size; void **cr_buf; register int i, n; n_buf_it_init(&nbufi, nbuf); n_buf_it_get_int16(&nbufi, &arr_size); DBGF("%d, arr_size = %d\n", n_buf_size(nbuf), arr_size); //cr_buf = alloca(arr_size * sizeof(void*)); cr_buf = n_malloc(arr_size * sizeof(void*)); n = 0; for (i=0; i < arr_size; i++) { if ((cr = capreq_restore(na, &nbufi))) { if (capreq_is_bastard(cr)) continue; cr_buf[n++] = cr; } } if (n == 0) { free(cr_buf); return NULL; } //arr = capreq_arr_new_ex(n, n_memdup(cr_buf, n * sizeof(void*))); return capreq_arr_new_ex(n, cr_buf); }
static char *recode(const char *val, const char *valencoding) { char *p, *val_utf8, *usrencoding, *tmpval; size_t vlen, u_vlen, tmpvlen; iconv_t cd; usrencoding = nl_langinfo(CODESET); if (usrencoding == NULL) return (char*)val; valencoding = "UTF-8"; /* XXX, support for others needed? */ vlen = u_vlen = tmpvlen = strlen(val); p = val_utf8 = n_malloc(u_vlen + 1); /* FIXME: iconv leave val content untouched */ tmpval = (char*) val; cd = iconv_open(usrencoding, valencoding); if (iconv(cd, &tmpval, &tmpvlen, &p, &u_vlen) == (size_t)-1) { iconv_close(cd); free(val_utf8); return (char*)val; } iconv_close(cd); n_assert(p <= val_utf8 + vlen); *p = '\0'; return val_utf8; }
void init_undo(void) { kill_undo(); prevstate = (zbyte *) n_malloc(dynamic_size); n_memcpy(prevstate, z_memory, dynamic_size); }
struct iset *iset_new(void) { struct iset *iset; iset = n_malloc(sizeof(*iset)); iset->pkgs = pkgs_array_new(128); iset->pkgs_by_recno = pkgs_array_new_ex(128, pkg_cmp_recno); iset->capcache = n_hash_new(128, NULL); iset->pms = pkgmark_set_new(0, 0); return iset; }
strid_t startup_findfile(void) { static DIR *dir = NULL; static char *pathstart = NULL; static char *path = NULL; strid_t stream; struct dirent *d; char *name = NULL; if(!pathstart) { char *p = search_path; if(!p) return 0; pathstart = n_strdup(p); if(!(path = n_strtok(pathstart, ":"))) { n_free(pathstart); pathstart = 0; return 0; } } do { if(!dir) { dir = opendir(path); if(!dir) { n_free(pathstart); pathstart = 0; return 0; } } d = readdir(dir); if(!d) { closedir(dir); dir = NULL; if(!(path = n_strtok(NULL, ":"))) { n_free(pathstart); pathstart = 0; return 0; } } } while(!dir); name = (char *) n_malloc(n_strlen(path) + n_strlen(d->d_name) + 2); n_strcpy(name, path); n_strcat(name, "/"); n_strcat(name, d->d_name); stream = glkunix_stream_open_pathname(name, fileusage_Data | fileusage_BinaryMode, 0); if(stream) set_game_filename(name); n_free(name); return stream; }
struct poclidek_rcmd *poclidek_rcmd_new(struct poclidek_ctx *cctx, struct poldek_ts *ts) { struct poclidek_rcmd *rcmd = n_malloc(sizeof(*rcmd)); rcmd->_flags = 0; rcmd->_cctx = cctx; rcmd->_ts = ts; rcmd->rpkgs = NULL; rcmd->rbuf = NULL; rcmd->rc = -1; return rcmd; }
static struct pkg_unreq *pkg_unreq_new(struct capreq *req, int mismatch) { struct pkg_unreq *unreq; char s[512]; int n; n = capreq_snprintf(s, sizeof(s), req); unreq = n_malloc(sizeof(*unreq) + n + 1); unreq->mismatch = mismatch; memcpy(unreq->req, s, n + 1); return unreq; }
static edge *automap_new_edge(loc_node *src, loc_node *dest, BOOL is_oneway) { edgelist newedge; newedge.node = n_malloc(sizeof(edge)); newedge.node->dest[0] = src; newedge.node->dest[1] = dest; newedge.node->is_oneway = is_oneway; newedge.node->touched = FALSE; newedge.node->min_length = is_oneway ? 4 : 2; newedge.node->guess_length = is_oneway ? 4 : 2; LEadd(all_edges, newedge); return newedge.node; }
static void do_putenv(const char *var, const char *val) { #ifdef HAVE_SETENV setenv(var, val, 1); #else { int len = strlen(var) + strlen(val) + 3; char *tmp = n_malloc(len); n_snprintf(tmp, len, "%s=%s", var, val); putenv(tmp); } #endif }
/* Allocate and initialise a chunk of memory. */ static inline void *n_malloc_null(int size, const char *file, int line) { #ifdef DEBUG_MEM # define nmalloc_null(size) n_malloc_null(size, __FILE__, __LINE__) void *ptr = n_malloc(size, file, line); #else # define nmalloc_null(size) n_malloc_null(size, NULL, 0) void *ptr = nmalloc(size); #endif egg_memset(ptr, 0, size); return ptr; }
/* This helps the memory debugging */ void *_get_data_ptr(int size, char *file, int line) { char *p; #ifdef DEBUG_MEM char x[1024]; p = strrchr(file, '/'); egg_snprintf(x, sizeof x, "dccutil.c:%s", p ? p + 1 : file); p = n_malloc(size, x, line); #else p = nmalloc(size); #endif egg_bzero(p, size); return p; }
static void args_init(struct poclidek_ctx *cctx, struct poldek_ts *ts, int argc, char **argv, int mode) { memset(&args, 0, sizeof(args)); args.ctx = cctx->ctx; args.cctx = cctx; args.argc = 0; args.argv = n_malloc(sizeof(*argv) * argc); args.argv[0] = NULL; args.mode = mode; args.ts = ts; args.opctx = poclidek_op_ctx_new(); }
static struct poclidek_cmd *command_new_alias(const char *name, const char *cmdline) { struct poclidek_cmd *alias; alias = n_malloc(sizeof(*alias)); memset(alias, 0, sizeof(*alias)); alias->flags = COMMAND_IS_ALIAS | COMMAND__MALLOCED; alias->name = n_strdup(name); alias->cmdline = n_strdup(cmdline); alias->aliasto = NULL; alias->_free = free_alias; if (strchr(alias->cmdline, '%')) alias->flags |= COMMAND_PARAMETERIZED; return alias; }
static inline struct capreq *capreq_malloc(tn_alloc *na, int size) { struct capreq *cr; n_assert(size < UINT8_MAX); if (na) { cr = na->na_malloc(na, sizeof(*cr) + size + 1); cr->cr_relflags = __NAALLOC; } else { cr = n_malloc(sizeof(*cr) + size + 1); cr->cr_relflags = 0; } cr->_buf[size] = '\0'; return cr; }
struct pm_ctx *pm_new(const char *name) { struct pm_ctx *ctx; const struct pm_module *mod; void *modh; if ((mod = pm_module_find(name)) == NULL) return NULL; if ((modh = mod->init()) == NULL) return NULL; ctx = n_malloc(sizeof(*ctx)); ctx->mod = mod; ctx->modh = modh; return ctx; }
tn_tuple *n_tuple_new(tn_alloc *na, int size, void **data) { tn_tuple *tu; n_assert(size < UINT16_MAX); if (na) tu = na->na_malloc(na, sizeof(*tu) + (size * sizeof(void*))); else tu = n_malloc(sizeof(*tu) + (size * sizeof(void*))); tu->_refcnt = 0; tu->size = size; if (data) memcpy(tu->data, data, size * sizeof(void*)); else if (size) memset(tu->data, 0, size * sizeof(void*)); return tu; }
strid_t startup_open(const char *name) { strid_t str; char *s; str = glkunix_stream_open_pathname((char *) name, fileusage_Data | fileusage_BinaryMode, 0); if(str) { set_game_filename(name); #ifdef USE_GARGLK_FEATURES s = strrchr(name, '\\'); if (!s) s = strrchr(name, '/'); garglk_set_story_name(s ? s + 1 : name); #endif } else { char *path = search_path; if(path) { char *p; char *newname = (char *) n_malloc(strlen(path) + strlen(name) + 2); path = n_strdup(path); for(p = n_strtok(path, ":"); p; p = n_strtok(NULL, ":")) { n_strcpy(newname, p); n_strcat(newname, "/"); n_strcat(newname, name); str = glkunix_stream_open_pathname((char *) newname, fileusage_Data | fileusage_BinaryMode, 0); if(str) { set_game_filename(newname); #ifdef USE_GARGLK_FEATURES s = strrchr(newname, '\\'); if (!s) s = strrchr(newname, '/'); garglk_set_story_name(s ? s + 1 : newname); #endif break; } } n_free(path); } } if(!str) fprintf(stderr, "Cannot open '%s'\n", name); return str; }
struct capreq *capreq_clone(tn_alloc *na, const struct capreq *cr) { uint8_t size; struct capreq *newcr; size = capreq_sizeof(cr); if (na) newcr = na->na_malloc(na, size); else newcr = n_malloc(size); memcpy(newcr, cr, size); if (na) newcr->cr_relflags |= __NAALLOC; else newcr->cr_relflags &= ~(__NAALLOC); return newcr; }
struct source *source_malloc(void) { struct source *src; src = n_malloc(sizeof(*src)); memset(src, '\0', sizeof(*src)); src->type = src->original_type = NULL; src->flags = src->subopt_flags = 0; src->pri = 0; src->no = 0; //src->flags |= PKGSOURCE_PRI; src->name = src->path = src->pkg_prefix = NULL; src->dscr = src->type = NULL; src->lc_lang = NULL; src->_refcnt = 0; src->exclude_path = n_array_new(4, free, (tn_fn_cmp)strcmp); src->ign_patterns = n_array_new(4, free, (tn_fn_cmp)strcmp); return src; }
static int posthook_diff(struct pkgdir *pd1, struct pkgdir* pd2, struct pkgdir *diff) { struct pndir *idx, *idx2; pd2 = pd2; /* unused */ if ((idx2 = pd1->mod_data) == NULL) return 0; idx = diff->mod_data; if (idx == NULL) { idx = n_malloc(sizeof(*idx)); pndir_init(idx); diff->mod_data = idx; } idx->md_orig = n_strdup(idx2->dg->md); return 1; }
DWORD CDataServer::LoadFileToBuffer(const nString& FileName, char*& Buffer) { CFileStream File; int BytesRead; if (File.Open(FileName, SAM_READ, SAP_SEQUENTIAL)) { int FileSize = File.GetSize(); Buffer = (char*)n_malloc(FileSize); BytesRead = File.Read(Buffer, FileSize); File.Close(); } else { Buffer = NULL; BytesRead = 0; } return BytesRead; }