root/tags/5.4.pre05/citrm.c

Revision 1, 34.8 kB (checked in by heitor.barbieri, 4 years ago)

Criação do svn para Cisis.
Line 
1#include <stdio.h>
2#include <string.h>
3#include <ctype.h>
4#include "cisis.h"
5
6#if CICPP
7#include <citrm.hpp>
8#define CITRM_SOURCE
9#include <cirun.hpp>
10/* ------------------------- CITRM.HPP --------------------------------- */
11#define trminit                         xtrminit                  /* internal use */
12#define trmalloc(itrm,nbytes)           xtrmalloc(nbytes)         /* internal use */
13#define term(itrm,dbnamp,keyp)          xterm(dbnamp,keyp)        /* internal use */
14#define trmread(trmp,treecase,retkeyp)  xtrmread(treecase,retkeyp)                   /* internal use */
15/*#define cntread                         xcntread                  /* moved to CISISX */
16/*#define invsetup                        xinvsetup                 /* moved to CISISX */
17/*#define noderead                        xnoderead                 /* moved to CISISX */
18/*#define leafread                        xleafread                 /* moved to CISISX */
19#define nxterm                          xnxterm                   /* internal use */
20#define posthdr1(trmp)                  xposthdr1()               /* internal use */
21#define posting(itrm,nord)              xposting(nord)            /* internal use */
22#define postpost(trmp)                  xpostpost()               /* internal use */
23/*#define postread                        xpostread                 /* moved to CISISX */
24/* --------------------------------------------------------------------- */
25#endif /* CICPP */
26
27/* ----------------------------- trm.c ------------------------------ */
28#define TRXTRACE    00
29#define TRMTRACE    00
30#define TRATRACE    0
31#define TRITRACE    0
32#define TRRTRACE    0
33#define TRSTRACE    00007
34#define TRSXRACE    00007
35#define TRNTRACE    000
36#define TRLTRACE    00
37#define TRPTRACE    00
38#define TRETRACE    0
39#define TRYTRACE    00
40#define TRCTRACE    0
41
42#define SAMTRACx    0
43#define SAMTRACE    00          /* last */
44
45#define IFPDUMMY    1           /* .ifp may be absent for validation */
46
47#if !CICPP
48/* global */
49int trmifupd=0;                         /* trm IFUPDATE operation */
50
51off_t lrlrseek=0L;
52int lrlrsize=0;
53
54char lasttrmread[CIMPL+1] = "";             /* 950724 */
55
56#if PC
57UCHR highv[LE2+1] = { 0xFF, '\0' };     /* manca controllo.. if signed */
58#else
59UCHR highv[LE2+1] = { 0x7F, '\0' };     /* manca controllo.. if signed */
60#endif
61
62#endif /* CICPP */
63
64#if !CICPP
65#define CITRM_CISISX_SOURCE 1
66#include "cisisx.c"
67#endif
68
69#if CICPP
70#define NO_ITRM   -1L
71#endif /* CICPP */
72
73#if CICPP
74TRMSTRU :: TRMSTRU (CISISX *cxp)
75{
76    TRMSTRU *trmp;
77    memset (this, 0x00, sizeof(*this));         // sizeof X member functions ?
78    trmp = this;
79    TRMnbytes = -1;
80    cisisxp = cxp;
81    if (cisisxp == NULL)
82     fatal("TRMSTRU/cisisxp==NULL");
83}
84#endif /* CICPP */
85
86
87#if CICPP
88void TRMSTRU :: xtrminit(void)
89#else /* CICPP */
90void trminit()                                                        /*
91------------
92                    inicializa vtrmp;
93                    expande highv;
94                    checa defines;
95                                                                      */
96#endif /* CICPP */
97{
98#if !LIND
99    int n;
100#endif
101
102    memset(&highv[1],highv[0],LE2-1); highv[LE2]='\0';
103
104#if !CICPP
105    for (ntrms=maxntrm;ntrms--; )
106        vtrmp[ntrms]=NULL;
107    ntrms=0;
108
109#if !LIND
110    n=IFHDRINFOS*INFOSIZE;
111    if (n != IFHDRSIZ)
112        fatal("trminit/check2");
113    n=IFPSTINFOS*INFOSIZE;
114    if (n != IFPSTSIZ)
115        fatal("trminit/check3");
116#endif
117
118#if TRITRACE
119printf("trminit - ntrms=%ld maxntrm=%ld\n",ntrms,maxntrm);
120#endif
121
122#endif /* CICPP */
123}
124
125
126#if CICPP
127LONGX TRMSTRU :: xtrmalloc(LONGX nbytes)
128#else /* CICPP */
129LONGX trmalloc(itrm,nbytes)                                             /*
130-------------
131                    abenda se nbytes != IFBSIZ, se diferente de zero;
132                    abenda se ja' alocado;
133                    aloca TRMHSIZE+nbytes bytes;
134                    aponta por vtrmp[itrm];
135                    garante inicializacao com zeros;
136                    armazena vtrmp[itrm]->trmnbytes;
137                    retorna itrm
138                                                                      */
139LONGX itrm;          /* indice de vtrmp, para ALLOC */
140LONGX nbytes;        /* tamanho da area em bytes */
141#endif /* CICPP */
142{
143    TRMSTRU *trmp;
144
145#if CICPP
146    trminit();
147    LONGX itrm = NO_ITRM;
148#else /* CICPP */
149    if (!ntrms)
150        trminit();
151
152    if (itrm < 0 || itrm >= maxntrm)
153        fatal("trmalloc/index");
154    if (ntrms >= maxntrm)
155        fatal("trmalloc/overflow");
156#endif /* CICPP */
157
158    if (nbytes)
159        if (nbytes != IFBSIZ)
160            fatal("trmalloc/nbytes");
161
162#if !CICPP
163    if (vtrmp[itrm])
164        fatal("trmalloc/again");
165    if ((TRMHSIZE+nbytes) > ALLOMAXV)
166        fatal("trmalloc/ALLOMAXV/TRMHSIZE+nbytes");
167    trmp=(TRMSTRU *)ALLOC((ALLOPARM)(TRMHSIZE+nbytes));
168    if (trmp == (TRMSTRU *)ALLONULL)
169        fatal("trmalloc/ALLOC");
170    vtrmp[itrm]=trmp;
171    ntrms++;
172    memset(trmp,0x00,(size_t)(TRMHSIZE+nbytes));
173#else /* CICPP */
174    trmp = this;
175#endif /* CICPP */
176    TRMnbytes=nbytes;
177    TRMtype=TYPETRM;
178#if TRATRACE
179#if !CICPP
180printf("trmalloc - vtrmp[%ld]=%p ntrms=%ld\n",itrm,vtrmp[itrm],ntrms);
181#endif /* CICPP */
182printf("trmalloc - TRMtype=%d TRMnbytes=%ld\n",TRMtype,TRMnbytes);
183#endif
184    return(itrm);
185}
186#if CICPP
187LONGX TRMSTRU :: xterm(UCHR *dbnamp,
188                      UCHR *keyp)
189#else /* CICPP */
190LONGX term(itrm,dbnamp,keyp)                                           /*
191---------
192                    inicializa vtrmp, se necessario;
193                    toma valor absoluto de itrm;
194                    aloca o registro itrm, se ainda nao alocado;
195                    seta dbxp com o resultado de dbxstorp(dbnamp);
196                    chama invsetup, se necessario;
197                    guarda chave preenchida com brancos em trmp->trmkey;
198                    procura termo exato;
199                    se nao achou,
200                      a) se itrm_in < 0 fica com primeiro resultado, ou
201                      b) procura na outra arvore e fica com a menor;
202                    move termo para trmp->trmkey;
203                    seta trmp->trmrc com retorno de trmread();
204                    seta controles para nxterm();
205                    chama posthdr1;
206                    retorna itrm_in
207                                                                      */
208LONGX itrm;          /* indice de vtrmp, para store */
209UCHR *dbnamp;       /* ptr nome base de dados a ler */
210UCHR *keyp;         /* termo a recuperar */
211#endif /* CICPP */
212{
213
214#if CICPP
215  LONGX itrm = NO_ITRM;
216#endif /* CICPP */
217
218    TRMSTRU *trmp;
219    DBXSTRU *dbxp;
220    LONGX itrm_in;
221    int treecase;
222    int len,n,n1,tc2,n2,rc2,kn;
223    UCHR *p,*k1p,*k2p,*dbnp;
224#if TRXTRACE
225    UCHR area[LE2+1];
226#endif
227#if SAMEL
228    char dbxname[sizeof(DBXname)],*dbp;
229    int lxx;
230#endif
231    if (!keyp) keyp=(unsigned char *)"";
232    dbnp=dbnamp;
233#if SAMEL
234    lxx=0;
235    strcpy(dbxname,dbp=dbnamp);
236    for (p=dbnamp=dbxname; *p; p++)
237        if (*p == '#') {
238            *p++ = '\0';
239            for (; isdigit(*p); p++) lxx=10*lxx+(int)*p-(int)'0';
240            if (*p) fatal(dbp);
241            if (lxx < 1 || lxx > MAXSAMEL) {
242                printf("*** dbname=%s\n",dbp);
243                fatal("term/dbname");
244            }
245            break;
246        }
247    if (trmtrace) printf("term - %s,%s,lxx=%d\n",dbp,dbnamp,lxx);
248#endif
249#if CICPP
250    trminit();
251    itrm_in = itrm;
252#else /* CICPP */
253    if (!ntrms)
254        trminit();
255    itrm_in = labs(itrm);
256#endif /* CICPP */
257#if CICPP
258    trmp = this;
259#else /* CICPP */
260    if (itrm_in < 0 || itrm_in >= maxntrm)
261        fatal("term/index");
262    trmp=vtrmp[itrm_in];
263#endif /* CICPP */
264#if CICPP
265    if (TRMnbytes < 0)
266        xtrmalloc((LONGX)IFBSIZ);
267#else /* CICPP */
268    if (!trmp)
269        trmp=vtrmp[trmalloc(itrm_in,(LONGX)IFBSIZ)];
270#endif /* CICPP */
271
272    dbxp=dbxstorp((char *)dbnamp);
273#if SAMEL
274    DBXiflxx=lxx;
275#endif
276
277#if BEFORE950724
278#else
279    if (strcmp((CONST char *)dbnamp,lasttrmread)) {
280        if (lasttrmread[0]) {
281            DBXSTRU *lastdbxp=dbxsrchp(lasttrmread);
282            if (lastdbxp) if (lastdbxp->dbxiflush) invflush(lasttrmread);
283        }
284        strcpy(lasttrmread,(CONST char *)dbnamp);
285    }
286#endif
287
288#if TRMTRACE
289printf("term - itrm=%ld  trmp=%p  dbxp=%p  keyp=%s\n",itrm,trmp,dbxp,keyp);
290#endif
291
292    if (TRMdbxp) {
293/* ver MULTI */
294#if SAMEL
295        if (strcmp(TDBname,dbnamp) || TDBiflxx != lxx) {        /* v3.2 */
296#else
297        if (strcmp(TDBname,(CONST char *)dbnamp)) {             /* v3.2 */
298/*
299   Para nao referenciar TDBname quando TRMdbxp liberado por dbxflush:
300   if ((TRMdbxp!=dbxp) || (strcmp(TDBname,(CONST char *)dbnamp)))
301   (HB 23/11/98)
302*/
303
304#endif
305            TRMl1buf.pos=0;
306            TRMl2buf.pos=0;
307#if 0
308printf("now:\n");
309printf("TRMl1buf.pos=%d TRMl2buf.pos=%d\n",TRMl1buf.pos,TRMl2buf.pos);
310#endif
311#if !LIND
312            if (TRMnbytes) ((IFPSTRU *)TRMifbuf)->ifpblk=0;     /* 26/02/92 */
313#endif
314        }
315    }
316
317    TRMdbxp=dbxp;
318
319/* ver MULTI */
320    if (!TDBifmap)
321        invsetup(dbnp,0L,0L,0L);
322
323    len=strlen((CONST char *)keyp);
324    for (p=keyp+len-1; len; )
325        if (isspace(*p)) {
326            p--; len--;
327        }
328        else
329            break;
330    if (len > LE2) len=LE2;
331    memcpy(TRMkey,keyp,len);
332    memset(TRMkey+len,' ',LE2-len); TRMkey[LE2]='\0';
333#if TRMTRACE
334printf("term - len=%d  TRMkey='%s'(%d)\n",len,TRMkey,strlen(TRMkey));
335#endif
336    if (len <= LE1) {
337        treecase=0; n1=LE1;
338        tc2=1; n2=LE2;
339    }
340    else {
341        treecase=1; n1=LE2;
342        tc2=0; n2=LE1;
343    }
344#if TRMTRACE
345printf("term - treecase=%d  n1=%d  tc2=%d  n2=%d\n",treecase,n1,tc2,n2);
346#endif
347
348    TRMrc=trmread(trmp,treecase,&k1p); TRMlidxp(treecase)=k1p;
349
350#if TRXTRACE
351memcpy(area,k1p,n1); area[n1]='\0';
352printf("term - TRMrc=%d (em %d)  k1p=%p=%s\n",TRMrc,treecase,k1p,area);
353#endif
354
355#if CICPP
356    if (TRMrc == RCNORMAL) {
357#else
358    if (TRMrc == RCNORMAL || itrm < 0) {
359#endif /* CICPP */
360        kn=n1;
361        TRMlcase=treecase; TRMlidxp(tc2)=NULL;
362    }
363    else {
364        if (tc2 == 0)
365            TRMkey[LE1-1]++;                    /* OLD: nothing */
366           
367        rc2=trmread(trmp,tc2,&k2p); TRMlidxp(tc2)=k2p;
368
369#if TRXTRACE
370memcpy(area,k2p,n2); area[n2]='\0';
371printf("term - TRMrc=%d (em %d)  k2p=%p=%s\n",TRMrc,tc2,k2p,area);
372#endif
373        if (rc2 == RCNORMAL) {
374            TRMrc=RCNEXT; kn=n2;                /* OLD: TRMrc=rc2 */
375            TRMlcase=tc2;
376        }
377        else {
378            n=strncmp((CONST char *)k1p,(CONST char *)k2p,LE1);             /* min */
379#if TRXTRACE
380memcpy(area,k1p,n1); area[n1]='\0';
381printf("term - n=%d[%d-%d] p/ strncmp(%s,",n,*k1p,*k2p,area);
382memcpy(area,k2p,n2); area[n2]='\0';
383printf("%s,%d)\n",area,LE1);
384#endif
385            if (n == 0) {               /* AOT/HB - 08/04/97 */
386               if (treecase) n=1;       /* get LE1 key */
387            }
388
389            if (n <= 0) {
390                memcpy(TRMkey,k1p,n1);         /* k1p is less than k2p */
391                TRMlcase=treecase;
392                kn=n1;
393            }
394            else {
395                memcpy(TRMkey,k2p,n2);         /* k2p is less than k1p */
396                TRMlcase=tc2;
397                TRMrc=rc2; kn=n2;
398            }
399        }
400    }
401    *(TRMkey+kn)='\0';
402#if SAMTRACE
403printf("term - TRMrc=%d  TRMlcase=%d,%p,%p  TRMkey=%s(%d) TRMliock=%d/%d \n",
404 TRMrc,TRMlcase,TRMlidxp(0),TRMlidxp(1),TRMkey,strlen(TRMkey),
405  TRMliock(0),TRMliock(1));
406#endif
407    posthdr1(trmp);                                        /* v3.2 */
408#if TRXTRACE
409printf("term - TRMrc=%d  TRMlcase=%d,%p,%p  TRMkey=%s(%d)\n",
410TRMrc,TRMlcase,TRMlidxp(0),TRMlidxp(1),TRMkey,strlen(TRMkey));
411#endif
412    if (trmtrace) printf("+++ term(%ld,%s,%s) = %s (%d) [%d:%ld,%d]\n",
413                                       itrm,dbnamp,keyp,TRMkey,TRMrc,
414                                       TRMlcase,
415                                       (TRMlcase)?TRMl2buf.pos:TRMl1buf.pos,
416                                       TRMliock(TRMlcase));
417
418#define TRMINVFLUSH 0
419#if TRMINVFLUSH /* 950724 */
420    invflush(DBXname);
421#endif
422
423    return(itrm_in);
424}
425
426
427#if CICPP
428int TRMSTRU :: xtrmread(int      treecase,
429                        UCHR   **retkeyp)
430#else /* CICPP */
431int trmread(trmp,treecase,retkeyp)                                    /*
432-----------
433                    //seta dbxp;
434                    seta invp;
435                    seta parametros de acordo com treecase;
436                    retorna RCEOF se liv = NEGLIV;              /* 3.1 *//*
437                    se trmp->key < primeiro termo, fica com primeiro termo;
438                    busca nos Nos o punt da Folha onde deve estar trmp->key;
439                    procura trmp->key nessa Folha, apontando por retkeyp;
440                    se trmp->key > ultimo termo, aponta para high-value;
441                    retorna RCEOF, RCNORMAL ou RCNEXT ou aborta
442                                                                      */
443TRMSTRU *trmp;      /* elemento de vtrmp, com chave ja' setada */
444int treecase;       /* indice da B*Tree a pesquisar */
445UCHR **retkeyp;     /* endereco do apontador para a chave encontrada */
446#endif /* CICPP */
447{
448    INVMAP  *invp;
449    N0STRU  *np;
450    L0STRU  *lp;
451    UCHR *wp,*w0p;
452    int idxesiz,idxksiz;
453    UCHR *kp;
454    PUNT punt;
455    int rc,n,n0;
456    UCHR *lbufp;
457    int lidxesiz,level,liv,kk;
458    UCHR *rp,*p;
459    int lxx;
460#if TRRTRACE /* 1 */
461    UCHR area[LE2+1];
462#endif
463#if SAMTRACx
464    int loop;
465    L1STRU *l1p;
466    L2STRU *l2p;
467    UCHR *ap;
468#endif
469
470#if CICPP
471    TRMSTRU *trmp = this;
472#endif /* CICPP */
473
474    invp=TDBifmap;
475#if TRRTRACE
476printf("trmread - trmp=%p  invp=%p\n",trmp,invp);
477#if SAMEL
478printf("trmread - name=%s,iflxx=%d,iflxn=%d \n",TDBname,TDBiflxx,invp->iflxn);
479#endif
480#endif
481    if (TRMrcase) if ((TRMrcase-1) != treecase) {
482#if TRETRACE
483printf("trmread - forcing highv for treecase=%d\n",treecase);
484#endif
485        *retkeyp=highv;
486        return(RCEOF);
487    }
488    if (invp->cn[treecase].liv == NEGLIV) {                     /* v3.1 */
489#if TRETRACE
490printf("trmread - highv for treecase=%d\n",treecase);
491#endif
492        *retkeyp=highv;
493        return(RCEOF);
494    }
495    if (treecase) {
496        idxksiz=LE2;
497        idxesiz=sizeof(N2IDXE);
498        lbufp=(UCHR *)(&TRMl2buf);
499        lidxesiz=sizeof(L2IDXE);
500    }
501    else {
502        idxksiz=LE1;
503        idxesiz=sizeof(N1IDXE);
504        lbufp=(UCHR *)(&TRMl1buf);
505        lidxesiz=sizeof(L1IDXE);
506    }
507    np=noderead(invp,treecase,0,invp->cn[treecase].posrx);
508    kp=TRMkey; wp=w0p=(unsigned char *)np->idxchars;     /* root node buffer */
509#if TRRTRACE
510printf("trmread - np->pos=%ld  np=%p  wp=%p\n",(LONGX)np->pos,np,wp);
511#endif
512    for (n=n0=np->ock; --n; ) {
513        wp+=idxesiz;                            /* next entry */
514        if (strncmp((CONST char *)kp,(CONST char *)wp,idxksiz) < 0) {
515            wp-=idxesiz;                        /* move back */
516            break;
517        }
518#if TRRTRACE
519memcpy(area,wp,idxksiz); area[idxksiz]='\0';
520printf("trmread - key > %s\n",area);
521#endif
522    }
523    punt= (treecase) ? ((N2IDXE *)wp)->punt : ((N1IDXE *)wp)->punt;
524    liv=invp->cn[treecase].liv;
525#if TRRTRACE
526memcpy(area,wp,idxksiz); area[idxksiz]='\0';
527printf("trmread - key em %s\n",area);
528printf("trmread - treecase=%d  em level=%d  punt=%ld  liv=%d\n",
529    treecase,0,(LONGX)punt,liv);
530#endif
531    for (level=1; level<=liv; level++) {
532        np=noderead(invp,treecase,level,punt);
533        wp=(unsigned char *)np->idxchars;
534        for (n=np->ock; --n; ) {
535            wp+=idxesiz;
536            if (strncmp((CONST char *)kp,(CONST char *)wp,idxksiz) < 0) {
537                wp-=idxesiz;
538                break;
539            }
540#if TRRTRACE
541memcpy(area,wp,idxksiz); area[idxksiz]='\0';
542printf("trmread - key > %s\n",area);
543#endif
544        }
545        punt= (treecase) ? ((N2IDXE *)wp)->punt : ((N1IDXE *)wp)->punt;
546#if TRRTRACE
547memcpy(area,wp,idxksiz); area[idxksiz]='\0';
548printf("trmread - key em %s\n",area);
549printf("trmread - treecase=%d  em level=%d  punt=%ld\n",
550    treecase,level,(LONGX)punt);
551#endif
552    }
553    if (punt >= 0)
554        fatal("trmread/punt");
555    punt= -punt;
556#if SAMEL
557    lxx=TDBiflxx;
558#else
559    lxx=0;
560#endif
561    lp=leafread(lbufp,invp,treecase,punt,lxx);
562    if (lrlrseek) TRMrseek(treecase)=lrlrseek;
563    if (lrlrsize) TRMrsize(treecase)=lrlrsize;
564    if ((UCHR *)lp != lbufp) fatal("trmread/leafread/bug/1");
565    TRMliock(treecase)=0;                                       /* vl.l */
566    wp=(unsigned char *)lp->idxchars; rc=RCNORMAL;
567#if SAMTRACx
568if (treecase) {
569 l2p=(L2STRU *)lbufp; ap=wp;
570 for (loop=0; loop < l2p->ock; loop++, ap+=lidxesiz)
571  printf("%d/%d=%.30s=%ld/%ld/%ld=%.30s=%ld/%ld/%ld \n",
572   loop+1,l2p->ock,
573   l2p->idx[loop].key,
574   l2p->idx[loop].info1,
575   l2p->idx[loop].info2,
576#if LIND
577   l2p->idx[loop].info3info4.info3,
578#else
579   0,
580#endif
581   ap,
582   ((L2IDXE *)ap)->info1,
583   ((L2IDXE *)ap)->info2,
584#if LIND
585   ((L2IDXE *)ap)->info3info4.info3);
586#else
587   0L);
588#endif
589 getchar();
590}
591else {
592 l1p=(L1STRU *)lbufp; ap=wp;
593 for (loop=0; loop < l1p->ock; loop++, ap+=lidxesiz)
594  printf("%d/%d=%.10s=%ld/%ld/%ld=%.10s=%ld/%ld/%ld \n",
595   loop+1,l1p->ock,
596   l1p->idx[loop].key,
597   l1p->idx[loop].info1,
598   l1p->idx[loop].info2,
599#if LIND
600   l1p->idx[loop].info3info4.info3,
601#endif
602   ap,
603   ((L1IDXE *)ap)->info1,
604   ((L1IDXE *)ap)->info2,
605#if LIND
606   ((L1IDXE *)ap)->info3info4.info3);
607#else
608   0L);
609#endif
610 getchar();
611}
612#endif
613    kk=strncmp((CONST char *)kp,(CONST char *)wp,idxksiz);
614    if (kk < 0) {
615/*      if (strncmp(wp,w0p+idxesiz,idxksiz) < 0) {   <== bug == */
616        if (n0 == 1 || strncmp((CONST char *)wp,(CONST char *)w0p+idxesiz,idxksiz) <= 0) {
617            rc=RCNEXT;
618            rp=wp;
619        }
620        else {
621if (trmtrace) {
622 printf("trmread - wp='");
623 for (p=wp,n=idxksiz; n--; p++) printf("%c(%02x)",*p,*p);
624 printf("'\n");
625 printf("trmread - w0='");
626 for (p=w0p+idxesiz,n=idxksiz; n--; p++) printf("%c(%02x)",*p,*p);
627 printf("'\n");
628}
629            fatal("trmread/leaf/less");
630        }
631    }
632#if TRRTRACE /* 1 */
633memcpy(area,wp,idxksiz); area[idxksiz]='\0';
634printf("trmread - folha=%s  kk=%d  l/k=%d/%d\n",area,kk,lidxesiz,idxksiz);
635#endif
636    if (kk > 0) {
637        TRMliock(treecase)++;   /* 18/12/95 */
638        rp=NULL;
639        for (n=lp->ock; --n; TRMliock(treecase)++) {            /* vl.l */
640#if ALPTRACE
641memcpy(area,wp,idxksiz); area[idxksiz]='\0';
642printf("trmread - folxx=%s  kk=%d  l/k=%d/%d\n",area,kk,lidxesiz,idxksiz);
643#endif
644            wp+=lidxesiz;
645#if ALPTRACE
646memcpy(area,wp,idxksiz); area[idxksiz]='\0';
647printf("trmread - folyy=%s  kk=%d  l/k=%d/%d\n",area,kk,lidxesiz,idxksiz);
648#endif
649#if SAMTRACE
650memcpy(area,wp,idxksiz); area[idxksiz]='\0';
651printf("trmread - wp=%s  kk=%d [%d]\n",area,kk,TRMliock(treecase));
652#endif
653            if (*wp <= MINLCHR) {                               /* vm.m */
654                wp[idxksiz]='\0';
655                printf("*** wp=%s\n",wp);
656                fatal("trmread/check/wp");
657            }
658            kk=strncmp((CONST char *)kp,(CONST char *)wp,idxksiz);
659#if TRRTRACE /* 1 */
660memcpy(area,wp,idxksiz); area[idxksiz]='\0';
661printf("trmread - wp=%s  kk=%d [%d]\n",area,kk,TRMliock(treecase));
662#endif
663            if (kk == 0) {
664                rp=wp;
665                rc=RCNORMAL;
666                break;
667            }
668            else
669               if (kk < 0) {
670                     rp=wp;
671                     rc=RCNEXT;
672                     break;
673                }
674        }
675        if (!rp)
676            if (lp->ps) {
677                lp=leafread(lbufp,invp,treecase,lp->ps,lxx);
678                if (lrlrseek) TRMrseek(treecase)=lrlrseek;
679                if (lrlrsize) TRMrsize(treecase)=lrlrsize;
680                if ((UCHR *)lp != lbufp) fatal("trmread/leafread/bug/2");
681#if SAMTRACE
682if (treecase) {
683 l2p=(L2STRU *)lbufp;
684 for (loop=0; loop < l2p->ock; loop++)
685  printf("%d/%d=%.30s=%ld/%ld/%ld\n",loop+1,l2p->ock,
686   l2p->idx[loop].key,
687   l2p->idx[loop].info1,
688   l2p->idx[loop].info2,
689#if SAMTRACE
690   l2p->idx[loop].info3info4.info3);
691#endif
692 getchar();
693}
694else {
695 l1p=(L1STRU *)lbufp;
696 for (loop=0; loop < l1p->ock; loop++)
697  printf("%d/%d=%.10s=%ld/%ld/%ld\n",loop+1,l1p->ock,
698   l1p->idx[loop].key,
699   l1p->idx[loop].info1,
700   l1p->idx[loop].info2,
701#if SAMTRACE
702   l1p->idx[loop].info3info4.info3);
703#endif
704 getchar();
705}
706#endif
707                TRMliock(treecase)=0;                           /* vl.l */
708                rp=(unsigned char *)lp->idxchars;
709                rc=RCNEXT;
710            }
711            else {
712                rp=highv;
713                rc=RCEOF;
714            }
715    }
716    else
717        rp=wp;
718    *retkeyp=rp;
719#if TRRTRACE
720memcpy(area,*retkeyp,idxksiz); area[idxksiz]='\0';
721printf("trmread - rc=%d  *retkeyp=%s[%d]\n",rc,area,TRMliock(treecase));
722#endif
723    return(rc);
724}
725
726
727/* ----------------------------- nxt.c ------------------------------ */
728#if CICPP
729LONGX TRMSTRU :: xnxterm(void)
730#else /* CICPP */
731LONGX nxterm(itrm)                                                     /*
732-----------
733                    abenda se vtrmp ou registro itrm nao inicializado;
734                    abenda se nenhuma folha foi carregada em term() anterior;
735                    se necessario, "incrementa" chave e carrega a da outra;
736                    compara e fica com a menor;
737                    move termo para trmp->trmkey;
738                    seta trmp->trmrc com RCEOF ou RCNORMAL;
739                    seta controles para chamadas subsequentes;
740                    chama posthdr1();
741                    retorna itrm
742                                                                      */
743LONGX itrm;          /* indice de vtrmp, para store */
744#endif /* CICPP */
745{
746    TRMSTRU *trmp;
747    UCHR *keyp;
748    int rc,lcase,len;
749    UCHR *l1idxp,*l2idxp;
750    int n,kn;
751    UCHR *p,*k1p,*k2p,*kp;
752    PUNT ps;
753    int lxx;
754#if CICPP
755    trmp = this;
756    LONGX itrm = NO_ITRM;
757#else /* CICPP */
758    if (!ntrms)
759        fatal("nxterm/ntrms");
760    trmp=vtrmp[itrm];
761    if (!trmp)
762        fatal("nxterm/trmp");
763#endif /* CICPP */
764    rc=TRMrc; keyp=TRMkey;
765    if (!*keyp)
766        fatal("nxterm/key");
767#if TRMTRACE
768printf("nxterm - itrm=%ld  trmp=%p  TRMrc=%d  TRMkey=%s\n",itrm,trmp,rc,keyp);
769#endif
770    if (rc == RCEOF)
771        return(itrm);
772    l1idxp=TRMlidxp(0); l2idxp=TRMlidxp(1);
773    lcase=TRMlcase; len=strlen((CONST char *)keyp);
774    if (len)                                            /* 06/04/89 */
775        for (p=keyp+len-1; len; --p)
776            if (*p != ' ')
777                break;
778            else
779                len--;
780    else
781        fatal("nxterm/len");
782    if (!l2idxp) {              /* 2nd tree not used in last term() call */
783        if (!l1idxp)
784            fatal("nxterm/l1idxp");
785        if (lcase != 0)
786            fatal("nxterm/l1case");
787        if (len < LE2) {
788            p=keyp+len; *p=0x01;
789            for (n=LE2-len; n--; )
790                *++p=' ';
791        }
792        else {
793            p=keyp+len-1; (*p)++;
794        }
795#if TRXTRACE
796printf("nxterm - calling trmread(1) - len=%d key='",len);
797for (p=keyp,n=LE2+1; n--; p++) printf("%c(%02x)",*p,*p);
798printf("'\n");
799#endif
800        trmread(trmp,1,&k2p);
801    }
802    else
803        k2p=l2idxp;
804    if (!l1idxp) {              /* 1st tree not used in last term() call */
805        if (!l2idxp)
806            fatal("nxterm/l2idxp");
807        if (lcase != 1)
808            fatal("nxterm/l2case");
809/*      if (len < LE1) {
810            p=keyp+len; *p=0x01;
811            for (n=LE1-len; n--; )
812                *++p=' ';
813        }
814        else {
815            p=keyp+len-1; (*p)++;
816        }                               */
817        if (len > LE1)                                  /* 06/04/89 */
818            len=LE1;
819        p=keyp+len-1; (*p)++; *++p='\0';
820#if TRXTRACE
821printf("nxterm - calling trmread(0) - len=%d key='",len);
822for (p=keyp,n=LE1+1; n--; p++) printf("%c(%02x)",*p,*p);
823printf("'\n");
824#endif
825        trmread(trmp,0,&k1p);
826    }
827    else
828        k1p=l1idxp;
829#if TRXTRACE /* 1 */
830printf("nxterm - 1. lcase=%d  k1p=",lcase);
831for (p=k1p,n=LE1; n--; p++) printf("%c",*p);
832printf("[%d]  k2p=",TRMliock(0));
833for (p=k2p,n=LE2; n--; p++) printf("%c",*p);
834printf("[%d]\n",TRMliock(1));
835#endif
836#if SAMEL
837    lxx=TDBiflxx;
838#else
839    lxx=0;
840#endif
841    switch (lcase) {
842    case 0: if (*k1p == *highv)                 /* eof */
843                break;
844            if (*k1p) {                         /* active */
845                k1p+=sizeof(L1IDXE);
846                TRMliock(0)++;                          /* vl.l */
847            }
848            if (!*k1p) {                        /* last or inactive */
849                ps=TRMl1buf.ps;
850                if (ps) {                       /* next page ptr */
851                    leafread((UCHR *)&TRMl1buf,TDBifmap,0,ps,lxx);
852                    if (lrlrseek) TRMrseek(0)=lrlrseek;
853                    if (lrlrsize) TRMrsize(0)=lrlrsize;
854                    k1p=TRMl1buf.idx[0].key;
855                    TRMliock(0)=0;                              /* vl.l */
856                }
857            }
858            if (!*k1p)                          /* wood never del */
859                k1p=highv;
860            break;
861    case 1: if (*k2p == *highv)                 /* eof */
862                break;
863            if (*k2p) {                         /* active */
864                k2p+=sizeof(L2IDXE);
865                TRMliock(1)++;                          /* vl.l */
866            }
867            if (!*k2p) {                        /* last or inactive */
868                ps=TRMl2buf.ps;
869                if (ps) {                       /* next page ptr */
870                    leafread((UCHR *)&TRMl2buf,TDBifmap,1,ps,lxx);
871                    if (lrlrseek) TRMrseek(1)=lrlrseek;
872                    if (lrlrsize) TRMrsize(1)=lrlrsize;
873                    k2p=TRMl2buf.idx[0].key;
874                    TRMliock(1)=0;                              /* vl.l */
875                }
876            }
877            if (!*k2p)                          /* wood never del */
878                k2p=highv;
879            break;
880    default: fatal("nxterm/lcase");
881    }
882#if TRXTRACE /* 1 */
883printf("nxterm - 2. lcase=%d  k1p=",lcase);
884for (p=k1p,n=LE1; n--; p++) printf("%c",*p);
885printf("[%d]  k2p=",TRMliock(0));
886for (p=k2p,n=LE2; n--; p++) printf("%c",*p);
887printf("[%d]\n",TRMliock(1));
888#endif
889    n=strncmp((CONST char *)k1p,(CONST char *)k2p,LE1);             /* min */
890    if (n <= 0) {
891        kp=k1p;                         /* k1p is less than k2p */
892        kn=LE1; lcase=0;
893    }
894    else {
895        kp=k2p;                         /* k2p is less than k1p */
896        kn=LE2; lcase=1;
897    }
898    memcpy(TRMkey,kp,kn); *(TRMkey+kn)='\0';
899    TRMrc = (*TRMkey == *highv) ? RCEOF : RCNORMAL;
900    TRMlcase=lcase;
901    TRMlidxp(0)=k1p;
902    TRMlidxp(1)=k2p;
903    posthdr1(trmp);                                             /* v3.2 */
904#if TRXTRACE
905printf("nxterm - TRMrc=%d  TRMlcase=%d,%p,%p  TRMkey=%s(%d)\n",
906TRMrc,TRMlcase,TRMlidxp(0),TRMlidxp(1),TRMkey,strlen(TRMkey));
907#endif
908    return(itrm);
909}
910
911/* ----------------------------- citrmh.c --------------------------- */
912/* ----------------------------- pst.c ------------------------------ */
913#if CICPP
914void TRMSTRU :: xposthdr1(void)
915#else /* CICPP */
916void posthdr1(trmp)                                                   /*
917-------------
918                    zera trmp->trmifhdr/ifseg;
919                    zera trmp->trmpost/pmfn/ptag/pocc/pcnt;
920                    inicializa trmp->pcurr/pchar/pleft/pcblk/pcpos;
921                    retorna se trmp->trmifbuf nao estiver alocado;
922                    retorna se RCEOF;
923                    le.ifp block, se necessario;
924                    carrega trmp->trmifhdr;
925                    duplica em trmp->trmifseg;
926                    aponta primeiro posting por trmp->trmpchar;
927                    seta trmp->trmpcblk com o .ifp blk do posting1;
928                    seta trmp->trmpcpos com o offset do posting1;
929                    sempre zera trmp->trmpost;
930                    sempre seta trmp->trmpleft com trmp->trmifhdr.ifsegp
931                                                                      */
932TRMSTRU *trmp;      /* elemento de vtrmp, apos nx/term(), com IFBSIZ */
933#endif /* CICPP */
934{
935    INFX info1;
936    INFO info2;
937#if LIND
938    INFX info3;
939    INFX bytes;
940#endif
941    UCHR *p,*inp;
942#if !LIND
943    int n;
944    INFO *hdrp,*segp,*hp;
945#endif
946
947#if CICPP
948    TRMSTRU *trmp = this;
949#endif /* CICPP */
950
951#if TRPTRACE
952printf("posthdr1 - trmp=%p  %s(%d)  TRMrc=%d\n",trmp,TRMkey,TRMlcase,TRMrc);
953#endif
954#if !LIND
955    hdrp=(INFO *)&TRMifhdr;
956    segp=(INFO *)&TRMifseg;
957#if TRPTRACE
958printf("posthdr1 - hdrp=%p  segp=%p  IFHDRINFOS=%d\n",hdrp,segp,IFHDRINFOS);
959#endif
960    for (n=IFHDRINFOS; n--; )
961        *hdrp++= *segp++=0;
962#endif
963    TRMpost=TRMpmfn=0;
964    TRMptag=TRMpocc=TRMpcnt=0;
965    TRMpcurr=TRMpchar=NULL; TRMpleft=0;
966#if !LIND
967    TRMpcblk=NULL; TRMpcpos=IFMAXTIV;
968#endif
969    if (TRMrc == RCEOF)
970        return;
971#if SAMTRACE
972printf("hdr1 - TRMrc=%d  TRMlcase=%d,%p,%p  TRMkey=%s(%d) lxx=%d\n",
973TRMrc,TRMlcase,TRMlidxp(0),TRMlidxp(1),TRMkey,strlen(TRMkey),TDBiflxx);
974#endif
975    if (TRMlcase) {            /* {} yes */
976        info1=((L2IDXE *)TRMlidxp(1))->info1;
977        info2=((L2IDXE *)TRMlidxp(1))->info2;
978#if LIND
979        info3=((L2IDXE *)TRMlidxp(1))->info3info4.info3;
980#endif
981    }
982    else {
983        info1=((L1IDXE *)TRMlidxp(0))->info1;
984        info2=((L1IDXE *)TRMlidxp(0))->info2;
985#if LIND
986        info3=((L1IDXE *)TRMlidxp(0))->info3info4.info3;
987#endif
988    }
989#if SAMTRACE
990printf("posthdr1 - info1=%"P_OFF_T"  info2=%ld  info3=%"P_OFF_T"\n",(LONG_LONG)info1,info2,(LONG_LONG)info3);
991#endif
992#if LIND
993    TRMyaddr=info1;
994    TRMypsts=info2;
995    if (info3 < 0) {
996        TRMycase=BITSTRING;
997        TRMysize=1; /* one byte */
998        TRMydocs=info2;
999        TRMydisk= -info3;
1000    }
1001    if (info3 == 0) {
1002        TRMycase=MFNSTRING;
1003        TRMysize=PMFNSIZ;
1004        TRMydocs=info2;
1005        TRMydisk=info2*PMFNSIZ;
1006    }
1007    if (info3 > 0) {
1008        TRMycase=CNTSTRING;
1009        TRMysize=PMFNSIZ+PCNTSIZ;
1010        TRMydocs=info3;
1011        TRMydisk=info2*(PMFNSIZ+PCNTSIZ);
1012    }
1013#endif
1014    if (TRMnbytes < IFBSIZ)                                     /* v3.2 */
1015        return;
1016    inp=TRMifbuf;
1017
1018#if !LIND
1019#if IFUPDATE
1020    if (trmifupd || *(INFO *)(inp) != info1) {
1021#else
1022    if (*(INFO *)(inp) != info1) {
1023#endif
1024#if TRPTRACE
1025printf("posthdr1 - info1=%ld  info2=%ld\n",(LONGX)info1,(LONGX)info2);
1026#endif
1027        postread(inp,TDBifmap,info1,TDBiflxx);                  /* v3.3 */
1028    }
1029    p=inp+INFOSIZE+(info2*INFOSIZE);  /* INFOSIZE = ifpblk */
1030    hdrp=(INFO *)&TRMifhdr;
1031    segp=(INFO *)&TRMifseg;
1032    for (hp=(INFO *)(p), n=IFHDRINFOS; n--; )
1033        *hdrp++= *segp++= *hp++;
1034#if CNV_PCBINUM
1035    ConvertIFP_PSTHDR((char *)&TRMifhdr);
1036    ConvertIFP_PSTHDR((char *)&TRMifseg);
1037#endif
1038#if TRPTRACE
1039printf("posthdr1/hdr - ifpnxtb=%ld  nxtp=%ld  totp=%ld  segp=%ld  segc=%ld\n",
1040    (LONGX)TRMifhdr.ifpnxtb,(LONGX)TRMifhdr.ifpnxtp,
1041    TRMifhdr.ifptotp,TRMifhdr.ifpsegp,TRMifhdr.ifpsegc);
1042#endif
1043    TRMpchar=p+IFHDRSIZ;
1044    TRMpcblk=info1; TRMpcpos=info2+IFHDRINFOS;
1045    TRMpost=0; TRMpleft=TRMifhdr.ifpsegp;
1046#if TRPTRACE
1047printf("posthdr1 - post=%ld  pchar=%p  pcblk=%ld pcpos=%ld  pleft=%ld\n",
1048    (LONGX)TRMpost,TRMpchar,(LONGX)TRMpcblk,(LONGX)TRMpcpos,TRMpleft);
1049#endif
1050#else //LIND
1051#if TRPTRACE
1052printf("posthdr1 - info1=%"P_OFF_T"  info2=%ld  info3=%"P_OFF_T"\n",(LONG_LONG)info1,info2,(LONG_LONG)info3);
1053#endif
1054    if (TRMydisk > IFBSIZ)
1055        bytes=IFBSIZ;
1056    else 
1057        bytes=TRMydisk;
1058    postread(inp,TDBifmap,TRMyaddr,(unsigned int)bytes,TDBiflxx);
1059    TRMyread=bytes;
1060    TRMyleft=bytes;
1061    p=inp;
1062    TRMpchar=p;
1063    TRMpost=0; TRMpleft=TRMypsts;
1064#if TRPTRACE
1065printf("posthdr1 - post=%ld  pchar=%p  yread=%"P_OFF_T" ydisk=%"P_OFF_T"  pleft=%ld\n",
1066    (long)TRMpost,TRMpchar,(LONG_LONG)TRMyread,(LONG_LONG)TRMydisk,(long)TRMpleft);
1067#endif
1068#endif //LIND
1069}
1070#if !LIND
1071#if CICPP
1072LONGX TRMSTRU :: xposting(LONGX nord)
1073#else /* CICPP */
1074LONGX posting(itrm,nord)                                               /*
1075------------
1076                    seta trmp;
1077                    retorna trmp->trmifhdr.ifptotp se nord = 0;
1078                    se nord > trmp->trmifhdr.ifptotp
1079                        zera trmp->trmpxxx e retorna um valor negativo;
1080                    incrementa trmp->trmpost e abenda se nord diferente;
1081                    le proximo segmento/bloco, se necessario;
1082                    decodifica posting;
1083                    mantem controles para chamadas subsequentes;
1084                    retorna trmp->trmpmfn
1085                                                                      */
1086LONGX itrm;          /* indice de vtrmp, para store */
1087LONGX nord;          /* numero de ordem do posting desejado ou 0L */
1088#endif /* CICPP */
1089{
1090    TRMSTRU *trmp;
1091    LONGX total;
1092    INFO info1,info2,*hp,*sp;
1093    int n;
1094    UCHR *p,*inp;
1095#if CICPP
1096    trmp = this;
1097    LONGX itrm = NO_ITRM;
1098#else /* CICPP */
1099    if (!ntrms)
1100        fatal("posting/ntrms");
1101    trmp=vtrmp[itrm];
1102    if (!trmp)
1103        fatal("posting/trmp");
1104#endif /* CICPP */
1105    if (TRMnbytes < IFBSIZ)                                     /* 05/07/91 */
1106        fatal("posting/TRMnbytes");
1107    total=TRMifhdr.ifptotp;
1108#if TRPTRACE
1109printf("posting - itrm=%ld  trmp=%p  rc=%d  nord=%ld  post=%ld/%ld\n",
1110    itrm,trmp,TRMrc,nord,TRMpost,total);
1111#endif
1112    if (nord == 0)
1113        return(total);
1114    if (nord > total) {
1115        TRMpost=TRMpmfn=NULL;
1116        TRMptag=TRMpocc=TRMpcnt=NULL;
1117        TRMpcurr=TRMpchar=NULL; TRMpleft=NULL;
1118        return(-1L);
1119    }
1120    TRMpost++;
1121    if (nord != TRMpost)
1122        fatal("posting/nord");
1123    while (!TRMpleft) {
1124        info1=TRMifseg.ifpnxtb;
1125        if (!info1)
1126            fatal("posting/ifpnxtb");
1127        info2=TRMifseg.ifpnxtp;
1128#if TRPTRACE
1129printf("posting - pleft=%ld  info1=%ld  info2=%ld\n",
1130    TRMpleft,info1,info2);
1131#endif
1132        inp=TRMifbuf;
1133#if IFUPDATE
1134        if (trmifupd || *(PUNT *)(inp) != info1) {
1135#else
1136        if (*(PUNT *)(inp) != info1) {
1137#endif
1138#if TRPTRACE
1139printf("posting - new seg - info1=%ld  info2=%ld \n",
1140    (LONGX)info1,(LONGX)info2);
1141#endif
1142            postread(inp,TDBifmap,info1,TDBiflxx);              /* v3.3 */
1143        }
1144        p=inp+INFOSIZE+(info2*INFOSIZE);      /* INFOSIZE = ifpblk */
1145        for (sp=(INFO *)&TRMifseg, hp=(INFO *)p, n=IFHDRINFOS; n--; )
1146            *sp++= *hp++;
1147#if CNV_PCBINUM
1148        ConvertIFP_PSTHDR((char *)&TRMifseg);
1149#endif
1150        TRMpleft=TRMifseg.ifpsegp; TRMpchar=p+IFHDRSIZ;
1151        TRMpcblk=info1;
1152        TRMpcpos=info2+IFHDRINFOS;
1153#if TRPTRACE
1154printf("posting - post=%ld  pchar=%p  pcblk=%ld pcpos=%ld  pleft=%ld\n",
1155    (LONGX)TRMpost,TRMpchar,(LONGX)TRMpcblk,(LONGX)TRMpcpos,TRMpleft);
1156#endif
1157    }
1158    if (TRMpcpos >= (IFMAXTIV-1)) {
1159        info1=TRMpcblk+1; info2=0;              /* 22/02/89 */
1160        inp=TRMifbuf;
1161        postread(inp,TDBifmap,info1,TDBiflxx);                  /* v3.3 */
1162#if TRPTRACE                                    /* 22/02/89 */
1163printf("posting - new blk -  info1=%ld  info2=%ld \n",
1164    (LONGX)info1,(LONGX)info2);
1165#endif
1166        TRMpchar=inp+INFOSIZE;                  /* INFOSIZE = ifpblk */
1167        TRMpcblk=info1;
1168        TRMpcpos=info2;                         /* 22/02/89 */
1169#if TRPTRACE                                    /* 22/02/89 */
1170printf("posting - post=%ld  pchar=%p  pcblk=%ld pcpos=%ld  pleft=%ld\n",
1171    (LONGX)TRMpost,TRMpchar,(LONGX)TRMpcblk,(LONGX)TRMpcpos,TRMpleft);
1172#endif
1173    }
1174    postpost(trmp);
1175    TRMpleft--; TRMpcurr=TRMpchar;
1176    TRMpchar+=IFPSTSIZ; TRMpcpos+=IFPSTINFOS;
1177    return(TRMpmfn);
1178}
1179#else /* LIND posting() */
1180#if CICPP
1181LONGX TRMSTRU :: xposting(LONGX nord)
1182#else /* CICPP */
1183LONGX posting(itrm,nord)                                               /*
1184------------                                                          */
1185LONGX itrm;          /* indice de vtrmp, para store */
1186LONGX nord;          /* numero de ordem do posting desejado ou 0L */
1187#endif /* CICPP */
1188{
1189    TRMSTRU *trmp;
1190    LONGX total,mfn;
1191    off_t bytes,xbyte;
1192    int loop2,n,blshift; 
1193    UCHR *inp;
1194#if CICPP
1195    trmp = this;
1196    LONGX itrm = NO_ITRM;
1197#else /* CICPP */
1198    if (!ntrms)
1199        fatal("posting/ntrms");
1200    trmp=vtrmp[itrm];
1201    if (!trmp)
1202        fatal("posting/trmp");
1203#endif /* CICPP */
1204    if (TRMnbytes < IFBSIZ)                                     /* 05/07/91 */
1205        fatal("posting/TRMnbytes");
1206    total=TRMypsts;
1207#if TRPTRACE
1208printf("posting - itrm=%ld  trmp=%p  rc=%d  nord=%ld  post=%ld/%ld\n",
1209    itrm,trmp,TRMrc,nord,TRMpost,total);
1210#endif
1211    if (nord == 0)
1212        return(total);
1213    mfn=(TRMpmfn == 0)?0:TRMpmfn+1;
1214    TRMpmfn=TRMptag=TRMpocc=TRMpcnt=0;
1215    if (nord > total) {
1216        TRMpost=0;
1217        TRMpcurr=TRMpchar=NULL; TRMpleft=0;
1218        return(-1L);
1219    }
1220    TRMpost++;
1221    if (nord != TRMpost)
1222        fatal("posting/nord");
1223    for (; !TRMpmfn; ) {
1224        if (TRMyleft < TRMysize) {
1225            if (TRMyleft) {
1226                if (TRMycase == BITSTRING) fatal("posting/align/BITSTRING");
1227                blshift=TRMyleft;
1228                TRMyread-=blshift;
1229            }
1230            else blshift=0;
1231            inp=TRMifbuf;
1232            bytes=TRMydisk-TRMyread;
1233            if (bytes <= 0)
1234                fatal("posting/bytes");
1235            if (bytes > IFBSIZ)
1236                bytes=IFBSIZ;
1237            xbyte=TRMyaddr+TRMyread;
1238            postread(inp,TDBifmap,xbyte,(unsigned int)bytes,TDBiflxx);
1239            TRMyread+=bytes;
1240            TRMyleft=bytes;
1241#if TRPTRACE
1242printf("posting - new blk  \n");
1243#endif
1244            TRMpchar=inp;
1245        }
1246        if (TRMycase == BITSTRING) {
1247            if (!*TRMpchar) {
1248                TRMpchar++; TRMyleft--;
1249                mfn+=8;
1250                continue;
1251            }
1252            loop2 = 8 - (mfn&BY8RMASK);
1253#if TRPTRACE
1254printf("posting - TRMpchar=%p=%02x TRMyleft=%ld      mfn=%ld/%d\n",
1255 TRMpchar,*TRMpchar,TRMyleft,mfn,loop2);
1256#endif
1257            for (; loop2--; mfn++) {
1258                n=mfn&BY8RMASK;
1259#if TRPTRACE
1260printf("posting - TRMpchar=%p=%02x TRMyleft=%ld  now mfn=%ld/%d %d/%02x\n",
1261 TRMpchar,*TRMpchar,TRMyleft,mfn,loop2,n,bitmask[n]);
1262#endif
1263                if (*TRMpchar & bitmask[n]) {
1264                    TRMpmfn=mfn;
1265                    break;
1266                }
1267            }
1268            if (!TRMpmfn) {
1269                TRMpchar++; TRMyleft--;
1270                continue;
1271            }
1272            TRMpleft--; TRMpcurr=TRMpchar;
1273            if (n == BY8RMASK) {
1274                TRMpchar++; TRMyleft-=1;
1275            }
1276        }
1277        else {
1278            postpost(trmp);
1279            TRMpleft--; TRMpcurr=TRMpchar;
1280            TRMpchar+=TRMysize; TRMyleft-=TRMysize;
1281        }
1282    }
1283    if (!TRMpmfn)
1284        fatal("posting/TRMpmfn");
1285    return(TRMpmfn);
1286}
1287#endif /* LIND */
1288
1289#if CICPP
1290void TRMSTRU :: xpostpost(void)
1291#else /* CICPP */
1292void postpost(trmp)                                                   /*
1293-------------
1294                    aponta origem para trmp->trmpchar;
1295                    decodifica em trmp->trmpmfn...trmp->trmpcnt
1296                                                                      */
1297TRMSTRU *trmp;      /* elemento de vtrmp, posting() */
1298#endif /* CICPP */
1299{
1300    unsigned char *p,*q;
1301
1302#if CICPP
1303    TRMSTRU *trmp = this;
1304#endif /* CICPP */
1305
1306#if TRPTRACE
1307char *pp;
1308int pn;
1309printf("postpost - post=%ld  ifbuf=%p  char=%p=%02x left=%ld\n",
1310   TRMpost,&TRMifbuf,TRMpchar,*TRMpchar,TRMpleft);
1311for (pp=TRMpchar, pn=8; pn--; pp++) printf("%02x ",*pp); printf("\n");
1312#endif
1313#if LIND
1314    if (TRMycase != MFNSTRING && TRMycase != CNTSTRING)
1315        fatal("postpost/TRMycase");
1316#endif
1317
1318  p=TRMpchar;
1319  q=(unsigned char *)&TRMpmfn;
1320  q[M1] = *p++;
1321  q[M2] = *p++;
1322  q[M3] = *p++;
1323#if LIND4
1324  q[M4] = *p++;
1325#else
1326  q[M4]=(unsigned char)0;
1327#endif
1328#if !LIND
1329  q=(unsigned char *)&TRMptag;
1330  q[T1] = *p++;
1331  q[T2] = *p++;
1332  q=(unsigned char *)&TRMpocc;
1333  q[O1] = *p++;
1334  q[O2]=(unsigned char)0;
1335#endif
1336#if LIND
1337if (TRMycase == CNTSTRING) {
1338#endif
1339  q=(unsigned char *)&TRMpcnt;
1340  q[C1] = *p++;
1341  q[C2] = *p++;
1342#if LIND
1343 }
1344#endif
1345
1346#if TRPTRACE
1347printf("postpost - mfn=%ld  tag=%d  occ=%d  cnt=%d\n",
1348   TRMpmfn,TRMptag,TRMpocc,TRMpcnt);
1349#endif
1350}
1351
Note: See TracBrowser for help on using the browser.