root/trunk/ciutl.c

Revision 389, 18.9 kB (checked in by heitor.barbieri, 3 weeks ago)

essage first commit
Line 
1#include <stdio.h>
2#include <ctype.h>
3#include <string.h>
4#include "cisis.h"
5
6#if CICPP
7#include "cirec.hpp"
8#include "citrm.hpp"
9#include "cirun.hpp"
10#endif /* CICPP */
11
12#if !CICPP || CIAPI_SOURCE
13#if GEN_UTL
14/* ********************************************************************** */
15/* * prtcontrol/prtleader/prtfields/prtxref/prtdir                      * */
16/* ********************************************************************** */
17/* ***************************** prtcontrol ***************************** */
18#if ANSI
19LONGX prtcontrol(RECSTRU *recp, char dbname[])                           /*
20---------------
21                                        display control
22                                                                        */
23#else
24LONGX prtcontrol(recp,dbname)
25RECSTRU *recp;
26char dbname[];
27#endif
28{
29    if (dbname)
30        if (*dbname) printf("*%s\n",dbname);
31    printf(" nxtmfn nxtmfb nxtmfp  t  reccnt mfcxx1 mfcxx2 mfcxx3    RC\n");
32    printf("%6"_LD_" %6"_LD_" %6d   %d %6"_LD_" %6"_LD_" %6"_LD_" %6"_LD_" %6d\n",
33        MF0nxtmfn,MF0nxtmfb,MF0nxtmfp,MF0mftype,
34        MF0reccnt,MF0mfcxx1,MF0mfcxx2,MF0mfcxx3,RECrc);
35    return(MF0nxtmfn);
36}
37/* ***************************** prtleader ****************************** */
38#if ANSI
39LONGX prtleader(RECSTRU *recp, LONGX mfn)                                 /*
40--------------
41                                        display leader
42                                                                        */
43#else
44LONGX prtleader(recp,mfn)
45RECSTRU *recp;
46LONGX mfn;
47#endif
48{
49    char x;
50    if (mfn)
51        printf("mfn=%6"_LD_"\n",mfn);
52    printf(
53       "mfn=%6"_LD_"|mfrl=%5"_LD_"|mfbwb=%6"_LD_"|mfbwp=%5d|base=%5"_LD_"|nvf=%3d|status=%2d|",
54        MFRmfn,(LONGX)MFRmfrl,MFRmfbwb,MFRmfbwp,(LONGX)MFRbase,MFRnvf,MFRstatus);
55    x=' ';
56#if MULTI
57    if (RECgdbw) x = (RECgdbl) ? '*' : '+';
58#endif
59    printf("%2d%c\n",RECrc,x);      /* tty line overflow */
60    return(mfn);
61}
62/* ***************************** prtfields ****************************** */
63#if ANSI
64LONGX prtfields(RECSTRU *recp, LONGX mfn)                                 /*
65--------------
66                                        display fields
67                                                                        */
68#else
69LONGX prtfields(recp,mfn)
70RECSTRU *recp;
71LONGX mfn;
72#endif
73{
74    int xdir,loop1;
75    FFI loop2;
76    UBYTE *p;
77    if (mfn)
78        printf("mfn=%6"_LD_"%s\n",mfn,(MFRstatus != ACTIVE) ? " [DELETED]" : " ");
79    for (xdir=0, loop1=MFRnvf; loop1--; xdir++) {
80        printf("%3u  %c",DIRtag(xdir),OPENFCHR);
81        for (p=(UBYTE*)FIELDP(xdir), loop2=DIRlen(xdir); loop2--; p++)
82            printf("%c",*p);
83        printf("%c\n",CLOSFCHR);
84    }
85    return(mfn);
86}
87#if CIAPI_SOURCE
88LONGX prtxref  (CISISX *cisisxp, RECSTRU *recp, LONGX mfn)                         
89#else /* CIAPI_SOURCE */
90#if ANSI
91LONGX prtxref  (RECSTRU *recp, LONGX mfn)                                 /*
92------------
93                                        display xref
94                                                                        */
95#else
96LONGX prtxref(recp,mfn)
97RECSTRU *recp;
98LONGX mfn;
99#endif
100#endif /* CIAPI_SOURCE */
101{
102    LONGX xrftiv,comb;
103    int xtiv,comp,flagnew,flagmod;
104    DBXSTRU *dbxp;
105    dbxp=RECdbxp;
106    xrftiv=DBXxribp->xrmfptr[(xtiv=(MFRmfn-1)%XRMAXTIV)];
107    comb = recxrefb;
108    comp = recxrefp;
109    flagnew=recxrefn;
110    flagmod=recxrefm;
111    if (mfn) printf("mfn=%6"_LD_"|",mfn);
112    printf("comb=%5"_LD_"|comp=%3d|%c|%c|%5"_LD_"+%03d=%08lx\n",
113            comb,comp,
114            flagnew?'N':' ',flagmod?'M':' ',
115            DBXxribp->xrxrpos,xtiv,xrftiv);
116    return(mfn);
117}
118#if ANSI
119LONGX prtdir   (RECSTRU *recp, LONGX mfn)                                 /*
120-----------
121                                        display dir
122                                                                        */
123#else
124LONGX prtdir(recp,mfn)
125RECSTRU *recp;
126LONGX mfn;
127#endif
128{
129    int xdir,loop1;
130        for (xdir=0,loop1=MFRnvf; loop1--; xdir++) {
131            if (mfn)
132                printf("mfn=%6"_LD_"|",mfn);
133            printf("dir=%3d|tag=%5u|pos=%5"_LD_"|len=%5"_LD_"\n",
134                xdir+1,DIRtag(xdir),(LONGX)DIRpos(xdir),(LONGX)DIRlen(xdir));
135        }
136    return(mfn);
137}
138
139/* **************************************************************** */
140/* fldxocc */
141/* **************************************************************** */
142/* *************************** fldxocc  ******************************** */
143#if CIAPI_SOURCE
144int fldocc(CISISX *cisisxp, RECSTRU *recp, int diridx)
145#else /* CIAPI_SOURCE */
146int fldocc(ridx,diridx)
147LONGX ridx;
148int diridx;
149#endif /* CIAPI_SOURCE */
150{
151#if !CIAPI_SOURCE
152    RECSTRU *recp;  /* mandatory for defines REC,MFR,DIR,FIELDP */
153#endif /* !CIAPI_SOURCE */
154    int xocc,xdir;
155#if !CIAPI_SOURCE
156    recp=vrecp[ridx];
157#endif /* !CIAPI_SOURCE */
158
159    for (xocc=0, xdir=0; xdir <= diridx; xdir++)
160        if (DIRtag(xdir) == DIRtag(diridx))
161            xocc++;
162    if (xocc == 0) fatal("fldocc");
163    return(xocc);
164}
165/* *************************** recfieldx **************************** */
166#if CIAPI_SOURCE
167char *recfield(CISISX *cisisxp, char *areap,RECSTRU *recp, int tag,int iocc,char *defaultp)
168#else /* CIAPI_SOURCE */
169char *recfield(areap,ridx,tag,iocc,defaultp)
170char *areap;
171LONGX ridx;
172int tag;
173int iocc;
174char *defaultp;
175#endif /* CIAPI_SOURCE */
176{
177    int xdir;
178    FFI n;
179    unsigned char *p;
180#if CIAPI_SOURCE
181    if ((xdir=recp->xfieldx(tag,iocc)) >= 0) {
182        p=( unsigned char*)FIELDP(xdir); n=DIRlen(xdir);
183    }
184#else /* CIAPI_SOURCE */
185    if ((xdir=fieldx(ridx,tag,iocc)) >= 0) {
186        p=VFIELDP(ridx,xdir); n=VDIRlen(ridx,xdir);
187    }
188#endif /* CIAPI_SOURCE */
189    else
190        if (defaultp)
191            n=strlen((char*)(p=(unsigned char*)defaultp));
192        else
193            n=strlen((char*)(p=(unsigned char*)"\0"));
194    if (!areap)
195#if CIAPI_SOURCE
196        if ((areap=new char[(ALLOPARM)n+1]) == (char *)ALLONULL)
197#else /* CIAPI_SOURCE */
198        if ((areap=(char *)ALLOC((ALLOPARM)n+1)) == (char *)ALLONULL)
199#endif /* CIAPI_SOURCE */
200            fatal("recfield/ALLOC");
201    memcpy(areap,p,n); areap[n]='\0';
202    return(areap);
203}
204#endif /* GEN_UTL */
205
206/* *************************** showcore ***************************** */
207#if CICPP
208unsigned LONGX showcore(char *s)
209#else /* CICPP */
210unsigned LONGX showcore(s)
211char *s;
212#endif /* CICPP */
213{
214    char *sp;
215    unsigned LONGX left;
216    sp = "::";
217    if (s)
218        if (*s)
219            sp = s;
220#if CIAPI_SOURCE
221    left=0;
222#else /* CIAPI_SOURCE */
223    left=CORELEFT();
224#endif /* CIAPI_SOURCE */
225
226    printf("%s: coreleft=%"_LD_"\n",sp,left);
227    return(left);
228}
229#if GEN_UTL
230/* ***************************** 12345678 ******************************* */
231/* ***************************** prtifcnt   ***************************** */
232#if ANSI
233LONGX prtifcnt  (TRMSTRU *trmp, char dbname[])                           /*
234-------------
235                                        display .cnt
236                                                                        */
237#else
238LONGX prtifcnt  (trmp,dbname)
239TRMSTRU *trmp;
240char dbname[];
241#endif
242{
243    CNSTRU *cp;
244    int treecase;
245    if (*dbname)
246        printf("*%s\n",dbname);
247    printf("idtype ordn ordf   n   k  liv    ");
248    printf("posrx nmaxpos  fmaxpos  abnormal\n");
249    for (treecase=0; treecase < 2; treecase++) {
250        cp= &TDBifmap->cn[treecase];
251        printf("%4d  %4d %4d %4d%4d",cp->idtype,cp->ordn,cp->ordf,cp->n,cp->k);
252        printf("%4d %8"_LD_,cp->liv,cp->posrx);
253        printf("%8"_LD_" %8"_LD_"    %4d\n",cp->nmaxpos,cp->fmaxpos,cp->abnormal);
254    }
255    return(0L);
256}
257/* *************************** chkxref  ******************************** */
258#if ANSI
259LONGX chkxref  (RECSTRU *recp, LONGX mfn, int delta)                      /*
260------------
261                                        check xref from MFRmfn on
262                                                                        */
263#else
264LONGX chkxref(recp,mfn,delta)
265RECSTRU *recp;
266LONGX mfn;
267int delta;
268#endif
269{
270    LONGX xrftiv,xrftiva,wcomb;
271    int flagnew,flagmod,wcomp;
272    DBXSTRU *dbxp;
273    dbxp=RECdbxp;
274    for ( ; ; mfn+=delta) {
275        if (mfn <= 0L) return(0L);
276        if (recxref(recp,mfn,&wcomb,&wcomp) == RCEOF) return(0L);
277        xrftiv=DBXxribp->xrmfptr[(MFRmfn-1)%XRMAXTIV];
278        xrftiva=labs(xrftiv);
279        flagnew=(xrftiva & XRXMASKN);
280        flagmod=(xrftiva & XRXMASKU);
281        if(flagnew || flagmod)
282            return(mfn);
283    }
284}
285
286/* ********************************************************************** */
287/* * reccopy/recfgets/loaductb/loadactb                                 * */
288/* ********************************************************************** */
289/* ***************************** reccopy ******************************** */
290#if CIAPI_SOURCE
291int reccopy(CISISX *cisisxp, RECSTRU *upirec,RECSTRU *upcrec,RECSTRU *recp,LONGX mfn)
292{
293    upirec->xrecord(upcrec->recdbxp->dbxname,upcrec->recmfp->m0.m0nxtmfn);         /* dbnp,etc */
294    if (MFRmfrl > upirec->recnbytes ) fatal("reccopy/check/mfrl");
295    memcpy(upirec->recmfp->mx,MFX,MFRmfrl); /* mfn included */
296    upirec->recmfp->m1.m1mfn=mfn;
297    return(0);
298}
299#else /* CIAPI_SOURCE */
300int reccopy(upirec, upcrec, recp, mfn)
301LONGX upirec;
302LONGX upcrec;
303RECSTRU *recp;
304LONGX mfn;
305{
306    record(upirec,VRDBname(upcrec),VMF0nxtmfn(upcrec));         /* dbnp,etc */
307    if (MFRmfrl > VRECnbytes(upirec)) fatal("reccopy/check/mfrl");
308    memcpy(VMFX(upirec),MFX,MFRmfrl); /* mfn included */
309    VMFRmfn(upirec)=mfn;
310    return(0);
311}
312#endif /* CIAPI_SOURCE */
313/* ********************* recfgets ********************************* */
314#if MFUPDATE
315#if CIAPI_SOURCE
316int recfgets(CISISX *cisisxp, RECSTRU *crec, RECSTRU *irec, char line[], FFI linsiz, FILE *fpconv)
317#else /* CIAPI_SOURCE */
318#if ANSI
319int recfgets(LONGX crec, LONGX irec, char line[], FFI linsiz, FILE *fpconv)
320#else
321int recfgets(crec,irec,line,linsiz,fpconv)
322LONGX crec;
323LONGX irec;
324char line[];
325FFI linsiz;
326FILE *fpconv;
327#endif
328#endif /* CIAPI_SOURCE */
329{
330    char *p,*p0,*batchp,c;
331    int tag,rc;
332    FFI len,/*left*,*/n;
333    char *buffup;
334    LONGX nbytes,left;
335
336    /* truncate linsiz to fgets() maximum */
337    if (linsiz > (FFI)INT_MAX) linsiz=(FFI)INT_MAX;
338
339    /* allocate working area */
340    nbytes=linsiz+BUFSIZ;
341    if (nbytes > ALLOMAXV) nbytes=ALLOMAXV;
342#if CICPP
343    if ((buffup=new char[nbytes]) == (char *)ALLONULL)
344#else /* CICPP */
345    if ((buffup=(char *)ALLOC((ALLOPARM)nbytes)) == (char *)ALLONULL)
346#endif /* CICPP */
347        fatal("recfgets/ALLOC");
348    left=nbytes-1;
349    rc= ~EOF;
350    *buffup='\0';
351    c = (line[0]) ? line[0] : '|';
352    if (fgets(line,linsiz-1,fpconv)) {
353        for (batchp=buffup, p=line, tag=1; *p; tag++) {
354            for (len=0, p0=p; *p; p++, len++)
355                if (*p == c || *p == '\n')
356                    break;
357                if (len) {
358                    sprintf(batchp,"H%d %d ",tag,len);
359                    batchp+=(n=strlen(batchp));
360                    if (left <= (n+len))
361                        fatal("recfgets/buffup");
362                    for (left-=(n+len); len--; )
363                        *batchp++ = *p0++;
364                    *batchp = '\0';
365                }
366                p++;
367            }
368        }
369    else
370        rc=EOF;
371#if CIAPI_SOURCE
372    irec->xrecord(crec->recdbxp->dbxname,crec->recmfp->m0.m0nxtmfn);
373    irec->recrc=RCNORMAL;
374    irec->recmfp->m1.m1status=ACTIVE;    /* PDEL status is DELETED */
375    if (*buffup) {
376                p=irec->xfldupdat(buffup);
377#else /* CIAPI_SOURCE */
378    record(irec,VRDBname(crec),VMF0nxtmfn(crec));
379    VRECrc(irec)=RCNORMAL;
380    VMFRstatus(irec)=ACTIVE;    /* PDEL status is DELETED */
381    if (*buffup) {
382        p=fldupdat(irec,buffup);
383#endif /* CIAPI_SOURCE */
384        if (p) {
385            printf("+++fldupdat='%s'\n",p);
386            fatal("recfgets/fldupdat");
387        }
388    }
389    /* deallocate working area */
390#if CICPP
391    delete(buffup);
392#else /* CICPP */
393    free(buffup);
394#endif /* CICPP */
395    return(rc);
396}
397#endif /* MFUPDATE */
398
399#endif /* GEN_UTL */
400
401#endif /* !CICPP || CIAPI_SOURCE */
402
403
404
405/* ******************** subfield routines ************************** */
406#if !CICPP
407UBYTE sfldchr = SFLDCHR;
408#endif /* CICPP */
409
410#if CICPP
411UBYTE *subfldp(UBYTE *fldp,
412               UBYTE  dlm,
413               FFI   *lenp)
414#else /*CICPP*/
415UBYTE *subfldp(fldp,dlm,lenp)
416UBYTE *fldp;
417UBYTE dlm;
418FFI *lenp;
419#endif /*CICPP*/
420{
421    UBYTE *p,*retp,ucdlm,ucdata;
422    FFI n,len;
423    ucdlm = toupper(dlm);
424    for (retp=NULL, p=fldp, n=0, len= *lenp;  n < len; p++) {
425        n++;
426        if (*p == SFLDCHR)
427            if (n < len) {
428                ucdata=toupper(*(p+1));
429                if (ucdata == ucdlm) {
430                    retp=p+2;
431                    n++;
432                    break;
433                }
434            }
435            else {
436                n--;
437                break;
438            }
439    }
440    if (retp)
441        *lenp = *lenp - n;
442    else
443        *lenp = 0;
444    return(retp);
445}
446
447#if CICPP
448FFI subfldn(UBYTE *sfldp,
449            FFI    len)
450#else /*CICPP*/
451FFI subfldn(sfldp,len)
452UBYTE *sfldp;
453FFI len;
454#endif /*CICPP*/
455{
456    UBYTE *p;
457    FFI n;
458    if (!sfldp)
459        return(0);
460    for (n=0, p=sfldp; n < len; p++)
461        if (*p == SFLDCHR)
462            break;
463        else
464            n++;
465    return(n);
466}
467
468#if CICPP
469FFI subfield(UBYTE *fldp,
470             FFI    fldl,
471             UBYTE  dlm,
472             UBYTE *areap)
473#else /*CICPP*/
474FFI subfield(fldp,fldl,dlm,areap)
475UBYTE *fldp;
476FFI fldl;
477UBYTE dlm;
478UBYTE *areap;
479#endif /*CICPP*/
480{
481    UBYTE *p;
482    FFI n;
483    static FFI l;
484    l=fldl;
485    p=subfldp(fldp,dlm,&l);
486    n=subfldn(p,l);
487    if (areap) {
488        memcpy(areap,p,n);
489        areap[n]='\0';
490    }
491    return(n);
492}
493
494
495/* *************************** loaductb  ******************************** */
496#define TRACEUC 0
497#if VAX
498#define UCTABCOLS 16
499#else
500#define UCTABCOLS 32
501#endif
502
503#if !CICPP
504int loaduct0 = 0;               /* last char (zero) is not loaded */
505#endif /* CICPP */
506
507#if CICPP
508char *loaductb(DBXSTRU *dbxp,
509               char *gidbnp,                    /* dbn.par */
510               char *uctbp,
511               char *ucfilp)
512#else /*CICPP*/
513char *loaductb(gidbnp,uctbp,ucfilp)
514char *gidbnp;                   /* dbn.par */
515char *uctbp;
516char *ucfilp;
517#endif /*CICPP*/
518{
519    int fd,loop,lrecl,n,loop2;
520    char line[BUFSIZ];
521    unsigned char *p,*tabp;
522    tabp=(unsigned char *)uctbp;
523
524#if CICPP
525    CISISX * cisisxp = dbxp->cisisxp;
526#endif /* CICPP */
527
528#if 0
529000 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 ... 030 031
530032 ....
531224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 ... 254 255
532#endif
533    lrecl=UCTABCOLS*4;
534#if CRLF
535    lrecl++;    /* 0D 0A for CIREAD with _read */
536#endif
537    ucfilp=dbxcipar(gidbnp,ucfilp,'=');
538#if TRACEUC
539printf("loaductb - %s lrecl=%d\n",ucfilp,lrecl);
540#endif
541    if ((fd=OPEN(ucfilp,O_RDONLY)) <= 0)
542        return(NULL);
543    for (loop=0; CIREAD(fd,line,lrecl) == lrecl; ) {
544        line[lrecl]='\0';
545#if TRACEUC
546printf("%s",line);
547#endif
548        if (line[lrecl-1] != '\n')
549            return(NULL);
550        for (p=(unsigned char *)line, loop2=UCTABCOLS; loop2--; p+=4) {
551            sscanf((CONST char *)p,"%d",&n);
552            if (n < 0 || n > 255 || loop > 255)
553                return(NULL);
554            if (loaduct0 == 0) {
555                if (loop) if (n == 0) return(NULL);
556            }
557            tabp[loop]=n;
558#if TRACEUC
559printf("(%3d) %c -> %c (%3d)\n",loop,loop,tabp[loop],tabp[loop]);
560#endif
561            loop++;
562        }
563    }
564    CLOSE(fd);
565    if (loop != 256)
566        return(NULL);
567    return(uctbp);
568}
569
570/* *************************** loadactb  ******************************** */
571#if CICPP
572char *loadactb(DBXSTRU *dbxp,
573               char *gidbnp,                    /* dbn.par */
574               char *actbp,
575               char *acfilp)
576#else /*CICPP*/
577char *loadactb(gidbnp,actbp,acfilp)
578char *gidbnp;                   /* dbn.par */
579char *actbp;
580char *acfilp;
581#endif /*CICPP*/
582{
583    int fd,ne,k;
584    char chr;
585
586#if CICPP
587    CISISX *cisisxp = dbxp->cisisxp;
588#endif /* CICPP */
589
590#if 0
591...
592140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 160 ... 164 165
593#endif
594
595    actbp[ne=0]='\0'; /* empty table */
596
597    acfilp=dbxcipar(gidbnp,acfilp,'=');
598    if ((fd=OPEN(acfilp,O_RDONLY)) <= 0) return(NULL);
599
600    for (k=0; CIREAD(fd,&chr,1) == 1; ) {
601
602        if (chr < '0' || chr > '9') {
603            if (k > 255) return(NULL);
604            if (k) actbp[ne++]=(unsigned char)k;
605            k=0;
606        }
607        else k=k*10+((int)chr-(int)'0');
608    }
609
610    if (k) {
611        if (k > 255) return(NULL);
612        actbp[ne++]=(unsigned char)k;
613    }
614
615    actbp[ne++]='\0';   /* end of table = isisactab */
616
617    CLOSE(fd);
618    return(actbp);
619}
620
621/*-----------------------------------------------------------------------*/
622/* encodepst                                                             */
623/*-----------------------------------------------------------------------*/
624#if CICPP
625void encodepst(POSTSTRU *pstp,
626               LONGX mfn,
627               unsigned short tag,
628               unsigned short occ,
629               unsigned short cnt)
630#else /*CICPP*/
631void encodepst( pstp, mfn, tag, occ, cnt )
632POSTSTRU *pstp;
633LONGX mfn;
634unsigned short tag,occ,cnt;
635#endif /*CICPP*/
636{
637  unsigned char vc[sizeof(POSTSTRU)],*q;
638  int i=0;
639#define TRACENCODEPST 0
640#if TRACENCODEPST
641  unsigned char *p;
642#endif
643  q=(unsigned char *)&mfn;
644  vc[i++] = q[M1];
645  vc[i++] = q[M2];
646  vc[i++] = q[M3];
647#if LIND4
648  vc[i++] = q[M4];
649#else
650  //vc[i++] = (unsigned char)0;
651#endif
652  q=(unsigned char *)&tag;
653  vc[i++] = q[T1];
654  vc[i++] = q[T2];
655  q=(unsigned char *)&occ;
656  vc[i++] = q[O1];
657  q=(unsigned char *)&cnt;
658  vc[i++] = q[C1];
659  vc[i++] = q[C2];
660  memcpy(pstp,vc,sizeof(POSTSTRU));
661#if TRACENCODEPST
662  printf("+++ encodepst: %"_LD_"/%u/%u/%u =",mfn,tag,occ,cnt);
663  for (p=(unsigned char *)pstp, i=0; i<sizeof(POSTSTRU); i++) printf(" %02x",p[i]);
664  printf("\n");
665#endif
666}
667
668/*-----------------------------------------------------------------------*/
669/* decodepst                                                             */
670/*-----------------------------------------------------------------------*/
671#if CICPP
672void decodepst(POSTSTRU *pstp,
673               LONGX     *mfnp,
674               unsigned short *tagp,
675               unsigned short *occp,
676               unsigned short *cntp)
677#else /*CICPP*/
678void decodepst( pstp, mfnp, tagp, occp, cntp )
679POSTSTRU *pstp;
680LONGX *mfnp;
681unsigned short *tagp,*occp,*cntp;
682#endif /*CICPP*/
683{
684  unsigned char *p,*q;
685  p=(unsigned char *)pstp;
686  q=(unsigned char *)mfnp;
687  q[M1] = *p++;
688  q[M2] = *p++;
689  q[M3] = *p++;
690#if LIND4
691  q[M4] = *p++;
692#else
693  q[M4] = (unsigned char)0;
694#endif /* LIND4 */
695  q=(unsigned char *)tagp;
696  q[T1] = *p++;
697  q[T2] = *p++;
698  q=(unsigned char *)occp;
699  q[O1] = *p++;
700  q[O2]=(unsigned char)0;
701  q=(unsigned char *)cntp;
702  q[C1] = *p++;
703  q[C2] = *p++;
704}
705
706
707/* ***************************** bobkey ***************************** */
708
709#if CICPP
710FFI bobkey(char *keyp,
711           FFI   klen,
712           char *areap,
713           FFI   maxlen,
714           int   leading,
715           int   middle,
716           int   trailing)
717#else /*CICPP*/
718FFI bobkey(keyp,klen,areap,maxlen,leading,middle,trailing)
719char *keyp;
720FFI klen;
721char *areap;
722FFI maxlen;
723int leading;
724int middle;
725int trailing;
726#endif /*CICPP*/
727{
728    FFI len,hn;
729    char *p;
730
731    len=klen;
732    if (!klen) len=strlen(keyp);
733
734    if (trailing) {
735        /* BEFORE BOB - elimina brancos/ctlchr's finais */
736        while (len) if ((UCHR)(keyp[len-1]) <= MINLCHR) len--; else break;
737    }
738
739    hn=0;
740    if (leading) {
741        /* BOB - elimina brancos/ctlchr's iniciais */
742        for (p=keyp; hn < len; hn++) if ((UCHR)(*p++) > MINLCHR) break;
743        len-=hn;
744    }
745
746    if (len > maxlen) {
747        len=maxlen;
748        if (trailing) {
749            /* BEFORE BOB - elimina brancos/ctlchr's finais - 13/08/96 */
750            p=keyp+hn;
751            while (len) if ((UCHR)(p[len-1]) <= MINLCHR) len--; else break;
752        }
753    }
754    memcpy(areap,keyp+hn,len); areap[len]='\0';
755
756    if (middle) {
757        /* BOB - corrige ctlchr's centrais  */
758        for (hn=0, p=areap; hn < len; hn++, p++) if ((UCHR)(*p) < MINLCHR) *p=MINLCHR;
759    }
760
761    return(len);
762}
Note: See TracBrowser for help on using the browser.