/* * Read something back in from swap. Return the size. * blockp - a pointer to what will hold the block read in * loc - position in the swap file to read from */ static int swap_in(char ** blockp, int loc) { int size; DEBUG_CHECK(!blockp, "blockp null in swap_in()\n"); if (loc == -1) return 0; swap_seek(loc, 0); #ifdef SWAP_USE_FD /* find out size */ if (read(swap_file, &size, sizeof size) == -1) fatal("Couldn't read the swap file.\n"); DEBUG_CHECK(size <= 0, "Illegal size read from swap file.\n"); *blockp = DXALLOC(size, TAG_SWAP, "swap_in"); if (read(swap_file, *blockp, size) == -1) fatal("Couldn't read the swap file.\n"); #else /* find out size */ if (fread((char *) &size, sizeof size, 1, swap_file) == -1) fatal("Couldn't read the swap file.\n"); DEBUG_CHECK(size <= 0, "Illegal size read from swap file.\n"); *blockp = DXALLOC(size, TAG_SWAP, "swap_in"); if (fread(*blockp, size, 1, swap_file) == -1) fatal("Couldn't read the swap file.\n"); #endif total_bytes_swapped -= size; return size; }
char *int_string_unlink P1(char *, str) #endif { malloc_block_t *mbt, *newmbt; mbt = ((malloc_block_t *)str) - 1; mbt->ref--; if (mbt->size == USHRT_MAX) { int l = strlen(str + USHRT_MAX) + USHRT_MAX; /* ouch */ newmbt = (malloc_block_t *)DXALLOC(l + sizeof(malloc_block_t) + 1, TAG_MALLOC_STRING, desc); memcpy((char *)(newmbt + 1), (char *)(mbt + 1), l+1); newmbt->size = USHRT_MAX; ADD_NEW_STRING(USHRT_MAX, sizeof(malloc_block_t)); } else { newmbt = (malloc_block_t *)DXALLOC(mbt->size + sizeof(malloc_block_t) + 1, TAG_MALLOC_STRING, desc); memcpy((char *)(newmbt + 1), (char *)(mbt + 1), mbt->size+1); newmbt->size = mbt->size; ADD_NEW_STRING(mbt->size, sizeof(malloc_block_t)); } newmbt->ref = 1; CHECK_STRING_STATS; return (char *)(newmbt + 1); }
static void add_define (const char * name, int nargs, const char * exps) { defn_t *p = lookup_definition(name); int h, len; /* trim off leading and trailing whitespace */ while (uisspace(*exps)) exps++; for (len = strlen(exps); len && uisspace(exps[len - 1]); len--); if (*exps == '#' && *(exps + 1) == '#') { yyerror("'##' at start of macro definition"); return; } if (len > 2 && *(exps + len - 2) == '#' && *(exps + len - 1) == '#') { yyerror("'##' at end of macro definition"); return; } if (p) { if (p->flags & DEF_IS_UNDEFINED) { p->exps = (char *)DREALLOC(p->exps, len + 1, TAG_COMPILER, "add_define: redef"); memcpy(p->exps, exps, len); p->exps[len] = 0; p->flags = 0; p->nargs = nargs; } else { if (p->flags & DEF_IS_PREDEF) { yyerror("Illegal to redefine predefined value."); return; } if (nargs != p->nargs || strcmp(exps, p->exps)) { char buf[200 + NSIZE]; sprintf(buf, "redefinition of #define %s\n", name); yywarn(buf); p->exps = (char *)DREALLOC(p->exps, len + 1, TAG_COMPILER, "add_define: redef"); memcpy(p->exps, exps, len); p->exps[len] = 0; p->nargs = nargs; } #ifndef LEXER p->flags &= ~DEF_IS_NOT_LOCAL; #endif } } else { p = ALLOCATE(defn_t, TAG_COMPILER, "add_define: def"); p->name = (char *) DXALLOC(strlen(name) + 1, TAG_COMPILER, "add_define: def name"); strcpy(p->name, name); p->exps = (char *) DXALLOC(len + 1, TAG_COMPILER, "add_define: def exps"); memcpy(p->exps, exps, len); p->exps[len] = 0; p->flags = 0; p->nargs = nargs; h = defhash(name); p->next = defns[h]; defns[h] = p; } }
void f_compress (void) { unsigned char* buffer; unsigned char* input; int size; buffer_t* real_buffer; uLongf new_size; if (sp->type == T_STRING) { size = SVALUE_STRLEN(sp); input = (unsigned char*)sp->u.string; } else if (sp->type == T_BUFFER) { size = sp->u.buf->size; input = sp->u.buf->item; } else { pop_n_elems(st_num_arg); push_undefined(); return ; } new_size = size; // Make it a little larger as specified in the docs. buffer = (unsigned char*)DXALLOC(size * 101 / 100 + 12, TAG_TEMPORARY, "compress"); compress(buffer, &new_size, input, size); // Shrink it down. pop_n_elems(st_num_arg); real_buffer = allocate_buffer(new_size); write_buffer(real_buffer, 0, (char *)buffer, new_size); FREE(buffer); push_buffer(real_buffer); }
static void s_Enlarge() { int n = s_handleCount + 512; int first = s_handleCount; int last; int i; HandleData *handle = NULL; /* Make compiler happy */ if (s_handleTable == NULL) { s_handleTable = DXALLOC((size_t)n * sizeof(HandleData)); first = s_handleCount + 1; /* Reserve the first handle. */ } else { s_handleTable = DXREALLOC(s_handleTable, (size_t)n * sizeof(HandleData)); } s_handleCount = n; last = -1; for (i = n - 1; i >= first; --i) { handle = &s_handleTable[i]; handle->data = NULL; handle->handleType = DXHANDLE_NONE; handle->nextID = last; handle->prevID = i - 1; last = i; } handle->prevID = -1; s_handleLists[DXHANDLE_NONE] = first; }
int Dx_File_ReadFile(const char *filename, unsigned char **dData, unsigned int *dSize) { unsigned char *data; unsigned int size; int retval; SDL_RWops *rwops = Dx_File_OpenStream(filename); if (rwops == NULL) { return -1; } size = (unsigned int)SDL_RWsize(rwops); retval = 0; data = DXALLOC(size); if (SDL_RWread(rwops, data, size, 1) < 1) { retval = -1; DXFREE(data); } else { *dData = data; *dSize = size; } SDL_RWclose(rwops); return retval; }
/* ------------------------------------------------------------ PUBLIC INTERFACE */ int Dx_File_EXTSetDXArchiveAlias(const char *srcName, const char *destName) { ArchiveAliasEntry **pEntry = &s_archiveAliases; while (*pEntry != NULL) { if (PL_Text_Strcmp((*pEntry)->srcArchiveName, srcName) == 0) { DXFREE((*pEntry)->destArchiveName); if (destName == NULL) { ArchiveAliasEntry *next = (*pEntry)->next; DXFREE((*pEntry)->srcArchiveName); DXFREE(*pEntry); *pEntry = next; } else { (*pEntry)->destArchiveName = PL_Text_Strdup(destName); } return 0; } pEntry = &(*pEntry)->next; } if (srcName == NULL || destName == NULL) { return 0; } *pEntry = DXALLOC(sizeof(ArchiveAliasEntry)); (*pEntry)->srcArchiveName = PL_Text_Strdup(srcName); (*pEntry)->destArchiveName = PL_Text_Strdup(destName); (*pEntry)->next = NULL; return 0; }
void c_anonymous(int num_arg, int num_local, POINTER_INT func) { funptr_t *fp; fp = (funptr_t *)DXALLOC(sizeof(funptr_hdr_t) + sizeof(functional_t), TAG_FUNP, "c_functional"); fp->hdr.owner = current_object; add_ref( current_object, "c_functional" ); if (num_arg & 0x10000) fp->hdr.type = FP_FUNCTIONAL | FP_NOT_BINDABLE; else fp->hdr.type = FP_FUNCTIONAL; current_prog->func_ref++; fp->f.functional.prog = current_prog; fp->f.functional.offset = func; fp->f.functional.num_arg = num_arg & 0xff; fp->f.functional.num_local = num_local; fp->f.functional.fio = function_index_offset; fp->f.functional.vio = variable_index_offset; fp->hdr.args = 0; fp->hdr.ref = 1; STACK_INC; sp->type = T_FUNCTION; sp->u.fp = fp; }
void c_functional(int kind, int num_arg, POINTER_INT func) { funptr_t *fp; fp = (funptr_t *)DXALLOC(sizeof(funptr_hdr_t) + sizeof(functional_t), TAG_FUNP, "c_functional"); fp->hdr.owner = current_object; add_ref( current_object, "c_functional" ); fp->hdr.type = kind; current_prog->func_ref++; fp->f.functional.prog = current_prog; fp->f.functional.offset = func; fp->f.functional.num_arg = num_arg; fp->f.functional.num_local = 0; fp->f.functional.fio = function_index_offset; fp->f.functional.vio = variable_index_offset; if (sp->type == T_ARRAY) { fp->hdr.args = sp->u.arr; fp->f.functional.num_arg += sp->u.arr->size; } else fp->hdr.args = 0; fp->hdr.ref = 1; sp->type = T_FUNCTION; sp->u.fp = fp; }
INLINE funptr_t * make_lfun_funp (int index, svalue_t * args) { funptr_t *fp; int newindex; if (replace_program_pending(current_object)) error("cannot bind an lfun fp to an object with a pending replace_program()\n"); fp = (funptr_t *)DXALLOC(sizeof(funptr_hdr_t) + sizeof(local_ptr_t), TAG_FUNP, "make_lfun_funp"); fp->hdr.owner = current_object; add_ref( current_object, "make_lfun_funp" ); fp->hdr.type = FP_LOCAL | FP_NOT_BINDABLE; fp->hdr.owner->prog->func_ref++; debug(d_flag, ("add func ref /%s: now %i\n", fp->hdr.owner->prog->filename, fp->hdr.owner->prog->func_ref)); newindex = index + function_index_offset; if (current_object->prog->function_flags[newindex] & FUNC_ALIAS) newindex = current_object->prog->function_flags[newindex] & ~FUNC_ALIAS; fp->f.local.index = newindex; if (args->type == T_ARRAY) { fp->hdr.args = args->u.arr; args->u.arr->ref++; } else fp->hdr.args = 0; fp->hdr.ref = 1; return fp; }
char *int_new_string (int size) #endif { malloc_block_t *mbt; #if 0 if (!size) { the_null_string_blocks[0].ref++; ADD_NEW_STRING(0, sizeof(malloc_block_t)); return the_null_string; } #endif mbt = (malloc_block_t *)DXALLOC(size + sizeof(malloc_block_t) + 1, TAG_MALLOC_STRING, tag); if (size < USHRT_MAX) { mbt->size = size; ADD_NEW_STRING(size, sizeof(malloc_block_t)); } else { mbt->size = USHRT_MAX; ADD_NEW_STRING(USHRT_MAX, sizeof(malloc_block_t)); } mbt->ref = 1; ADD_STRING(mbt->size); CHECK_STRING_STATS; return (char *)(mbt + 1); }
char *int_alloc_cstring (const char * str) #endif { char *ret; ret = (char *)DXALLOC(strlen(str) + 1, TAG_STRING, tag); strcpy(ret, str); return ret; }
array_t *allocate_empty_class_by_size(int size) { array_t *p; p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (size - 1), TAG_CLASS, "allocate_class"); p->ref = 1; p->size = size; return p; }
static void add_define P3(char *, name, int, nargs, char *, exps) { defn_t *p = lookup_definition(name); int h; if (p) { if (p->flags & DEF_IS_UNDEFINED) { p->exps = (char *)DREALLOC(p->exps, strlen(exps) + 1, TAG_COMPILER, "add_define: redef"); strcpy(p->exps, exps); p->flags = 0; p->nargs = nargs; } else { if (p->flags & DEF_IS_PREDEF) { yyerror("Illegal to redefine predefined value."); return; } if (nargs != p->nargs || strcmp(exps, p->exps)) { char buf[200 + NSIZE]; sprintf(buf, "redefinition of #define %s\n", name); yywarn(buf); p->exps = (char *)DREALLOC(p->exps, strlen(exps) + 1, TAG_COMPILER, "add_define: redef"); strcpy(p->exps, exps); p->nargs = nargs; } #ifndef LEXER p->flags &= ~DEF_IS_NOT_LOCAL; #endif } } else { p = ALLOCATE(defn_t, TAG_COMPILER, "add_define: def"); p->name = (char *) DXALLOC(strlen(name) + 1, TAG_COMPILER, "add_define: def name"); strcpy(p->name, name); p->exps = (char *) DXALLOC(strlen(exps) + 1, TAG_COMPILER, "add_define: def exps"); strcpy(p->exps, exps); p->flags = 0; p->nargs = nargs; h = defhash(name); p->next = defns[h]; defns[h] = p; } }
/* * Free up a chunk of swap space, coalescing free blocks if necessary. * * Todo - think about tradeoff of storing the free block * info in the swap file itself. */ static void free_swap(int start, int length) { sw_block_t *m, *ptr, *prev; length += sizeof(int); /* extend with size of hidden information */ /* * Construct and insert new free block */ m = (sw_block_t *) DXALLOC(sizeof(sw_block_t), TAG_SWAP, "free_swap"); m->start = start; m->length = length; for (ptr = swap_free, prev = 0; ptr; prev = ptr, ptr = ptr->next) { if (start < ptr->start) break; } if (!prev) { swap_free = m; } else { prev->next = m; } m->next = ptr; /* * Combine adjacent blocks */ if (ptr && m->start + m->length == ptr->start) { m->length += ptr->length; m->next = ptr->next; FREE(ptr); } if (prev && prev->start + prev->length == m->start) { prev->length += m->length; prev->next = m->next; FREE(m); m = prev; } /* * There is an implicit infinite block at the end making life hard Can't * do this earlier, since m and prev could have combined, so prev must be * found again (or use doubly linked list, etc). */ if (m->start + m->length == last_data) { DEBUG_CHECK(m->next, "extraneous free swap blocks!\n"); /* find prev pointer again *sigh* */ for (ptr = swap_free, prev = 0; ptr != m; prev = ptr, ptr = ptr->next); last_data = m->start; FREE(m); if (!prev) swap_free = 0; else prev->next = 0; } }
array_t *allocate_class P1(class_def_t *, cld) { array_t *p; int n = cld->size; p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (n - 1), TAG_CLASS, "allocate_class"); p->ref = 1; p->size = n; while (n--) p->item[n] = const0; return p; }
array_t *allocate_class_by_size(int size) { array_t *p; p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (size - 1), TAG_CLASS, "allocate_class"); p->ref = 1; p->size = size; while (size--) p->item[size] = const0; return p; }
void *PL_Handle_AllocateData(int handleID, size_t dataSize) { HandleData *handle; if (handleID < 0 || handleID >= s_handleCount) { return NULL; } handle = &s_handleTable[handleID]; handle->data = DXALLOC((size_t)dataSize); return handle->data; }
array_t *allocate_empty_class_by_size (int size) { array_t *p; #ifdef CLASS_STATS num_classes++; total_class_size += sizeof(array_t) + sizeof(svalue_t) * (size - 1); #endif p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (size - 1), TAG_CLASS, "allocate_class"); p->ref = 1; p->size = size; return p; }
array_t *allocate_class(class_def_t * cld, int has_values) { array_t *p; int n = cld->size; p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (n - 1), TAG_CLASS, "allocate_class"); p->ref = 1; p->size = n; if (has_values) { while (n--) p->item[n] = *sp--; } else { while (n--) p->item[n] = const0; } return p; }
INLINE funptr_t * make_simul_funp (int index, svalue_t * args) { funptr_t *fp; fp = (funptr_t *)DXALLOC(sizeof(funptr_hdr_t) + sizeof(simul_ptr_t), TAG_FUNP, "make_simul_funp"); fp->hdr.owner = current_object; add_ref( current_object, "make_simul_funp" ); fp->hdr.type = FP_SIMUL; fp->f.simul.index = index; if (args->type == T_ARRAY) { fp->hdr.args = args->u.arr; args->u.arr->ref++; } else fp->hdr.args = 0; fp->hdr.ref = 1; return fp; }
INLINE funptr_t * make_efun_funp (int opcode, svalue_t * args) { funptr_t *fp; fp = (funptr_t *)DXALLOC(sizeof(funptr_t), TAG_FUNP, "make_efun_funp"); fp->hdr.owner = current_object; add_ref( current_object, "make_efun_funp" ); fp->hdr.type = FP_EFUN; fp->f.efun.index = opcode; if (args->type == T_ARRAY) { fp->hdr.args = args->u.arr; args->u.arr->ref++; } else fp->hdr.args = 0; fp->hdr.ref = 1; return fp; }
INLINE_STATIC block_t * alloc_new_string (const char * string, int h) { block_t *b; int len = strlen(string); int size; if (len > max_string_length) { len = max_string_length; } size = sizeof(block_t) + len + 1; b = (block_t *) DXALLOC(size, TAG_SHARED_STRING, "alloc_new_string"); strncpy(STRING(b), string, len); STRING(b)[len] = '\0'; /* strncpy doesn't put on \0 if 'from' too * long */ SIZE(b) = (len > USHRT_MAX ? USHRT_MAX : len); REFS(b) = 1; NEXT(b) = base_table[h]; base_table[h] = b; ADD_NEW_STRING(SIZE(b), sizeof(block_t)); ADD_STRING(SIZE(b)); return (b); }
INLINE funptr_t * make_functional_funp (short num_arg, short num_local, short len, svalue_t * args, int flag) { funptr_t *fp; if (replace_program_pending(current_object)) error("cannot bind a functional to an object with a pending replace_program()\n"); fp = (funptr_t *)DXALLOC(sizeof(funptr_hdr_t) + sizeof(functional_t), TAG_FUNP, "make_functional_funp"); fp->hdr.owner = current_object; add_ref( current_object, "make_functional_funp" ); fp->hdr.type = FP_FUNCTIONAL + flag; current_prog->func_ref++; debug(d_flag, ("add func ref /%s: now %i\n", current_prog->filename, current_prog->func_ref)); fp->f.functional.prog = current_prog; fp->f.functional.offset = pc - current_prog->program; fp->f.functional.num_arg = num_arg; fp->f.functional.num_local = num_local; fp->f.functional.fio = function_index_offset; fp->f.functional.vio = variable_index_offset; pc += len; if (args && args->type == T_ARRAY) { fp->hdr.args = args->u.arr; args->u.arr->ref++; fp->f.functional.num_arg += args->u.arr->size; } else fp->hdr.args = 0; fp->hdr.ref = 1; return fp; }
static DXArchive *s_GetArchive(const char *filename) { /* - Check to see if this archive is already open first. */ DXArchive *archive; ArchiveListEntry *entry; for (entry = s_archiveList; entry != NULL; entry = entry->next) { if (!PL_Text_Strcmp(entry->filename, filename)) { return entry->archive; } } /* - Since it isn't, try to load it up. */ archive = DXA_OpenArchive(filename, s_defaultArchiveString); if (archive != NULL) { /* - On success, add to the open list. */ entry = DXALLOC(sizeof(ArchiveListEntry)); entry->archive = archive; entry->filename = PL_Text_Strdup(filename); entry->next = s_archiveList; s_archiveList = entry; } return archive; }
array_t *allocate_class (class_def_t * cld, int has_values) { array_t *p; int n = cld->size; if(!n) n++; #ifdef CLASS_STATS num_classes++; total_class_size += sizeof(array_t) + sizeof(svalue_t) * (n - 1); #endif p = (array_t *)DXALLOC(sizeof(array_t) + sizeof(svalue_t) * (n - 1), TAG_CLASS, "allocate_class"); n = cld->size; p->ref = 1; p->size = n; if (has_values) { while (n--) p->item[n] = *sp--; } else { while (n--) p->item[n] = const0; } return p; }
LFONTSPRITE LunaFontSprite::CreateFromFile(const char *pFileName, const char *pExt, Bool IsAlpha, Uint32 Num, Bool IsSortZ, eSurfaceFormat Format) { char filebuf[4096]; int file = PL_File_OpenRead( PL_Text_ConvertStrncpyIfNecessary( filebuf, -1, pFileName, g_lunaUseCharSet, 4096) ); unsigned char *lfdData = NULL; do { int64_t fileSize = PL_File_GetSize(file); const LFDHeader *lfdHeader; LunaFontSprData *fontspr; int fontSprHandle; int fontBaseSize; int i; /* don't allow files beyond a certain size */ if (file < 0 || fileSize <= 0 || fileSize > 65536) { break; } lfdData = (unsigned char *)DXALLOC((int)fileSize); if (PL_File_Read(file, lfdData, (int)fileSize) != (int)fileSize) { break; } PL_File_Close(file); file = -1; /* sanity checks to verify LFD data is valid */ lfdHeader = (const LFDHeader *)lfdData; if (memcmp(lfdHeader, lfd_id, 4) != 0 || lfdHeader->sheetCount == 0 || lfdHeader->sheetCount > 32) { break; } fontBaseSize = sizeof(LFDHeader) + (sizeof(Uint16) * CODE_TABLE_SIZE) + (32 * lfdHeader->sheetCount); if (fileSize < (int64_t)(fontBaseSize + (sizeof(LFDCharEntry) * lfdHeader->fontMax))) { break; } /* create sprite handle and data */ fontSprHandle = PL_Handle_AcquireID(DXHANDLE_LUNAFONTSPRITE); if (fontSprHandle < 0) { break; } fontspr = (LunaFontSprData *)PL_Handle_AllocateData(fontSprHandle, sizeof(LunaFontSprData)); fontspr->lfdData = lfdData; fontspr->lfdHeader = lfdHeader; fontspr->lfdIndex = (const Uint16 *)(lfdData + sizeof(LFDHeader)); fontspr->lfdCharEntries = (const LFDCharEntry *)(lfdData + fontBaseSize); fontspr->charMax = lfdHeader->fontMax; fontspr->sheetCount = lfdHeader->sheetCount; fontspr->sheetGraphs = (int *)DXALLOC(sizeof(int) * fontspr->sheetCount); fontspr->sheetSprites = (int *)DXALLOC(sizeof(int) * fontspr->sheetCount); fontspr->space = 0; for (i = 0; i < fontspr->sheetCount; ++i) { char buf[64]; memcpy(buf, lfdData + sizeof(LFDHeader) + (sizeof(Uint16) * CODE_TABLE_SIZE) + (32 * i), 32); buf[32] = '\0'; if (pExt != NULL) { char newBuf[2048]; PL_Text_ConvertStrncpy( newBuf, -1, buf, g_lunaUseCharSet, 2048); PL_Text_ConvertStrncat( newBuf, -1, pExt, g_lunaUseCharSet, 2048); int surface = PL_Surface_Load(newBuf); fontspr->sheetGraphs[i] = PL_Surface_ToTexture(surface); PL_Surface_Delete(surface); } else { /* FIXME: LAG support */ fontspr->sheetGraphs[i] = -1; } fontspr->sheetSprites[i] = LunaSprite::Create(Num, PRIM_VERTEX_UV1, IsSortZ); LunaSprite::AttatchTexture(fontspr->sheetSprites[i], 0, fontspr->sheetGraphs[i]); } return fontSprHandle; } while(0); PL_File_Close(file); if (lfdData != NULL) { DXFREE(lfdData); } return INVALID_FONTSPRITE; }
/* - regcomp - compile a regular expression into internal code * * We can't allocate space until we know how big the compiled form will be, * but we can't compile it (and thus know how big it is) until we've got a * place to put the code. So we cheat: we compile it twice, once with code * generation turned off and size counting turned on, and once "for real". * This also means that we don't allocate space until we are sure that the * thing really will compile successfully, and we never have to move the * code and thus invalidate pointers into it. (Note that it has to be in * one piece because FREE() must be able to free it all.) * * Beware that the optimization-preparation code in here knows about some * of the structure of the compiled regexp. */ regexp *regcomp (unsigned char * exp, int excompat) /* \( \) operators like in unix ex */ { register regexp *r; register unsigned char *scan; register char *longest; register int len; int flags; short *exp2, *dest, c; if (!exp) FAIL("NULL argument\n"); exp2 = (short *) DXALLOC((strlen((char *)exp) + 1) * (sizeof(short[8]) / sizeof(char[8])), TAG_TEMPORARY, "regcomp: 1"); for (scan = exp, dest = exp2; (c = *scan++);) { switch (c) { case '(': case ')': *dest++ = excompat ? c : c | SPECIAL; break; case '.': case '*': case '+': case '?': case '|': case '$': case '^': case '[': case ']': *dest++ = c | SPECIAL; break; case '\\': switch (c = *scan++) { case 0: FREE(exp2); FAIL("Regular expression cannot end with '\\'. Use \"\\\\\".\n"); break; case '(': case ')': *dest++ = excompat ? c | SPECIAL : c; break; case '<': case '>': *dest++ = c | SPECIAL; break; case '{': case '}': FREE(exp2); FAIL("sorry, unimplemented operator\n"); case 'b': *dest++ = '\b'; break; case 't': *dest++ = '\t'; break; case 'r': *dest++ = '\r'; break; default: *dest++ = c; } break; default: *dest++ = c; } } *dest = 0; /* First pass: determine size, legality. */ regparse = exp2; regnpar = 1; regsize = 0L; regcode = ®dummy; regc((char) MAGIC); if (reg(0, &flags) == (char *) NULL) { FREE(exp2); return ((regexp *) NULL); } /* Small enough for pointer-storage convention? */ if (regsize >= 32767L) /* Probably could be 65535L. */ { FREE(exp2); FAIL("regexp too big\n"); } /* Allocate space. */ r = (regexp *) DXALLOC(sizeof(regexp) + (unsigned) regsize, TAG_TEMPORARY, "regcomp: 2"); if (r == (regexp *) NULL) { FREE(exp2); FAIL("out of space\n"); } /* Second pass: emit code. */ regparse = exp2; regnpar = 1; regcode = (char *)(r->program); regc((char) MAGIC); if (reg(0, &flags) == NULL) { FREE(exp2); FREE(r); return ((regexp *) NULL); } /* Dig out information for optimizations. */ r->regstart = '\0'; /* Worst-case defaults. */ r->reganch = 0; r->regmust = NULL; r->regmlen = 0; scan = (unsigned char *)(r->program + 1); /* First BRANCH. */ if (OP(regnext((char *)scan)) == END) { /* Only one top-level choice. */ scan = OPERAND(scan); /* Starting-point info. */ if (OP(scan) == EXACTLY) r->regstart = *OPERAND(scan); else if (OP(scan) == BOL) r->reganch++; /* * If there's something expensive in the r.e., find the longest * literal string that must appear and make it the regmust. Resolve * ties in favor of later strings, since the regstart check works * with the beginning of the r.e. and avoiding duplication * strengthens checking. Not a strong reason, but sufficient in the * absence of others. */ if (flags & SPSTART) { longest = NULL; len = 0; for (; scan != NULL; scan = (unsigned char *)regnext((char *)scan)) { char *tmp = (char *)OPERAND(scan); int tlen; if (OP(scan) == EXACTLY && (tlen = strlen(tmp)) >= len) { longest = tmp; len = tlen; } } r->regmust = longest; r->regmlen = len; } } FREE((char *) exp2); return (r); }
void f_uncompress (void) { z_stream* compressed; unsigned char compress_buf[COMPRESS_BUF_SIZE]; unsigned char* output_data = NULL; int len; int pos; buffer_t* buffer; int ret; if (sp->type == T_BUFFER) { buffer = sp->u.buf; } else { pop_n_elems(st_num_arg); push_undefined(); return ; } compressed = (z_stream *) DXALLOC(sizeof(z_stream), TAG_INTERACTIVE, "start_compression"); compressed->next_in = buffer->item; compressed->avail_in = buffer->size; compressed->next_out = compress_buf; compressed->avail_out = COMPRESS_BUF_SIZE; compressed->zalloc = zlib_alloc; compressed->zfree = zlib_free; compressed->opaque = NULL; if (inflateInit(compressed) != Z_OK) { FREE(compressed); pop_n_elems(st_num_arg); push_undefined(); return ; } len = 0; output_data = NULL; do { ret = inflate(compressed, 0); if (ret == Z_OK) { pos = len; len += COMPRESS_BUF_SIZE - compressed->avail_out; if (!output_data) { output_data = (unsigned char*)DXALLOC(len, TAG_TEMPORARY, "uncompress"); } else { output_data = REALLOC(output_data, len); } memcpy(output_data + pos, compress_buf, len - pos); compressed->next_out = compress_buf; compressed->avail_out = COMPRESS_BUF_SIZE; } } while (ret == Z_OK); inflateEnd(compressed); pop_n_elems(st_num_arg); if (ret == Z_STREAM_END) { buffer = allocate_buffer(len); memcpy(buffer->item, output_data, len); FREE(output_data); push_buffer(buffer); } else { push_undefined(); } }