void *_MemoryShrinkForSure(PyMOLGlobals * G, void *ptr, unsigned int size, int group_id,
int block_id MD_FILE_LINE_Decl)
{
/* no checking done */
if((group_id < 0) || (!SettingGetGlobal_b(G, cSetting_cache_memory)))
return (ReallocForSure(ptr, size)); /* NOTE: fatal if new ptr is larger than old... */
{
register CMemoryCache *I = G->MemoryCache;
register MemoryCacheRec *rec = &I->Cache[group_id][block_id];
if(ptr != rec->ptr)
printf("Error: Memory Cache Mismatch 2 %d %d\n", group_id, block_id);
if(!rec->ptr) { /* not currently cache-allocated... this should never happen */
rec->size = size;
rec->ptr = mrealloc(ptr, size);
} else if(rec->size < size) {
rec->ptr = MemoryReallocForSureSafe(ptr, size, rec->size);
rec->size = size;
} else { /* expanding size...should never happen... this should never happen */
rec->size = size;
rec->ptr = mrealloc(ptr, size);
}
return (rec->ptr);
}
}
void *from_file(const char *fn, unsigned long *size, t_check_fun chk)
{
int fd;
char *buff;
int r;
fd = open(fn, O_RDONLY);
if (fd < 0)
return (0);
*size = 0;
buff = ft_memalloc(512);
while (1)
{
r = read(fd, buff + *size, 512);
*size += r;
if (!chk(buff + *size, r, *size))
{
free(buff);
return (0);
}
if (r != 512)
break ;
buff = mrealloc(buff, *size, *size + 512);
ft_memset(buff + *size, 0, 512);
}
return (buff);
}
ppInt32 CosArrayInsert( PDFCosHandle CosObject, PDFCosHandle NewCosObject, ppUns32 Position )
{
if ( !_IsCosArray( CosObject ) )
_RAISE ( ErrCosLevel, cleInvalidObjError );
if ( _CosDoc ( NewCosObject ) != _DOC )
_RAISE ( ErrCosLevel, cleCannotInsertObjectFromOtherDocumentError );
if ( !_CosIsIndirect ( NewCosObject) && _CosParent ( NewCosObject ) )
_RAISE ( ErrCosLevel, cleCannotInsertObjectWithParrentError );
if ( Position >= _CosArrayCount ( CosObject ) )
return CosArrayAppend ( CosObject, NewCosObject );
if ( _CosArrayCount ( CosObject ) == _CosArrayCapacity ( CosObject ) ){
_CosArrayCapacity ( CosObject ) += CalculateDelta ( _CosArrayCapacity ( CosObject ) );
_CosArrayArray ( CosObject ) = ( PDFCosHandle * )
mrealloc ( _LIB, _CosArrayArray ( CosObject ),
_CosArrayCapacity ( CosObject ) * sizeof ( PDFCosHandle ) );
};
memmove ( &( _CosArrayItem ( CosObject, Position + 1 ) ),
&( _CosArrayItem ( CosObject, Position ) ),
( _CosArrayCount ( CosObject ) - Position ) * sizeof ( PDFCosHandle ) );
if ( _CosIsIndirect ( NewCosObject ) )
NewCosObject = CosNewRef ( _CosDoc( NewCosObject ), _CosObjID ( NewCosObject),
_CosObjGeneration ( NewCosObject ) );
_CosArrayItem ( CosObject, Position ) = NewCosObject;
_CosArrayCount ( CosObject )++;
if ( !_IsCosNull ( NewCosObject ) )
_CosParent ( NewCosObject ) = CO ( CosObject );
return Position;
}
char *get_next_line(const int fd)
{
static char buff_rd[READ_SIZE];
static int i;
int j;
char *buff_ret;
int len;
j = 0;
if ((buff_ret = malloc_ret()) == NULL)
return (NULL);
if (i > READ_SIZE + 1)
i = 0;
if (buff_rd[0] == 0 && (len = mread(fd, buff_rd, READ_SIZE, &i) < 0))
return (NULL);
while (buff_rd[i] != '\n')
{
if (buff_rd[i] == 0 && (len = mread(fd, buff_rd, READ_SIZE, &i) < 0))
return (NULL);
if (j != 0 && ( j % READ_SIZE) == 0
&& ((buff_ret = mrealloc(buff_ret, j)) == NULL))
return (NULL);
buff_ret[j++] = buff_rd[i++];
}
i = i + 1;
buff_ret[j] = 0;
return (buff_ret);
}
void *myalloc(tmemory *mem, int size)
{
// return mcalloc(size,sizeof(char));
//}
if (adplib_debug>1) printf("myalloc(), currentBlock = , currentPos = \n");
if (size % ALIGNMENT) {
size = ((size / ALIGNMENT) + 1) * ALIGNMENT;
if (adplib_debug>1) printf("realigned: %d\n", size);
}
if (mem->currentPos + size >= mem->blockSize) {
mem->currentBlock++;
if (mem->currentBlock > mem->numberOfBlocks) {
mem->address = mrealloc(mem->address, sizeof (char *) * mem->currentBlock);
mem->numberOfBlocks = mem->currentBlock;
mem->address[mem->currentBlock - 1] = mmalloc(mem->blockSize);
// if(adplib_debug>1) printf("address of mem->address[mem->currentBlock - 1]: %d\n", mem->address[mem->currentBlock - 1]);
}
mem->currentPos = 0;
// if (adplib_debug>1) printf("mrealloc: myalloc(%d), currentBlock = %d, currentPos = %d\n", size, mem->currentBlock, mem->currentPos);
}
mem->currentPos = mem->currentPos + size;
// if (adplib_debug>1) printf("myalloc: address: %d\n", mem->address[mem->currentBlock - 1] + (mem->currentPos - size));
return(mem->address[mem->currentBlock - 1] + (mem->currentPos - size));
}
void decr_line()
{
Lines--;
if (Alloc_Lines>Lines+201) {
Alloc_Lines-=200;
if ((edbf=(LIN *)mrealloc(edbf,sizeof(LIN)*Alloc_Lines,"err:decr_line"))
==NULL) exit(-1);
edstate[cur_file].edbf=edbf;
}
}
void incr_line()
{
Lines++;
if (Alloc_Lines<=Lines+1) {
Alloc_Lines+=200;
if ((edbf=(LIN *)mrealloc(edbf,
sizeof(LIN)*Alloc_Lines,"incr_line"))==NULL) exit(-1);
edstate[cur_file].edbf=edbf;
}
}
void ins_lines(int row, int lines)
{
int i;
Lines+=lines;
if (Alloc_Lines<=Lines+1) {
Alloc_Lines+=Max(lines,200);
if ((edbf=(LIN *)mrealloc(edbf,
sizeof(LIN)*Alloc_Lines,"err:ins_lines"))==NULL) exit(-1);
edstate[cur_file].edbf=edbf;
}
for(i=Lines-lines-1;i>=row;i--) edbf[i+lines]=edbf[i];
}
void *_MemoryCacheRealloc(PyMOLGlobals * G, void *ptr, unsigned int size, int group_id,
int block_id MD_FILE_LINE_Decl)
{
/* no checking done */
if((group_id < 0) || (!SettingGetGlobal_b(G, cSetting_cache_memory)))
return (mrealloc(ptr, size));
{
register CMemoryCache *I = G->MemoryCache;
register MemoryCacheRec *rec = &I->Cache[group_id][block_id];
if(ptr != rec->ptr)
printf("Error: Memory Cache Mismatch 2 %d %d\n", group_id, block_id);
if(!rec->ptr) {
rec->size = size;
rec->ptr = mrealloc(ptr, size);
} else if(rec->size < size) {
rec->size = size;
rec->ptr = mrealloc(ptr, size);
}
return (rec->ptr);
}
}
void *realloc(void *p, size_t s)
{
xbt_mheap_t mdp = __mmalloc_current_heap;
void *ret;
if (mdp) {
LOCK(mdp);
ret = mrealloc(mdp, p, s);
UNLOCK(mdp);
} else {
ret = real_realloc(p,s);
}
return ret;
}
void incr_kdefno(KEYDEF **kd, int kdefmapno, int *kdno)
{
KEYDEF *kdef=*kd;
int kdefno=*kdno;
kdefno++;
if (kdefno >= MAX_KEY_DEF) {
MAX_KEY_DEF+=50;
if ((kdef=mrealloc(kdef,MAX_KEY_DEF*sizeof(KEYDEF),"incr_kdefno"))==NULL)
exit(1);
kdefmap[kdefmapno]=kdef;
}
*kd=kdef;
*kdno=kdefno;
kdefno_m[kdefmapno]=kdefno;
}
int alloc_pool(){
int i, size=mem_pool.size;
trace(3,"alloc\n");
//top always =0 here! =)
mrealloc(mem_pool.free,unsigned int,mem_pool.size+ALLOC_CELLS);
mrealloc(mem_pool.mem,cell,mem_pool.size+ALLOC_CELLS);
for(i=0;i<ALLOC_CELLS;i++){
//reverse
mem_pool.free[i]=ALLOC_CELLS+size-1-i;
}
mem_pool.top=ALLOC_CELLS-1;
mem_pool.size+=ALLOC_CELLS;
pool_print();
hash_print();
return SUCCESS;
}
void extend_buffer(int article) {
int new_size;
if (article < buffer_entries)
return;
if (buffer_entries == 0)
new_size = INITIAL_BUFFER_ENTRIES;
else
new_size = buffer_entries * 2;
buffer = mrealloc(buffer, buffer_entries * NOV_BLOCK_SIZE,
new_size * NOV_BLOCK_SIZE);
buffer_entries = new_size;
max_article = article;
}
void leading_space_tab()
{
int row,len,nlen,i,ll,tabno,ofs;
char *ss;
for(row=0;row<Lines;row++) {
if (!(len=edbf[row].len)) continue;
ss=edbf[row].cstr;
for(ll=0;ll<len && ss[ll]==' ';ll++);
if (ll<tab_width) continue;
tabno=ll/tab_width;
ofs=tabno+(ll%tab_width);
mmemmove(ss+ofs,ss+ll,len-ll);
for(i=0;i<tabno;ss[i++]=9);
if ((ss=mrealloc(ss,nlen=len-ll+ofs,"leading_space_tab"))==NULL)
return;
edbf[row].cstr=ss;
edbf[row].len=nlen;
}
}
static void XMLCALL
setElement(void *data, const char *el, int len)
{
int i, j;
if(len <= 0 || parser_node == NULL)
return;
/* ignore prefixed '\n \r \t space' */
for(i = 0; i < len; i++) {
if(el[i] != '\r' && el[i] != '\n' && el[i] != '\t' && el[i] != ' ')
break;
}
if(i == len)
return;
if(el[len - 1] == '\n')
len--;
if(parser_node->value == NULL) {
parser_node->value = (char *) mcalloc(len - i + 1, 1);
if(parser_node->value == NULL) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
memcpy(parser_node->value, el + i, len - i);
parser_node->value[len - i] = '\0';
}
else {
/* expands parser's value */
j = strlen(parser_node->value);
parser_node->value =
(char *) mrealloc((void *) parser_node->value, j + (len - i) + 1);
if(parser_node->value == NULL) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
memcpy(parser_node->value + j, el + i, len - i);
parser_node->value[j + len - i] = '\0';
}
}
void CosDictAppend(PDFCosHandle CosObject, ppAtom Key, PDFCosHandle KeyValue )
{
ppUns32 i;
if ( !_IsCosDictOrStream (CosObject) )
_RAISE ( ErrCosLevel, cleInvalidObjError );
if ( _CosDoc ( KeyValue ) != _DOC )
_RAISE ( ErrCosLevel, cleCannotInsertObjectFromOtherDocumentError );
if ( !_CosIsIndirect ( KeyValue) && _CosParent ( KeyValue ) )
_RAISE ( ErrCosLevel, cleCannotInsertObjectWithParrentError );
if ( _IsCosNull ( KeyValue ) ){
CosDictRemoveKey ( CosObject, Key );
return;
}
if ( _IsCosStream ( CosObject ) )
CosObject = _CosStreamAttr (CosObject );
/* Check on exists key */
for ( i = 0; i < _CosDictCount ( CosObject ); i++ )
if ( _CosDictKey ( CosObject, i) == Key ){
CosFree( _CosDictValue ( CosObject, i) );
if ( _CosIsIndirect ( KeyValue ) )
KeyValue = CosNewRef ( _CosDoc( KeyValue ), _CosObjID ( KeyValue),
_CosObjGeneration ( KeyValue ) );
_CosDictValue ( CosObject, i) = KeyValue;
_CosParent ( KeyValue ) = CO ( CosObject );
return;
};
if ( _CosDictCount ( CosObject ) == _CosDictCapacity (CosObject) ){
_CosDictCapacity ( CosObject ) += CalculateDelta ( _CosDictCapacity ( CosObject) );
_CosDictArray ( CosObject ) = ( DictElem * ) mrealloc ( _LIB, _CosDictArray ( CosObject ),
_CosDictCapacity ( CosObject) * sizeof ( DictElem ) );
}
i = _CosDictCount ( CosObject );
_CosDictKey ( CosObject, i) = Key;
if ( _CosIsIndirect ( KeyValue ) )
KeyValue = CosNewRef ( _CosDoc( KeyValue ), _CosObjID ( KeyValue),
_CosObjGeneration ( KeyValue ) );
_CosDictValue ( CosObject, i) = KeyValue;
_CosParent ( KeyValue ) = CO ( CosObject );
_CosDictCount ( CosObject )++;
}
void *realloc(void *p, size_t s)
{
if (!mm_initialized) {
if (mm_initializing)
return mm_fake_realloc(p, s);
mm_legacy_constructor();
}
if (!__malloc_use_mmalloc) {
return mm_real_realloc(p, s);
}
xbt_mheap_t mdp = GET_HEAP();
if (!mdp)
return NULL;
LOCK(mdp);
void* ret = mrealloc(mdp, p, s);
UNLOCK(mdp);
return ret;
}
void trim_blank_tail()
{
int row,len,i,ll;
char *ss;
for(row=0;row<Lines;row++) {
if (!(len=edbf[row].len)) continue;
ss=edbf[row].cstr;
for(ll=len;ll>0 && (ss[ll-1]==' '||ss[ll-1]==9) ;ll--);
if (!ll) {
free(ss);
ss=0;
goto lll1;
} else
if (ll==len) continue;
if ((ss=mrealloc(ss,ll,"trim_blank_tail"))==NULL)
return;
lll1:
edbf[row].cstr=ss;
edbf[row].len=ll;
}
if (cursor_col>edbf[cursor_row].len) cursor_col=edbf[cursor_row].len;
}
LoadTedrc(char *tedname, int depth, int kdefmapno)
{
FILE *fp;
char ss[8192],ibuf[2048],*tt,*uu,*vv,*ww,*xx;
int len,i,j,lno;
int hdef[128];
extern int X_inited;
KEYDEF *kdef=kdefmap[kdefmapno];
int kdefno=kdefno_m[kdefmapno];
if ((fp=init_tedrc_fname(tedname, depth))==NULL)
return 1;
if (kdefno && !depth) {
for(j=0;j<kdefno;j++) free(kdef[j].cmd);
if (!kdefmapno) free_lang();
free(kdef);
kdefmap[kdefmapno]=NULL;
if (kdefmapno) {
free(mode_str_m[kdefmapno]);
mode_str_m[kdefmapno]=NULL;
}
kdef=NULL;
}
#if 0
printf("-- %d %d %s\n",depth, kdefmapno, ftedrc);
#endif
if (kdef==NULL) {
MAX_KEY_DEF=280;
if ((kdef=mmalloc(sizeof(KEYDEF)*MAX_KEY_DEF,"LoadTedrc"))==NULL)
exit(1);
kdefmap[kdefmapno]=kdef;
kdefno_m[kdefmapno]=kdefno=0;
}
if (!depth) qsort(kmap,kname_no,sizeof(KEYMAP),qcmpxk);
tedrcfname=tedname;
lno=0;
while (!feof(fp)) {
int next_l;
ss[0]=0;
next_l=0;
for(;;) {
lno++;
len=mfgets(ibuf,sizeof(ibuf),fp);
if (!len) {
next_l=1;
break;
}
if (ibuf[len-1]=='\n') ibuf[--len]=0;
if (!len) {
next_l=1;
break;
}
while (len && (ibuf[len-1]==' '||ibuf[len-1]==9)) len--;
if (!len) {
next_l=1;
break;
}
if (ibuf[len-1]=='\\') {
ibuf[len-1]=0;
strcat(ss,ibuf);
} else {
strcat(ss,ibuf);
break;
}
}
if (next_l) continue;
tt=skip_spc(ss);
uu=to_spc(tt);
vv=skip_spc(uu);
*uu=0;
if (tt[0]=='#') continue;
if (!strcmp(tt,"d")) {
ww=to_spc(vv);
if (!(*vv)) lper(tedname,lno,"argument expected");
kdef[kdefno].klen=parse_key(tedname, lno,vv,ww,kdef[kdefno].kcode);
if ((i=kcode_exist(kdefno,kdef,kdefno))<kdefno)
free(kdef[i].cmd);
xx=skip_spc(ww);
kdef[i].cmd=strdup(parse_Cstr(tedname, lno,xx,&uu));
kdef[i].type=0;
if (i==kdefno) incr_kdefno(&kdef,kdefmapno,&kdefno);
continue;
} else
if (!strcmp(tt,"f")) {
ww=to_spc(vv);
if (!(*vv)) lper(tedname,lno,"argument expected");
kdef[kdefno].klen=parse_key(tedname, lno,vv,ww,kdef[kdefno].kcode);
if ((i=kcode_exist(kdefno,kdef,kdefno))<kdefno)
free(kdef[i].cmd);
xx=skip_spc(ww);
if (parse_stmt(tedname, lno,xx,&kdef[i].cmd,&kdef[i].type)) {
if (i==kdefno) incr_kdefno(&kdef,kdefmapno,&kdefno);
}
continue;
}
if (kdefmapno)
lper(tedname,lno,"%s for LoadKeyDefInto can accept 'f' and 'd' command only", tedname);
if (!strcmp(tt,"s")) {
ww=to_spc(vv);
xx=skip_spc(ww);
*ww=0;
for(i=0;i<sizeof(locolor)/sizeof(locolor[0]);i++)
if (!strcmp(vv,locolor[i].cname)) break;
if (i==sizeof(locolor)/sizeof(locolor[0]))
lper(tedname,lno,"Unknown Def color %s",vv);
ww=to_spc(xx);
*ww=0;
strcpy(locolor[i].caddr,xx);
} else
if (!strcmp(tt,"set")) {
ww=to_spc(vv);
xx=skip_spc(ww);
tt=to_spc(xx);
if (!(*ww)) lper(tedname,lno,"argument expected");
*ww=0;
for(i=0;i<sizeof(sets)/sizeof(sets[0]);i++)
if (!strcmp(sets[i].sname,vv)) break;
if (i==sizeof(sets)/sizeof(sets[0]))
lper2(tedname,lno,"Unknown set %s",vv);
else {
*tt=0;
*(sets[i].saddr)=atoi(xx);
}
} else
if (!strcmp(tt,"lang") && !depth) {
extern char DirectCommentChars[];
int keywcnt=3,LangIdx,ColIdx,AllocN=32,kwidx, MaxKeywordLen=0;
char *ff;
KW *kw;
if (depth)
p_err("cannot define 'lang' in include %s", tedname);
tt=parse_Cstr(tedname, lno,vv,&uu);
i=strlen(tt)+2;
if ((vv=mmalloc(i,"LoadTedrc"))==NULL) exit(1);
if ((kw=mmalloc(AllocN*sizeof(KW),"LoadTedrc 2"))==NULL) exit(1);
LangExt[LangN]=strcat(strcpy(vv,tt)," ");
kw[0].coloridx=ColorCnt;
strcpy(pc_color[ColorCnt].fg_str,getstr(uu,&vv));
strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu));
uu=skip_spc(uu);
DirectCommentChars[LangN]=*uu;
kw[1].coloridx=ColorCnt;
strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv));
strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu));
kw[2].coloridx=ColorCnt;
strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv));
strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu));
for(;;) {
if (!*uu) break;
strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv));
strcpy(pc_color[ColorCnt].bg_str,getstr(vv,&uu));
uu=skip_spc(uu);
ww=tt=parse_Cstr(tedname, lno,uu,&vv);
uu=vv;
xx=tt+strlen(tt);
for(;;) {
char *pstr;
tt=to_spc(ww);
vv=skip_spc(tt);
*(tt)=0;
if (pstr=strchr(ww,'(')) {
kw[keywcnt].arg=strdup(pstr);
*pstr=0;
} else kw[keywcnt].arg=0;
kw[keywcnt].keyword=strdup(ww);
if (strlen(ww) > MaxKeywordLen) MaxKeywordLen=strlen(ww);
kw[keywcnt].coloridx=ColorCnt;
#if 0
printf("%d %d %d %s\n",LangN,keywcnt, ColorCnt,
kw[keywcnt].keyword);
#endif
keywcnt++;
if (keywcnt+3>=AllocN) {
AllocN+=32;
if ((kw=mrealloc(kw,AllocN*sizeof(KW),"LoadTedrc 3"))==NULL) exit(1);
}
ww=vv;
if (ww==xx) break;
}
ColorCnt++;
}
qsort(kw+3,keywcnt-3,sizeof(KW), kwcmp);
LangKw[LangN]=kw;
LangMaxKeywordLen[LangN]=MaxKeywordLen;
LangKwN[LangN++]=keywcnt;
if (LangN>=MaxLang) {
error("Too many languages defined");
error("Remove unused language in tedrc or modify ted.h and recompile");
exit(1);
}
} else
if (!strcmp(tt,"include")) {
if (depth > 10) {
error("include too many level ??");
continue;
}
ww=to_spc(vv);
xx=skip_spc(ww);
if (!(*vv)) lper(tedname,lno,"argument expected");
*ww=0;
LoadTedrc(vv,depth+1,kdefmapno);
tedrcfname=tedname;
} else
if (!strcmp(tt,"filebrowser")) {
ww=to_spc(vv);
xx=skip_spc(ww);
if (!(*vv)) lper(tedname,lno,"argument expected");
init_reg_exp(vv);
} else
if (!strcmp(tt,"fontlist")) {
ww=to_spc(vv);
xx=skip_spc(ww);
if (!(*vv)) lper(tedname,lno,"argument expected");
setFontList(vv);
} else
if (!strcmp(tt,"LoadKeyDefInto")) {
int no;
char mstr[16], *p;
tt=parse_Cstr(tedname, lno,vv,&uu);
if (!(*tt)) lper(tedname,lno,"file name expected");
ww=skip_spc(uu);
if (!*ww) lper(tedname,lno,"Bind number expected");
no=*ww-'0';
if (no<=0 || no>=4)
lper(tedname,lno,"Bind number must be less than 4 and greater than 0");
if ((p=strchr(tt,'.'))==NULL) {
mode_str_m[no]=" ";
} else {
p++;
if (! *p)
mode_str_m[no]=strdup(" ");
else
mode_str_m[no]=strdup(p);
}
LoadTedrc(tt,0,no);
}
}
fclose(fp);
if (!depth) {
kdefno=kdefno_m[kdefmapno];
qsort(kdef,kdefno,sizeof(kdef[0]),qcmp);
bzero(hdef,sizeof(hdef));
bzero(kdefhash[kdefmapno],128*sizeof(int));
for(i=0;i<kdefno;i++) {
j=KEYHASH(kdef[i].kcode[0]);
if (hdef[j]) continue;
hdef[j]=1;
kdefhash[kdefmapno][j]=i;
}
kdefhash[kdefmapno][127]=kdefno;
for(i=126;i>=0;i--)
if (!hdef[i]) kdefhash[kdefmapno][i]=kdefhash[kdefmapno][i+1];
ReLoadTed=1;
if (X_inited) alloc_pc_colors();
}
return 0;
}
ExecCommand(char *cmd, int count)
{
int i,usta,j;
char *ttt,*uuu;
char *pcmd;
pcmd=cmd;
last_str=0;
for(i=0;i<count;i++) {
u_char funo=*(cmd++);
if (func[funo].modfunc && readonly) {
message(4,"Read only mode");
break;
}
switch (func[funo].argtype) {
case 0:
if (rec_mac && funo!=1) {
*(mac_ptr++)=funo;
mac_cnt++;
ck_mac_size();
}
usta=func[funo].action();
X_loop();
break;
case 1:
if (rec_mac) {
*(mac_ptr++)=funo;
*(mac_ptr++)=*cmd;
mac_cnt++;
ck_mac_size();
}
usta=func[funo].action(*(cmd++));
break;
case 2:
if (rec_mac) {
*(mac_ptr++)=funo;
strcpy(mac_ptr, cmd);
mac_ptr+=strlen(cmd)+1;
ck_mac_size();
}
usta=func[funo].action(cmd);
if (ReLoadTed) {
ReLoadTed=0;
return 0;
}
cmd+=strlen(cmd)+1;
break;
case 3:
usta=func[funo].action(cmd,ttt=cmd+strlen(cmd)+1);
if (rec_mac) {
*(mac_ptr++)=funo;
strcpy(mac_ptr, cmd);
mac_ptr+=strlen(cmd)+1;
strcpy(mac_ptr,ttt);
mac_ptr+=strlen(ttt)+1;
ck_mac_size();
}
cmd+=strlen(cmd)+1+strlen(ttt)+1;
break;
case 5:
/* for binding that needs vi keystrokes saving (dd, dw ...) */
/* look for PlaySaveFunc */
for (j=0;j<ckdefno;j++) {
char *p=ckdef[j].cmd;
if (*p==4) {
static char *qq;
int cmlen=cmdlen(pcmd,count);
if ((qq=mrealloc(qq,cmlen,"feek_key"))==NULL)
return 0;
memcpy(qq,pcmd,cmlen);
ckdef[j].type=count;
*qq=4;
ckdef[j].cmd=qq;
saveBufType=1;
break;
}
}
usta=1;
break;
case 6:
if (saveBufType) usta=1;
else {
putStrSave();
return 0;
}
break;
case 7:
ttt=cmd+strlen(cmd)+1;
uuu=ttt+strlen(ttt)+1;
usta=func[funo].action(cmd,ttt,uuu);
if (rec_mac) {
*(mac_ptr++)=funo;
strcpy(mac_ptr, cmd);
mac_ptr+=strlen(cmd)+1;
strcpy(mac_ptr,ttt);
mac_ptr+=strlen(ttt)+1;
strcpy(mac_ptr,uuu);
mac_ptr+=strlen(uuu)+1;
ck_mac_size();
}
cmd+=strlen(cmd)+1+strlen(ttt)+1+strlen(uuu)+1;
break;
case 8:
{
int aa,bb;
memcpy(&aa,cmd,sizeof(int));
memcpy(&bb,cmd+4,sizeof(int));
usta=func[funo].action(aa,bb);
cmd+=sizeof(int)*2;
}
break;
}
if (xgets_enter==-1) {
xgets_enter=0;
break;
}
if (usta) continue;
disp_fname();
disp_cur_pos();
disp_ins_mod();
show_cursor_w();
}
return 1;
}
static void XMLCALL
startElement(void *data, const char *name, const char **atts)
{
int i, j;
struct xmlattribute *xmlattr;
/* starting parsing */
if(xml_error)
return;
parser_node = (struct xmlnode *) mcalloc(sizeof(struct xmlnode), 1);
if(parser_node == NULL) {
printf("%s: %d\n", __FILE__, __LINE__);
xml_error = XML_ERR_MEMORY;
return;
}
parser_node->parent = parser_parent[xml_depth];
/* update parser_parent child structure */
if(parser_parent[xml_depth]->nchild) {
/* add new child */
parser_parent[xml_depth]->child =
(struct xmlnode **) mrealloc((void *)
parser_parent[xml_depth]->child,
(parser_parent[xml_depth]->nchild +
1) * sizeof(struct xmlnode *));
if(parser_parent[xml_depth]->child == NULL) {
printf("%s: %d\n", __FILE__, __LINE__);
xml_error = XML_ERR_MEMORY;
return;
}
parser_parent[xml_depth]->child[parser_parent[xml_depth]->nchild] =
parser_node;
parser_parent[xml_depth]->nchild++;
}
else {
/* first child */
parser_parent[xml_depth]->child =
(struct xmlnode **) mcalloc(sizeof(struct xmlnode *), 1);
if(parser_parent[xml_depth]->child == NULL) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
parser_parent[xml_depth]->child[0] = parser_node;
parser_parent[xml_depth]->nchild = 1;
}
xml_depth++;
if(xml_depth == parent_depth) {
if(parent_depth == max_parent_depth) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
parent_depth++;
}
parser_parent[xml_depth] = parser_node;
parser_node->name = strdup(name);
/* get xml node's attributes */
for(i = 0, j = 0; atts[i]; i += 2)
j++;
if(j) {
parser_node->attr =
(struct xmlattribute **) mcalloc(sizeof(struct xmlattribute *),
j);
if(parser_node->attr == NULL) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
parser_node->nattr = j;
for(i = 0; i < j; i++) {
xmlattr =
(struct xmlattribute *) mcalloc(sizeof(struct xmlattribute),
1);
if(xmlattr == NULL) {
xml_error = XML_ERR_MEMORY;
printf("%s: %d\n", __FILE__, __LINE__);
return;
}
xmlattr->name = strdup(atts[2 * i]);
xmlattr->value = strdup(atts[2 * i + 1]);
parser_node->attr[i] = xmlattr;
}
}
}
ppInt32 ULModFindOrAppendAtom(PDFLibHandle Lib, char *str)
{
PPDFLib l = ( PPDFLib ) Lib;
ppInt32 i, cmp;
char *n;
PppAtomNode /* T = &( l-> AtomRoot), */
S,P, Q;
S = P = l->AtomRoot.Right;
if ( !S ){
S = ( PppAtomNode ) mmalloc ( Lib, sizeof ( ppAtomNode ) );
i = ( ppInt32 ) strlen ( str );
n = ( char * ) mmalloc ( Lib, i + 1 );
memcpy ( n, str, i + 1 );
S->Balance = 0;
S->ID = 0;
S->Left = NULL;
S->Right = NULL;
S->String = n;
S->EscStr = ULGetEscName ( Lib, n );
S->Length = ULGetNameSize ( n );
if ( ( l->AtomCount ) == l->AtomCapacity ){
l->AtomCapacity += CalculateDelta(l->AtomCapacity);
l->AtomArray = ( PppAtomNode *) mrealloc ( Lib, l->AtomArray, sizeof ( PppAtomNode ) * l->AtomCapacity );
};
l->AtomArray[l->AtomCount++] = S;
l->AtomRoot.Right = S;
return 0;
}
A2 :
cmp = strcmp ( str, P->String );
if ( !cmp )
return P->ID;
if ( cmp < 0 ){
Q = P->Left;
if ( !Q ){
Q = ( PppAtomNode ) mmalloc ( Lib, sizeof ( ppAtomNode ) );
P->Left = Q;
goto A5;
}
} else{
Q = P->Right;
if ( !Q ){
Q = ( PppAtomNode )mmalloc ( Lib, sizeof ( ppAtomNode ) );
P->Right = Q;
goto A5;
}
}
/* if ( Q->Balance ){
T = P;
S = Q;
}*/
P = Q;
goto A2;
A5 :
i = ( ppInt32 ) strlen ( str );
n = ( char * ) mmalloc ( Lib, i + 1 );
memcpy ( n, str, i + 1 );
Q->Balance = 0;
Q->ID = l->AtomCount;
Q->Left = NULL;
Q->Right = NULL;
Q->String = n;
Q->EscStr = ULGetEscName ( Lib, n );
Q->Length = ULGetNameSize ( n );
if ( ( l->AtomCount ) == l->AtomCapacity ){
l->AtomCapacity += CalculateDelta ( l->AtomCapacity ) ;
l->AtomArray = ( PppAtomNode * )mrealloc ( Lib, l->AtomArray, sizeof ( PppAtomNode ) * l->AtomCapacity );
};
l->AtomArray[l->AtomCount] = Q;
return l->AtomCount++;
}
// . pre-allocate memory
// . returns false and sets g_errno on error
bool TopTree::setNumNodes ( int32_t docsWanted , bool doSiteClustering ) {
// save this
m_docsWanted = docsWanted;
m_doSiteClustering = doSiteClustering;
// reset this
m_kickedOutDocIds = false;
//m_lastKickedOutDocId = -1LL;
// how many nodes to we need to accomodate "docsWanted" docids?
// we boost it up here for domain/host counting for site clustering.
m_ridiculousMax = (int64_t)docsWanted * 2;
if ( m_ridiculousMax < 50 ) m_ridiculousMax = 50;
int64_t numNodes = m_ridiculousMax * 256;
// i would say limit it to 100,000 nodes regarless
if ( numNodes > MAXDOCIDSTOCOMPUTE ) numNodes = MAXDOCIDSTOCOMPUTE;
// craziness overflow?
if ( numNodes < 0 ) numNodes = MAXDOCIDSTOCOMPUTE;
// amp it up last minute, after we set numNodes, if we need to
if ( ! m_doSiteClustering ) m_ridiculousMax = 0x7fffffff;
// if not doing siteclustering... don't use 5gb of ram!
// add 1 for printing "next 10" link
if ( ! m_doSiteClustering ) numNodes = m_docsWanted + 1;
// how many docids do we have, not FULLY counting docids from
// "dominating" domains? aka the "variety count"
m_vcount = 0.0;
// limit vcount to "cap" docids per domain
m_cap = m_docsWanted / 50;
if ( m_cap < 2 ) m_cap = 2;
if ( ! m_doSiteClustering ) m_cap = 0x7fffffff;
// to keep things more continuous as a function of "m_docsWanted" we
// count docids right at the "cap" as a fractional count. see below.
m_partial = (float)(m_docsWanted % 50) / 50.0;
// reset dom count array
memset ( m_domCount , 0 , 4 * 256 );
// reset domain min nodes
for ( int32_t i = 0 ; i < 256 ; i++ )
m_domMinNode[i] = -1;
// return if nothing needs to be done
if ( m_nodes && numNodes == m_numNodes ) return true;
// save this
//m_useSampleVectors = useSampleVectors;
// . grow using realloc if we should
// . alloc for one extra to use as the "empty node"
//int32_t vecSize = 0;
//if ( useSampleVectors ) vecSize = SAMPLE_VECTOR_SIZE ;
char *nn ;
int64_t oldsize = (m_numNodes+1) * ( sizeof(TopNode) );
int64_t newsize = ( numNodes+1) * ( sizeof(TopNode) );
// if they ask for to many, this can go negative
if ( newsize < 0 ) {
g_errno = ENOMEM;
return false;
}
bool updated = false;
if (! m_nodes) {
nn=(char *)mmalloc (newsize,"TopTree");
m_numUsedNodes = 0;
}
else {
nn=(char *)mrealloc(m_nodes,oldsize,newsize,"TopTree");
updated = true;
}
if ( ! nn ) return log("query: Can not allocate %"INT64" bytes for "
"holding resulting docids.", newsize);
// save this for freeing
m_allocSize = newsize;
// success
char *p = nn;
m_nodes = (TopNode *)p;
m_numNodes = numNodes;
p += (numNodes+1) * sizeof(TopNode);
// vectors
//if ( m_useSampleVectors ) m_sampleVectors = (int32_t *)p;
// bail now if just realloced
if ( updated ) return true;
// make empty the last
m_emptyNode = 0;
// set it
m_headNode = -1;
// score info
m_lowNode = -1;
m_highNode = -1;
// setup the linked list of empty nodes
for ( int32_t i = 0 ; i < m_numNodes ; i++ ) {
m_nodes[i].m_parent = -2;
m_nodes[i].m_right = i+1;
}
// last node is the end of the linked list of available nodes
m_nodes[m_numNodes-1].m_right = -1;
// alloc space for m_t2, only if doing site clustering
if ( ! m_doSiteClustering ) return true;
// . we must limit domHash to m_ridiculousMax nodes
// . "dataInPtrs" mean we have a 4 byte data that we store in the
// "dataPtr". this is somewhat of a hack, but we need a place to
// store the node number of this node in this top tree. see below.
if ( ! m_t2.set ( 4 , // fixedDataSize
m_numNodes , // maxNumNodes
true , // doBalancing
-1 , // memMax (-1-->no max)
false , // ownData?
"tree-toptree" ,
true , // dataInPtrs?
NULL , // dbname (generic)
12 , // keySize
false ))// useProtection?
return false;
return true;
}
// use "mem" bytes of memory for the cache
bool DiskPageCache::growCache ( long mem ) {
// debug msg
//log("GROWING PAGE CACHE from %li to %li bytes", m_upperMemOff, mem );
// don't exceed the max
if ( mem > m_maxMemOff ) mem = m_maxMemOff;
// bail if we wouldn't be growing
if ( mem <= m_upperMemOff ) return true;
// how many pages? round up.
long npages = mem/(m_pageSize+HEADERSIZE) + 1;
// . we need one "available" slot for each page in the cache
// . this is a list of memory offsets that are available
long oldSize = m_maxAvailMemOffs * sizeof(long) ;
long newSize = npages * sizeof(long) ;
long *a = (long *) mrealloc(m_availMemOff,oldSize,newSize,m_memTag);
if ( ! a ) return log("db: Failed to regrow page cache from %li to "
"%li bytes. Not enough memory.",oldSize,newSize);
m_availMemOff = a;
m_maxAvailMemOffs = npages;
m_memAlloced += (newSize - oldSize);
// debug msg
//log("%s growCache: up %li",m_dbname,(newSize - oldSize));
// how much more mem do we need to alloc?
long need = mem - m_upperMemOff ;
// how big is our last page set?
long size = 0;
char *ptr = NULL;
long i = 0;
if ( m_numPageSets > 0 ) {
// since we allocate everything at init this shouldn't happen
char *xx=NULL; *xx=0;
i = m_numPageSets - 1;
ptr = m_pageSet [ i ];
size = m_pageSetSize [ i ];
}
// realloc him
long extra = m_maxPageSetSize - size ;
if ( extra > need ) extra = need;
if ( m_useRAMDisk ){
// since RAMdisk it creates a file, no reason to alloc
m_memAlloced = need;
m_upperMemOff = need;
return true;
}
// and shared mem already has the mem at this point
if ( m_useSHM ) {
m_memAlloced = need;
m_upperMemOff = need;
return true;
}
char *s = (char *)mrealloc ( ptr , size , size + extra,
m_memTag);
if ( ! s ) return log("db: Failed to allocate %li bytes more "
"for pagecache.",extra);
m_pageSet [ i ] = s;
m_pageSetSize [ i ] = size + extra;
// if we are not adding to an existing, we are a new page set
if ( ! ptr ) m_numPageSets++;
// discount it
need -= extra;
// add to alloc count
m_memAlloced += extra;
m_upperMemOff += extra;
// debug msg
//log("%s growCache2: up %li",m_dbname,extra);
// if we do not need more, we are done
if ( need == 0 ) return true;
// otherwise, alloc new page sets until we hit it
for ( i++ ; i < MAX_PAGE_SETS && need > 0 ; i++ ) {
long size = need;
if ( size > m_maxPageSetSize ) size = m_maxPageSetSize;
need -= size;
m_pageSet[i] = (char *) mmalloc ( size , m_memTag );
if ( ! m_pageSet[i] ) break;
m_pageSetSize[i] = size;
m_memAlloced += size;
m_upperMemOff += size;
m_numPageSets++;
// debug msg
//log("%s growCache3: up %li",m_dbname,size);
}
// update upper bound
if ( need == 0 ) return true;
return log(LOG_LOGIC,"db: pagecache: Bad engineer. Weird problem.");
}
