root/tags/5.4.pre05/ciupd.c @ 1

Revision 1, 51.1 kB (checked in by heitor.barbieri, 2 years ago)

Criação do svn para Cisis.
Line 
1/*
2CCOPTS = -DINCPRECX=0 -DEXCFMCGI=1 -DEXCFMXML=1
3$(CC) -DINCPROCX=0 $(CCOPTS) wtrig2.c
4*/
5
6#include <stdio.h>
7#include <string.h>
8#include <ctype.h>
9#include "cisis.h"
10
11#ifndef PROCXSLT
12#if UNIX
13#define PROCXSLT  0
14#else /* UNIX */
15#define PROCXSLT  0
16#endif /* UNIX */
17#endif
18#if PROCXSLT
19#include <libxslt/transform.h>
20#include <libxslt/xsltutils.h>
21#endif /* PROCXSLT */
22
23#ifndef INCPROCX      // proc Y / proc T (bug if called by cifm3.c)      /* usa CIIFU (+FST(+FMT)) */
24#define INCPROCX  1
25#define INCPROCXT 1
26#endif
27
28#ifndef INCPRECX      // 6words/if= in Gsplit (ciupdsplt.c)              /* usa CITRM */
29#define INCPRECX  1
30#endif
31
32#ifndef INCPRCCX      // socket client with Gload (ciupdsocx.c)          /* */
33#define INCPRCCX  1
34#endif
35
36#ifndef INCPRSSX      // server                                          /* */
37#define INCPRSSX  0   // 1
38#endif
39
40#if INCPRCCX
41#ifndef PROCXSOCKREC
42#define PROCXSOCKREC 1    // include ciupdsocx.c
43#endif /* PROCXSOCKREC */
44#endif /* INCPRCCX */
45
46
47#if CICPP
48#if INCPROCX
49#include "ciifu.hpp"
50#endif
51#endif
52
53#if CICPP
54#if INCPRECX
55#include "citrm.hpp"
56#endif
57#endif
58
59#ifdef USE_ERROR_SYS
60#include <ui_win.hpp>
61#include <errorsys.hpp>
62extern MY_ERROR_SYSTEM * errsys;
63extern MESS_SYSTEM *mess;
64extern UIW_WINDOW * wprogress;
65#include <textdb.hpp>
66#define USE_INFO_SYS
67#endif
68
69/* ----------------------------- upd.c ------------------------------ */
70
71#define RUCTRACE    00
72#define RUCTRACX    00
73#define RUCTRAC2    00
74#define RUFTRACE    0
75#define RUGTRACE    0
76#define RUHTRACE    0
77#define RUITRACE    0
78#define RUJTRACE    0
79#define RUKTRACE    0
80#define RUFxRACE    0
81
82#define RUUTRACE    0
83
84#define MULTRACE    1           /* multrace runtime switch */
85
86#if !CICPP
87
88int  recisis0_m=1;              /* recisis0() init .mst */
89int  recisis0_s=0;              /* recisis0() system file type */
90
91#endif /* CICPP */
92
93#if !CICPP
94#define CIUPD_CISISX_SOURCE 1
95#include "cisisx.c"
96#endif
97
98#if PROCXSLT
99#include "cidump.c"
100#endif /* PROCXSLT */ 
101
102#if CICPP
103#define NO_IREC  -1L
104#endif /* CICPP */
105
106#if MULTI
107
108#if CICPP
109int RECSTRU :: xrecunlck(int option)
110#else /* CICPP */
111int recunlck(irec,option)                                              /*
112------------
113                    se option = EWLOCK faz EWL unlock
114                    se option = DELOCK faz DEL unlock
115                    se option = RLOCK faz RL unlock;
116                    retorna RCNORMAL ou aborta
117                                                                      */
118LONGX irec;          /* vrecp[] element defining RECdbxp/MFRmfn */
119int option;
120#endif /* CICPP */
121{
122    RECSTRU *recp;
123    DBXSTRU *dbxp;
124    FFI oldgdbl;
125    LONGX mfn;
126    int fd,rc;
127    FFI n;
128    int uok=0,force=0;
129    LONGX comb;      /* gdb getmfr comb */
130    int comp;       /* gdb getmfr comp */
131
132#if CICPP
133#if RUUTRACE
134    LONGX irec = NO_IREC;
135#endif
136    RECSTRU *wrecp=NULL;
137    recp=this;
138#else
139    LONGX wrec;
140    if (irec < 0 || irec >= maxnrec) fatal("recunlck/irec");
141    if (!nrecs || !vrecp[irec]) fatal("recunlck/recinit");
142    recp=vrecp[irec];
143#endif
144
145    /* get input information */
146    dbxp=RECdbxp;
147    mfn=MFRmfn;
148
149    /* keep old RECgdbl */
150    oldgdbl=RECgdbl;
151
152    /* allocate working control record / record leader */
153#if CICPP
154    try { wrecp=new RECSTRU(cisisxp); wrecp->xrecalloc(sizeof(M0STRU)); }
155    catch (BAD_ALLOC) { return(-1); }
156    wrecp->recdbxp=dbxp;
157    recp=wrecp;
158#else /* CICPP */
159    for (wrec=maxnrec; wrec--; ) {
160        if (!vrecp[wrec]) /* ja' decrementado */ break;
161    }
162    if (wrec < 0) return(-1);
163    recallok(wrec,sizeof(M0STRU));
164    VRECdbxp(wrec)=dbxp;
165    recp=vrecp[wrec];
166#endif /* CICPP */
167
168
169    if (option & FORCE) { force=1; option-=FORCE; }
170
171    if (option & RDELOCK) option = (mfn) ? RLOCK : DELOCK;
172
173    if (option != EWLOCK && option != DELOCK && option != RLOCK)
174        fatal("recunlck/option");
175
176#if RUUTRACE
177 printf("recunlck - irec=%ld  dbn=%s/%ld  unlck=%d\n",irec,DBXname,mfn,option);
178#endif
179
180    if (DBXnetws == MONONETS) {
181        if (multrace)
182            printf("<u> %s/%ld [%s MONONETS]\n",
183              DBXname,mfn,(option&RDELOCK)?((option==RLOCK)?"RL":"DEL"):"EWL");
184        return(RCNORMAL);
185    }
186
187    if (!DBXmsopn) fatal("recunlck/msopn");
188    dbxopenw(DBXname,DBXname,mx1extp,&DBXmsopn,&DBXmsopw,"recunlck/msopn/w");
189    fd=DBXmsopn;
190
191    /* step 1: lock the .mst file and get the ctl rec */
192
193    if (multrace) printf("<u> %s .mst lock \n",DBXname);
194#if BEFORE950220
195    /* .mst file lock: lock */
196    if (dbxflock(dbxp,"M")) fatal("recunlck/file lock");
197    /* get the current ctl rec */
198    keeplock=REClock; REClock=NOLOCK;
199    if (recread(recp,0L) != RCNORMAL) fatal("recunlck/read/ctl");
200    REClock=keeplock;
201    /* check another's exclusive write lock */
202    if (MF0mfcxx3 && !DBXewlxx && !force) {
203        if (multrace) printf("<u> %s has exclusive write lock\n",DBXname);
204        fatal("recunlck/exclusive write lock");
205    }
206#else
207    if (dbxflock(dbxp,"M")) {
208        if (multrace) printf("<u> %s .mst lock/denied \n",DBXname);
209        if (dbxewlrc) return(RCLOCK);
210        fatal("recunlck/file lock");
211    }
212    /* wait another's exclusive write lock */
213    if (force) {
214        if (LSEEK64(DBXmsopn,0L,SEEK_SET) != 0) fatal("recunlck/force/lseek");
215        n=CIREAD(DBXmsopn,MFX,sizeof(M0STRU));
216#if CNV_PCBINUM
217        ConvertMST_CTLSTRUCT(MFX);
218#endif
219        if (n != sizeof(M0STRU)) {
220            if (dbxewlrc) return(RCLOCK);
221            fatal("recunlck/force/read");
222        }
223    }
224    else
225        if (dbxwlock(dbxp,MFX,dbxwloop)) {
226            if (multrace) printf("<u> %s .mst ewl is on !!!\n",DBXname);
227            if (dbxewlrc) return(RCLOCK);
228            fatal("recunlck/must wait ewl");
229        }
230    /* copy MFX to what will be written */
231    memcpy(DBXmsibp,MFX,sizeof(M0STRU));
232#endif
233
234    /* check data entry lock */
235    if (option & RDELOCK && (!MF0mfcxx2 || !DBXdelxx) && !force) {
236        if (multrace)
237            printf("<u> %s/mfcxx2=%ld delxx=%d\n",DBXname,MF0mfcxx2,DBXdelxx);
238        fatal("recunlck/data entry lock is off");
239    }
240
241    /* step 2: logical unlock */
242
243    if (option == EWLOCK || option == DELOCK) {         /* EWL or DEL */
244        if (option == EWLOCK) {
245            /* unflag exclusive write lock */
246            if (MF0mfcxx3 || DBXewlxx) {
247                if (MF0mfcxx3) MF0mfcxx3--;
248                if (DBXewlxx) DBXewlxx--;
249                /* update input buffer */
250                ((M0STRU *)DBXmsibp)->m0mfcxx3=MF0mfcxx3;
251                uok=1;
252            }
253        }
254        else {
255            /* unflag data entry lock */
256            if (MF0mfcxx2 || DBXdelxx) {
257                if (MF0mfcxx2) MF0mfcxx2--;
258                if (DBXdelxx) DBXdelxx--;
259                /* update input buffer */
260                ((M0STRU *)DBXmsibp)->m0mfcxx2=MF0mfcxx2;
261                uok=1;
262            }
263        }
264        /* write it back */
265        if (uok) {
266            if (LSEEK64(fd,0L,SEEK_SET) != 0)
267                fatal("recunlck/lseek/ctl");
268#if DBXMSTXL /* AOT 18/06/2002 */
269    if (DBXmstxl) {
270                ((M0STRU *)DBXmsibp)->m0mftype += DBXmstxl * 256;
271    }
272#endif
273#if CNV_PCBINUM
274            memcpy(cnv_pcbuff,DBXmsibp,sizeof(M0STRU));
275            ConvertMST_CTLSTRUCT(cnv_pcbuff);
276            if (CIWRITE(fd,cnv_pcbuff,sizeof(M0STRU)) != sizeof(M0STRU))
277#else
278            if (CIWRITE(fd,DBXmsibp,sizeof(M0STRU)) != sizeof(M0STRU))
279#endif
280                fatal("recunlck/write/ctl");
281#if DBXMSTXL /* AOT 18/06/2002 */
282    if (DBXmstxl) {
283                ((M0STRU *)DBXmsibp)->m0mftype &= 0x00FF;
284    }
285#endif
286        }
287
288    } /* end of data entry lock */
289
290    else {                                              /* RL */
291
292        /* get its xref to rewrite the leader segment */
293        recreadl=1; /* leader only */
294        rc=recread(recp,mfn);
295        comb=recxrefb; comp=recxrefp;
296#ifndef USE_ERROR_SYS
297        if (rc == RCEOF || rc == RCPDEL) fatal("recunlck/EOFPDEL");
298#else
299        if (!(rc == RCEOF || rc == RCPDEL)) {
300#endif
301
302        /* reset existing record lock and call recwmast */
303        if (oldgdbl || (force && RECgdbw)) {
304            if (multrace)
305              printf("<u> %s/%ld mfrl=%04x=+%d\n",DBXname,mfn,RECgdbl,MFRmfrl);
306            /* write back the leader segment */
307#if CICPP
308            recwmast(NULL,comb,comp,0,1); /* leader only */
309#else
310            recwmast(NULL,recp,comb,comp,0,1); /* leader only */
311#endif /* CICPP */
312            uok=1;
313        }
314#ifdef USE_ERROR_SYS
315                }
316#endif
317    } /* end of record unlock */
318
319    /* step 3: .mst file unlock */
320
321    if (multrace)
322        printf("<u> %s .mst unlock [%s %s]\n",DBXname,
323              (option&RDELOCK)?((option==RLOCK)?"RL":"DEL"):"EWL",
324              (uok)?"off":"unlock denied");
325
326    if (dbxulock(dbxp,"M")) fatal("recunlck/file unlock");
327
328#if CICPP
329    if (wrecp) delete wrecp;
330    recp=this;
331#else
332#if BEFORE20000809
333    if (wrec) if (vrecp[wrec]) {
334#else
335    if (wrec >= 0) if (vrecp[wrec]) {
336#endif
337        FREE(vrecp[wrec]); vrecp[wrec]=NULL; nrecs--;
338    }
339    recp=vrecp[irec];
340#endif
341
342    if (uok) {
343        RECgdbl=RECgdbw=0;
344        return(RCNORMAL);
345    }
346
347    return(RCEOF);
348}
349#endif /* MULTI */
350
351
352#if CICPP
353int RECSTRU :: xrecupdat(void)
354#else /* CICPP */
355int recupdat(crec,irec)                                                 /*
356------------
357                    abenda se vrecp nao inicializado;
358                    abenda se registros crec/irec ainda nao alocados;
359                    abenda se tipo de crec diferente de TYPEMF0;
360                    abenda se mfn menor do que 1 ou maior do que MAXMFN;
361                    seta dbxp de irec igual ao de crec;
362                    chama recwrite();
363                    retorna RCNORMAL
364                                                                      */
365LONGX crec;          /* indice de vrecp, para recwrite() */
366LONGX irec;          /* indice de vrecp, para recwrite() */
367#endif /* CICPP */
368{
369
370    RECSTRU *recp, *crecp;
371    LONGX mfn;
372    int rc;
373
374    if (rectrace) multrace=1;
375
376#if CICPP
377    try { crecp = new RECSTRU(cisisxp); }
378    catch (BAD_ALLOC) { fatal("recupdat/ALLOC/crecp"); }
379
380    crecp->xrecalloc(sizeof(M0STRU));
381    recp =this;
382    crecp->xrecord(RDBname,0L);
383
384    recp=crecp;         /* tmp */
385
386#else /* CICPP */
387
388    if (!nrecs)
389        fatal("recupdat/RECINIT");
390
391    if (crec < 0 || crec >= maxnrec) fatal("recupdat/crec/index");
392    if (irec < 0 || irec >= maxnrec) fatal("recupdat/irec/index");
393
394    recp=vrecp[crec];   /* tmp */
395
396#endif /* CICPP */
397
398    if (MF0nxtmfn < 1) fatal("recupdat/crec/nxtmfn");
399
400    if (MF0nxtmfb < 1) fatal("recupdat/crec/nxtmfb");
401
402    if (MF0mftype != MSMFTUSR &&
403        MF0mftype != MSMFTMSG) fatal("recupdat/crec/mftype");
404
405    if (MF0nxtmfn == 1)
406        if (MF0mftype != MSMFTMSG)
407            if (MF0nxtmfp <= sizeof(M0STRU)) fatal("recupdat/crec/nxtmfp/1");
408
409    if (MF0nxtmfp > MSBSIZ) fatal("recupdat/crec/nxtmfp/MSBSIZ");
410
411#if CICPP
412    recp=this;
413#else /* CICPP */
414    crecp=vrecp[crec]; recp=vrecp[irec];
415#endif /* CICPP */
416
417    if (!crecp || !recp)
418        fatal("recupdat/RECALLOC");
419
420    if (crecp->rectype != TYPEMF0)
421        fatal("recupdat/TYPEMF0");
422
423    if ((mfn=MFRmfn) < 1 || mfn > MAXUPDMFN)
424#if MULTI
425      if (!(RECwlock & NEWREC && MFRmfn == 0))
426#endif
427        fatal("recupdat/mfn");
428
429#if !CICPP
430#if RUCTRACE || RUCTRAC2
431printf("recupdat - crec=%ld  irec=%ld  dbn(crec)=%s  mfn=%ld  opw=%d,%d\n",
432 crec,irec,VRDBname(crec),mfn,VRDBxropw(crec),VRDBmsopw(crec));
433#endif
434#endif /* CICPP */
435
436    RECdbxp=crecp->recdbxp;             /* get dbxp from control record */
437#if CICPP
438    rc=recwrite(crecp);
439#else
440    rc=recwrite(crecp,recp);
441#endif /* CICPP */
442
443#if RUCTRACE
444#if CICPP
445    recp=crecp;
446#else
447    recp=vrecp[crec];
448#endif /* CICPP */
449    printf("recupdat - RECrc=%d  Ctlmfr: %ld,%ld,%ld,%d,%d,%ld,%ld,%ld,%ld\n",
450        RECrc,
451        MF0ctlmfn,MF0nxtmfn,MF0nxtmfb,MF0nxtmfp,
452        MF0mftype,MF0reccnt,MF0mfcxx1,MF0mfcxx2,MF0mfcxx3);
453#if CICPP
454    recp = this;
455#else
456    recp=vrecp[irec];
457#endif /* CICPP */
458    printf("recupdat - RECrc=%d  Leader: %ld,%d,%ld,%d,%d,%d,%d\n",
459        RECrc,MFRmfn,MFRmfrl,MFRmfbwb,MFRmfbwp,MFRbase,MFRnvf,MFRstatus);
460    printf("recupdat - rc=%d\n",rc);
461#endif
462#if !CICPP
463#if RUCTRAC2
464printf("recupdat : crec=%ld  irec=%ld  dbn(crec)=%s  mfn=%ld  opw=%d,%d\n",
465 crec,irec,VRDBname(crec),mfn,VRDBxropw(crec),VRDBmsopw(crec));
466#endif
467#endif /* CICPP */
468
469#if CICPP
470    delete crecp;
471#endif /* CICPP */
472
473    return(rc);
474}
475
476
477#if CICPP
478int RECSTRU :: xrecwrite(RECSTRU *crecp)
479#else /* CICPP */
480int recwrite(crecp,recp)                                              /*
481------------
482                    seta dbxp e ms0p desce crecp;
483                    seta mfn desde recp;
484                    abenda de dbxp diferentes;
485                    obtem ptr para .mst e seu (mfn) status em .xrf;
486                    regrava o registro recp;
487                    altera e regrava o registro crecp;
488                    mantem .xrf;
489                    retorna RCNORMAL ou aborta
490                                                                      */
491RECSTRU *crecp;     /* elemento de vrecp, para info/store nxtmfn,mfb,mfp */
492RECSTRU *recp;      /* elemento de vrecp, para info/store mfbwb,mfbwp  */
493#endif /* CICPP */
494{
495    DBXSTRU *dbxp;
496    M0STRU *ms0p;   /* defines MS0 */
497    M1STRU *mshp;   /* defines MSH */
498
499    LONGX mfn;
500    LONGX lastmfn;
501    int newblk;
502
503    int rc;
504    FFI n;
505    XRPTR xrftiv;    /* gdb .xrf pointer */
506    LONGX comb;      /* gdb getmfr comb */
507    int comp;        /* gdb getmfr comp */
508
509    M1STRU header;  /* to read LEADER bytes */
510
511#if CNV_PCFILES
512    char unibuff[MSNVSPLT]; /* CNV_PCFILES/recwrite - mshp */
513#endif
514
515    int pend;       /* if update is pending */
516    int pendnew;    /* if update is pending - newrec */
517    int pendupd;    /* if update is pending - update */
518
519    LONGX thiscomb;
520    off_t xbyte;
521    int thiscomp;
522    LONGX nxtcomp;
523
524    int flagnew;        /* record will be written as a newrec */
525    unsigned inplace;   /* NEVER or MAYBE */
526
527#if MULTI
528    int isnewrec;
529#if BEFORE950220
530    int keeplock;
531#endif
532#endif
533
534#if DBXMSTXL
535int pow, vtot;
536#endif
537
538#define NEVER 0
539#define MAYBE 1
540
541#if CICPP
542    RECSTRU *recp = this;
543#endif /* CICPP */
544
545    dbxp=crecp->recdbxp;
546
547#if BEFORE950724
548    if (!DBXxropn) fatal("recwrite/xropn");
549    if (!DBXmsopn) fatal("recwrite/msopn");
550#else
551    if (!DBXxropn || !DBXmsopn) mstsetup(DBXname,0L,0L);
552#endif
553
554    dbxopenw(DBXname,DBXname,xx1extp,&DBXxropn,&DBXxropw,"recwrite/xropn/w");
555    dbxopenw(DBXname,DBXname,mx1extp,&DBXmsopn,&DBXmsopw,"recwrite/msopn/w");
556
557    if (!DBXxropw) fatal("recwrite/xropw");
558    if (!DBXmsopw) fatal("recwrite/msopw");
559
560    if (!DBXxribp) fatal("recwrite/xribp");
561    if (!DBXmsibp) fatal("recwrite/msibp");
562
563#if CICPP
564    ms0p= &crecp->recmfp->m0;
565#else
566    ms0p= &crecp->recmf.m0;
567#endif /* CICPP */
568
569    if (MS0mftype != MSMFTUSR && MS0mftype != MSMFTMSG)
570        fatal("recwrite/mftype");
571
572    mfn=MFRmfn;
573
574#if RUCTRACE
575printf("recwrite - dbn/%d=%s  mfn=%ld  nxtmfn=%ld  nxtmfb=%ld  nxtmfp=%d\n",
576 MS0mftype,DBXname,mfn,MS0nxtmfn,MS0nxtmfb,MS0nxtmfp);
577#endif
578
579#if MULTI
580    isnewrec=RECwlock & NEWREC;
581
582    if (DBXnetws != MONONETS) {
583        if ((RECwlock & WUNLOCK && RECwlock & WLOCK) ||
584           !(RECwlock & WUNLOCK || RECwlock & WLOCK))
585            fatal("recwrite/WLOCK/WUNLOCK");
586        /* step 1: lock the .mst file and get the current ctl rec */
587        /* assure data entry lock has been granted (also ewl) */
588        if (!DBXdelxx) fatal("recwrite/lock/data entry lock is off");
589        /* assure record lock has been granted */
590        if (!isnewrec)
591            if (!RECgdbl) fatal("recwrite/lock/record lock needed");
592        /* .mst file lock: lock */
593        if (multrace) printf("<w> %s .mst lock \n",DBXname);
594#if BEFORE950220
595        if (dbxflock(dbxp,"M")) fatal("recwrite/lock/file lock");
596        /* reset internal lock flag and get the current ctl rec */
597        keeplock=crecp->reclock; crecp->reclock=NOLOCK;
598        if (recread(crecp,0L) != RCNORMAL) fatal("recwrite/lock/read");
599        crecp->reclock=keeplock;
600        /* check another's exclusive write lock - should never occur */
601        if (MS0mfcxx3 && !DBXewlxx) {
602            if (multrace) printf("<w> %s has exclusive write lock\n",DBXname);
603            fatal("recwrite/lock/exclusive write lock");
604        }
605#else
606        if (dbxflock(dbxp,"M")) {
607            if (multrace) printf("<w> %s .mst lock/denied \n",DBXname);
608            if (dbxewlrc) return(RCLOCK);
609            fatal("recwrite/lock/file lock");
610        }
611        /* wait another's exclusive write lock */
612        if (dbxwlock(dbxp,(char *)ms0p,dbxwloop)) {
613            if (multrace) printf("<w> %s .mst ewl is on !!!\n",DBXname);
614            if (dbxewlrc) return(RCLOCK);
615            fatal("recwrite/lock/must wait ewl");
616        }
617#endif
618
619        /* check data entry lock */
620        if (!MS0mfcxx2) fatal("recwrite/lock/data entry lock/mfcxx2");
621        if (!DBXdelxx) fatal("recwrite/lock/data entry lock needed");
622
623        /* assign nxtmfn */
624        if (isnewrec) {
625            if (!mfn) {
626                mfn=MFRmfn=MS0nxtmfn;
627                if (multrace) printf("<w> %s -> mfn=%ld\n",DBXname,MFRmfn);
628            }
629        }
630    }
631#endif /* MULTI */
632
633    lastmfn=MS0nxtmfn-1;
634
635    if (RECdbxp != dbxp)
636        fatal("recwrite/dbxp");
637
638    rc=recxref(recp,mfn,&comb,&comp);
639
640    if (comb > MS0nxtmfb)
641        fatal("recwrite/chknew/comb");
642    if (comp >= MSBSIZ)
643        fatal("recwrite/chknew/comp");
644
645#if DBXMSTXL
646    pendnew=recxrefn;
647    pendupd=recxrefm;
648#else
649    xrftiv=DBXxribp->xrmfptr[(mfn-1)%XRMAXTIV]; /* not available for mfn=0 */
650
651    pendnew=(int)(labs(xrftiv) & XRXMASKN);
652    pendupd=(int)(labs(xrftiv) & XRXMASKU);
653#endif
654
655    pend=(pendnew | pendupd);
656    if (pendnew && pendupd)
657        fatal("recwrite/pend");
658
659    if (MS0mftype == MSMFTMSG) {
660        pend=1;                         /* to force inplace=MAYBE */
661        pendnew=1;                      /* and mfbwb/mfbwp=0      */
662    }
663
664#if RUCTRACE
665printf("recwrite - comb=%ld  comp=%d  new=%d  upd=%d  pend=%d  rc=%d\n",
666comb,comp,pendnew,pendupd,pend,rc);
667#endif
668
669
670    mshp= &header;
671    if (rc == RCEOF || rc == RCPDEL) {
672#if MULTI
673        if (DBXnetws != MONONETS) {
674            if (multrace) printf("<w> %s/%ld rc=%d\n",DBXname,MFRmfn,rc);
675            if (!isnewrec) fatal("recwrite/lock/EOFPDEL");
676        }
677#endif /* MULTI */
678        if (pend)
679            if (MS0mftype != MSMFTMSG) /* 07/03/97 */
680                fatal("recwrite/chknew/pend/EOFPDEL");
681
682        memset((char *)mshp,0x00,LEADER);
683
684        MSHstatus=DELETED;
685        comb=MS0nxtmfb;
686        comp=MS0nxtmfp-1;
687#if RUCTRACE
688printf("recwrite - comb=%ld  comp=%d [%ld,%ld+%d]\n",
689 comb,comp,MS0nxtmfn,MS0nxtmfb,MS0nxtmfp);
690#endif
691    }
692    else {
693#if MULTI
694        if (multrace) printf("<w> %s/%ld rc=%d\n",DBXname,MFRmfn,rc);
695        if (DBXnetws != MONONETS)
696            if (isnewrec)
697                if (RECwlock & FORCE) ; else fatal("recwrite/lock/NORMALDEL");
698#endif /* MULTI */
699        xbyte=(((off_t)(comb-1))<<MSBSHIFT)+comp;
700        if (LSEEK64(DBXmsopn,xbyte,SEEK_SET) != xbyte)
701            fatal("recwrite/lseek/leader");
702        n=CIREAD(DBXmsopn,(char *)mshp,LEADER); /* MSNVSPLT */
703#if CNV_PCBINUM
704        ConvertMST_LEADER((char *)mshp,0,LEADER);
705#endif
706#if CNV_PCFILES
707        memcpy(unibuff,(char *)mshp,MSNVSPLT);
708        memcpy(((char *)mshp)+0,unibuff+0,4); /* mfn= */
709        memcpy(((char *)mshp)+4,unibuff+6,4); /* mfbwb= */
710        memcpy(((char *)mshp)+8,unibuff+4,2); /* mfrl= */
711#endif
712        if (n != LEADER) {
713#if RUCTRACE
714printf("recwrite - fd=%d  lseek=%"P_OFF_T"  n=%d\n",DBXmsopn,(LONG_LONG)xbyte,n);
715#endif
716            fatal("recwrite/read");
717        }
718        if (MSHmfn != mfn)
719            fatal("recwrite/check/mfn");
720        if (MS0mftype == MSMFTMSG)
721            MSHmfrl=MSBSIZ;                     /* to force inplace=MAYBE */
722#if MULTI
723        /* step 2: check existing record lock */
724        if (DBXnetws != MONONETS) {
725            if (multrace)
726              printf("<w> %s/%ld mfrl=%04x=%d\n",DBXname,mfn,MSHmfrl,MSHmfrl);
727            if (!isnewrec)
728              if (MSHmfrl <= (FFI)MFRL_MAX) fatal("recwrite/lock/record lock");
729            if (MSHmfrl > (FFI)MFRL_MAX) {
730              MSHmfrl=(FFI)0-MSHmfrl;
731              if (multrace)
732               printf("<w> %s/%ld mfrl=%04x=+%d\n",DBXname,mfn,0x0000,MSHmfrl);
733            }
734        }
735#endif /* MULTI */
736    }
737
738#if RUCTRACE
739printf("recwrite - rec: %ld,%d,%ld,%d,%d,%d,%d\n",
740        MFRmfn,MFRmfrl,MFRmfbwb,MFRmfbwp,MFRbase,MFRnvf,MFRstatus);
741printf("recwrite - mst: %ld,%d,%ld,%d,%d,%d,%d\n",
742        MSHmfn,MSHmfrl,MSHmfbwb,MSHmfbwp,MSHbase,MSHnvf,MSHstatus);
743#endif
744
745    if (rc == RCEOF || rc == RCPDEL)
746        if (MFRstatus == DELETED)
747            fatal("recwrite/deleted");
748
749    if (rc == RCEOF || rc == RCPDEL || pendnew)
750        flagnew=1;
751    else
752        flagnew=0;
753
754
755    if (pend) {
756
757        MFRmfbwb=MSHmfbwb;
758        MFRmfbwp=MSHmfbwp;
759        inplace=MAYBE;
760    }
761
762    else {              /* no if update is pending */
763
764        if (MSHmfbwb != 0 && MSHmfbwp != 0)
765            fatal("recwrite/mfbwlink");
766
767        if (rc != RCNORMAL) {                                   /* 26/09/90 */
768            MFRmfbwb=0;
769            MFRmfbwp=0;
770            inplace=MAYBE;
771        }
772        else {                  /* cancel xrfptr/add */
773            MFRmfbwb=comb;
774            MFRmfbwp=comp;
775            inplace=NEVER;
776        }
777    }
778
779    if (MS0mftype != MSMFTMSG) {
780        if (MFRmfrl & 0x01)
781            MFX[MFRmfrl++]=' '; /* gdb always an even number */
782#if DBXMSTXL
783    vtot = 1;
784    for (pow = 1; pow <= DBXmstxl; pow++) {
785        vtot *= 2;
786    }
787    vtot -= 1;
788    while (MFRmfrl & vtot)
789        MFX[MFRmfrl++]=' ';
790
791/*      if (DBXmstxl == 2) {
792            while (MFRmfrl & 0x03)
793                MFX[MFRmfrl++]=' ';
794        }
795        if (DBXmstxl == 3) {
796            while (MFRmfrl & 0x07)
797                MFX[MFRmfrl++]=' ';
798        } */
799#endif
800    }
801
802#if MULTI
803    /* step 3: check actual maximum record length */
804    if (DBXnetws != MONONETS) {
805        if (MFRmfrl > (FFI)MFRL_MAX) fatal("recwrite/lock/mfrl");
806    }
807#endif /* MULTI */
808
809
810#if RUCTRACE
811printf("recwrite - mfbwb=%ld  mfbwp=%d  inplace=%d  flagnew=%d\n",
812 MFRmfbwb,MFRmfbwp,inplace,flagnew);
813#endif
814
815
816    if (MFRmfrl <= MSHmfrl && inplace == MAYBE) {
817        thiscomb=comb;
818        thiscomp=comp;
819        newblk=0;
820    }
821    else {
822        thiscomb=MS0nxtmfb;
823        thiscomp=MS0nxtmfp-1;
824#if DBXMSTXL
825        /*if (thiscomp & 0x01 ||
826           (DBXmstxl == 2 && thiscomp & 0x03) ||
827           (DBXmstxl == 3 && thiscomp & 0x07))*/
828
829    if (thiscomp & 0x01 || (thiscomp & vtot))
830#else
831        if (thiscomp & 0x01)
832#endif
833            fatal("recwrite/check/even");
834
835        newblk=0;
836        if (thiscomp > (MSBSIZ-MSNVSPLT)) {
837            thiscomb++;
838            thiscomp=0;
839            newblk=1;
840        }
841
842        MS0nxtmfb=thiscomb;
843        nxtcomp= (MS0mftype == MSMFTMSG) ? MSBSIZ : thiscomp+MFRmfrl;
844        for (;;)
845            if (nxtcomp < MSBSIZ)
846                break;
847            else {
848                MS0nxtmfb++;
849                nxtcomp-=MSBSIZ;
850                newblk=1;
851            }
852        if (nxtcomp > (MSBSIZ-MSNVSPLT)) {              /* 17/01/91 */
853            MS0nxtmfb++;
854            nxtcomp=0;
855            newblk=1;
856        }
857        MS0nxtmfp=nxtcomp+1;    /* gdb first = sizeof(M0STRU)+1 */
858
859        if (MS0nxtmfp == 1)
860            newblk=0;
861        if (thiscomp == 0)
862            newblk=1;
863        if (MS0mftype == MSMFTMSG)
864            newblk=1;
865    }
866
867
868    if (mfn >= MS0nxtmfn) {
869        MS0nxtmfn=mfn+1;
870        DBXmsmfn=MS0nxtmfn;
871    }
872
873#if RUCTRACE
874printf("recwrite - thiscomb=%ld  thiscomp=%d\n",thiscomb,thiscomp);
875printf("recwrite - MS0nxtmfn=%ld  MS0nxtmfb=%ld  MS0nxtmfp=%d\n",
876 MS0nxtmfn,MS0nxtmfb,MS0nxtmfp);
877#endif
878
879
880#if MULTI
881    /* step 4: process record lock/unlock */
882    if (DBXnetws != MONONETS) {
883        /* process WUNLOCK/WLOCK */
884        MFRmfrl=(FFI)0-MFRmfrl;
885        RECgdbl=MFRmfrl; RECgdbw=1;
886        /* reset or keep record lock */
887        if (RECwlock & WUNLOCK) {
888            if (multrace)
889              printf("<w> %s/%ld mfrl=%04x=%d\n",DBXname,mfn,RECgdbl,MFRmfrl);
890            MFRmfrl=(FFI)0-MFRmfrl;
891            if (multrace)
892              printf("<w> %s/%ld mfrl=%04x=+%d\n",DBXname,mfn,RECgdbl,MFRmfrl);
893            RECgdbl=RECgdbw=0;
894        }
895    }
896#endif /* MULTI */
897
898#if CICPP
899    recwmast(crecp,thiscomb,thiscomp,newblk,0);
900#else
901    recwmast(crecp,recp,thiscomb,thiscomp,newblk,0);
902#endif /* CICPP */
903
904#if MULTI
905    /* step 5: process existing record lock */
906    if (DBXnetws != MONONETS) {
907        if (MFRmfrl > (FFI)MFRL_MAX) {
908            if (multrace)
909              printf("<w> %s/%ld mfrl=%04x=%d\n",DBXname,mfn,MFRmfrl,MFRmfrl);
910            if (!RECgdbl || !RECgdbw) fatal("recupdat/check/gdbl");
911            MFRmfrl=(FFI)0-MFRmfrl;
912            if (multrace)
913              printf("<w> %s/%ld mfrl=%04x=+%d\n",DBXname,mfn,MFRmfrl,MFRmfrl);
914        }
915    }
916#endif /* MULTI */
917
918    /* encode .xrf pointer for the record location */
919    comb = thiscomb;
920    comp = thiscomp;
921    if (flagnew)
922        comp |= XRXMASKN;
923    else
924        comp |= XRXMASKU;
925
926#if DBXMSTXL
927    xrftiv = comb * (XRXDIVIDE>>DBXmstxl) + (comp>>DBXmstxl);
928#else
929    xrftiv = comb * XRXDIVIDE + comp;
930#endif
931
932    /* complement .xrf pointer for logically deleted records */
933    if (MFRstatus == DELETED)
934        xrftiv= -xrftiv;
935
936#if CICPP
937    recwxref(xrftiv,lastmfn);
938#else
939    recwxref(recp,xrftiv,lastmfn);
940#endif /* CICPP */   
941
942#if MULTI
943    /* step 6: .mst file lock: unlock */
944    if (DBXnetws != MONONETS) {
945        if (multrace) printf("<w> %s .mst unlock [RL off]\n",DBXname);
946        if (dbxulock(dbxp,"M")) fatal("recwrite/lock/file unlock");
947    }
948#endif /* MULTI */
949
950
951    return(RCNORMAL);
952
953#undef NEVER
954#undef MAYBE
955}
956
957
958#if CICPP
959int RECSTRU :: xrecwmast(RECSTRU *crecp,
960                         LONGX     comb,
961                         int      comp,
962                         int      newblk,
963                         FFI      wlen)
964#else /* CICPP */
965int recwmast(crecp,recp,comb,comp,newblk,wlen)                        /*
966------------
967                    seta dbxp e ms0p desde crecp;
968                    regrava o registro recp na posicao comb/comp;
969                    preenche ultimo .mst block, se for o caso;
970                    reseta DBXmsibp->msbufn;
971                    regrava o registro crecp;
972                    retorna RCNORMAL ou aborta
973                                                                      */
974RECSTRU *crecp;     /* elemento de vrecp, para info */
975RECSTRU *recp;      /* elemento de vrecp, para info */
976LONGX comb;          /* gdb getmfr comb */
977int comp;           /* gdb getmfr comp */
978int newblk;         /* new .mst blk switch */
979FFI wlen;           /* 0=MFRmfrl, 1=leader, 2=+dir, n=mfrl */
980#endif /* CICPP */
981{
982    DBXSTRU *dbxp;
983
984    FFI n; /* deveria ser int para pegar o retorno da CIWRITE */
985    int k;
986    off_t xbyte;
987
988    FFI mfrl;
989
990#if CNV_PCFILES
991    char unibuff[MSNVSPLT]; /* CNV_PCFILES/recwmast - MFX */
992#endif
993
994#if DBXMSTXL
995    UWORD keepmftype;
996#endif
997
998#if CICPP
999    RECSTRU *recp = this;
1000#endif /* CICPP */
1001
1002    if (crecp) dbxp=crecp->recdbxp; else dbxp=RECdbxp;
1003
1004    xbyte=((((off_t)(comb-1))<<MSBSHIFT)+comp);
1005
1006#if RUCTRACE
1007printf("recwmast - fd=%d  lseek=%"P_OFF_T"  newblk=%d\n",
1008 DBXmsopn,(LONG_LONG)xbyte,newblk);
1009#endif
1010
1011    if (recp)
1012        if (LSEEK64(DBXmsopn,xbyte,SEEK_SET) != xbyte)
1013            fatal("recwmast/lseek/rec");
1014
1015    if (wlen) {
1016        if (wlen == 1) mfrl=LEADER;             /* leader */
1017        else if (wlen == 2) mfrl=MFRbase;       /*  + dir */
1018        else mfrl=wlen;                         /* waall! */
1019    }
1020    else {
1021        mfrl=MFRmfrl;
1022#if MULTI
1023        if (DBXnetws != MONONETS)
1024            if (MFRmfrl > (FFI)MFRL_MAX)
1025                mfrl=(FFI)0-MFRmfrl;
1026#endif /* MULTI */
1027    }
1028
1029    /* retag.c calls recwmast(recp,NULL,0,0,0,sizeof(M0STRU)) */
1030    if (recp) {
1031#if CNV_PCFILES
1032        if (MFRmfn > 0) {
1033            memcpy(unibuff,MFX,MSNVSPLT);
1034            memcpy(MFX+0,unibuff+0,4); /* mfn= */
1035            memcpy(MFX+6,unibuff+4,4); /* mfbwb= */
1036            memcpy(MFX+4,unibuff+8,2); /* mfrl= */
1037        }
1038#endif
1039#if CNV_PCBINUM
1040        memcpy(cnv_pcbuff,MFX,mfrl);
1041        if (MFRmfn > 0) {
1042            k=MFRnvf; /* CNV_PCFILES ok */
1043            ConvertMST_LEADER(cnv_pcbuff,0,LEADER);
1044            if (wlen != 1) ConvertMST_DIR(cnv_pcbuff,k);
1045        }
1046        else ConvertMST_CTLSTRUCT(cnv_pcbuff);
1047        if ((n=CIWRITE(DBXmsopn,cnv_pcbuff,mfrl)) != mfrl) {
1048#else
1049        if ((n=CIWRITE(DBXmsopn,MFX,mfrl)) != mfrl) {
1050#endif
1051#if RUCTRACE
1052printf("recwmast - write/rec  n=%d  mfrl=%d\n",n,mfrl);
1053#endif
1054            fatal("recwmast/write/rec");
1055        }
1056#if CNV_PCFILES
1057        if (MFRmfn > 0)
1058            memcpy(MFX,unibuff,MSNVSPLT);
1059#endif
1060    }
1061
1062    if (newblk) {
1063        k=MSBSIZ-((xbyte+mfrl)&XRXMASK);
1064
1065#if RUCTRACE
1066printf("recwmast - fill=%d\n",k);
1067#endif
1068        memset(DBXmsibp->msbuff,0x00,(size_t)k);
1069
1070        if ((n=CIWRITE(DBXmsopn,DBXmsibp->msbuff,k)) != k) { /* 0x00 */
1071
1072#if RUCTRACE
1073printf("recwmast - write/end  n=%d  k=%d\n",n,k);
1074#endif
1075            fatal("recwmast/write/end");
1076        }
1077    }
1078
1079    DBXmsibp->msbufn=0;                         /* reset .mst input buffer */
1080
1081    if (!crecp) return(RCNORMAL);
1082
1083    LSEEK64(DBXmsopn,0L,SEEK_SET);
1084
1085    recp=crecp; /* tmp for MFX */
1086
1087#if DBXMSTXL /* AOT/AARG 05/01/99 */
1088    if (DBXmstxl) {
1089        keepmftype=MF0mftype;
1090        MF0mftype += DBXmstxl * 256;
1091    }
1092#endif
1093
1094#if CNV_PCBINUM
1095    memcpy(cnv_pcbuff,MFX,sizeof(M0STRU));
1096    ConvertMST_CTLSTRUCT(cnv_pcbuff);
1097    n=CIWRITE(DBXmsopn,cnv_pcbuff,sizeof(M0STRU));
1098#else
1099    n=CIWRITE(DBXmsopn,MFX,sizeof(M0STRU));
1100#endif
1101    if (n != sizeof(M0STRU)) {
1102#if RUCTRACE
1103printf("recwmast - write/ctl  n=%d\n",n);
1104#endif
1105        fatal("recwmast/write/ctl");
1106    }
1107
1108#if DBXMSTXL /* AOT/AARG 05/01/99 */
1109    if (DBXmstxl) {
1110        MF0mftype=keepmftype;
1111    }
1112#endif
1113
1114    return(RCNORMAL);
1115}
1116
1117
1118#if CICPP
1119int RECSTRU :: xrecwxref(XRPTR    pointer,
1120                         LONGX     lastmfn)
1121#else /* CICPP */
1122int recwxref(recp,pointer,lastmfn)                                     /*
1123------------
1124                    seta dbxp/mfn desde recp;
1125                    atualiza .xrf;
1126                    retorna RCNORMAL ou aborta
1127                                                                      */
1128RECSTRU *recp;      /* elemento de vrecp, para info */
1129XRPTR pointer;      /* .xrf pointer para mfn */
1130LONGX lastmfn;       /* ultimo mfn em .xrf */
1131#endif /* CICPP */
1132{
1133    DBXSTRU *dbxp;
1134    LONGX mfn;
1135
1136    FFI n,k,j;
1137    int flag127;
1138    off_t xbyte;
1139    LONGX x;
1140    char *p;
1141
1142    int thisidx,lastidx;
1143    XRPOS thispos,lastpos;
1144    XRPTR xrftiv;
1145#if CNV_PCBINUM
1146    XRSTRU *xrp;
1147#endif
1148
1149    LONGX wcomb;
1150    int  wcomp;
1151
1152#if CICPP
1153    RECSTRU *recp = this;
1154#endif /* CICPP */
1155
1156    dbxp=RECdbxp;
1157    mfn=MFRmfn;
1158
1159    lastpos=(lastmfn+XRMAXTV1)/XRMAXTIV;
1160    if (lastpos < 1)
1161        lastpos=1;
1162    flag127=0;
1163    if (lastmfn)
1164        if (mfn > lastmfn && (lastmfn % XRMAXTIV) == 0)         /* 127 ok */
1165            { lastpos++; flag127=1; }
1166
1167    thispos=    (mfn+XRMAXTV1)/XRMAXTIV;
1168
1169    lastidx=(lastmfn-1)%XRMAXTIV;
1170    if (flag127)
1171        lastidx = -1;   /* 21/01/91 */
1172
1173    thisidx=    (mfn-1)%XRMAXTIV;
1174
1175#if RUCTRACX
1176printf("recwxref - lastmfn=%ld             \n",lastmfn);
1177printf("recwxref - lastpos=%ld  thispos=%ld\n",lastpos,thispos);
1178printf("recwxref - lastidx=%d   thisidx=%d \n",lastidx,thisidx);
1179#endif
1180
1181    if (!lastmfn) recxref(recp,1L,&wcomb,&wcomp);       /* 28/01/91 */
1182
1183    if (thispos < lastpos) {
1184
1185#if RUCTRACX
1186printf("recwxref - thispos < lastpos\n");
1187#endif
1188
1189#if BEFORE940815
1190        if (recxref(recp,mfn,&wcomb,&wcomp) == RCEOF)
1191            fatal("recwxref/recxref/thispos");
1192        if (DBXxribp->xrxrpos != thispos)
1193            fatal("recwxref/check/thispos");
1194        DBXxribp->xrmfptr[thisidx]=pointer;
1195#else
1196        if (DBXxribp->xrxrpos == thispos) DBXxribp->xrmfptr[thisidx]=pointer;
1197#endif
1198
1199        xbyte=(off_t)( (((off_t)(thispos-1))<<XRSHIFT)+XRPOSSIZ+thisidx*XRPTRSIZ );
1200        if (LSEEK64(DBXxropn,xbyte,SEEK_SET) != xbyte)
1201            fatal("recwxref/lseek/thispos");
1202#if BEFORE970319
1203        p=(char *)&DBXxribp->xrmfptr[thisidx];
1204#else
1205        p=(char *)&pointer;
1206#endif
1207
1208#if CNV_PCBINUM
1209        memcpy(cnv_pcbuff,p,XRPTRSIZ);
1210        ConvertXRF_PTR(cnv_pcbuff);
1211        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRPTRSIZ)) != XRPTRSIZ) {
1212#else
1213        if ((n=CIWRITE(DBXxropn,p,XRPTRSIZ)) != XRPTRSIZ) {
1214#endif
1215#if RUCTRACX
1216printf("recwxref - rewrite/mfptr  n=%d\n",n);
1217#endif
1218            fatal("recwxref/rewrite/mfptr");
1219        }
1220    }
1221
1222    else /* 21/01/91 */
1223
1224    if (thispos > lastpos) {
1225
1226#if RUCTRACX
1227printf("recwxref - thispos > lastpos\n");
1228#endif
1229
1230        if (lastmfn)
1231            if (recxref(recp,lastmfn,&wcomb,&wcomp) == RCEOF)
1232                fatal("recwxref/recxref/lastmfn");
1233
1234        x = (flag127) ? (lastpos-1) : (-lastpos);
1235        if (DBXxribp->xrxrpos != x)
1236            fatal("recwxref/xrpos/lastpos");
1237
1238        DBXxribp->xrxrpos=lastpos;        /* unflag last block */
1239
1240#if DBXMSTXL /* AOT, 07/04/2003 */
1241    xrftiv = (-1) * (XRXDIVIDE>>DBXmstxl) + ((0)>>DBXmstxl);  /* PDEL pointer */
1242#else
1243        xrftiv=(-1)*XRXDIVIDE + (0);      /* PDEL pointer */
1244#endif
1245
1246        for (n=lastidx+1; n<XRMAXTIV; n++)
1247            DBXxribp->xrmfptr[n] = xrftiv;
1248
1249        xbyte=(((off_t)(lastpos-1))<<XRSHIFT);
1250        if (LSEEK64(DBXxropn,xbyte,SEEK_SET) != xbyte)
1251            fatal("recwxref/lseek/lastpos");
1252#if CNV_PCBINUM
1253        memcpy(cnv_pcbuff,DBXxribp,XRBSIZ);
1254        ConvertXRF_REC(cnv_pcbuff);
1255        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRBSIZ)) != XRBSIZ) {
1256#else
1257        if ((n=CIWRITE(DBXxropn,(char *)DBXxribp,XRBSIZ)) != XRBSIZ) {
1258#endif
1259#if RUCTRACX
1260printf("recwxref - rewrite/lastpos  n=%d\n",n);
1261#endif
1262            fatal("recwxref/rewrite/lastpos");
1263        }
1264
1265
1266        while (++lastpos < thispos) {
1267
1268            DBXxribp->xrxrpos = lastpos;
1269
1270            for (n=0; n < XRMAXTIV; )
1271                DBXxribp->xrmfptr[n++] = xrftiv;
1272
1273#if CNV_PCBINUM
1274            memcpy(cnv_pcbuff,DBXxribp,XRBSIZ);
1275            ConvertXRF_REC(cnv_pcbuff);
1276            if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRBSIZ)) != XRBSIZ) {
1277#else
1278            if ((n=CIWRITE(DBXxropn,(char *)DBXxribp,XRBSIZ)) != XRBSIZ) {
1279#endif
1280#if RUCTRACX
1281printf("recwxref - write/midpos  n=%d\n",n);
1282#endif
1283                fatal("recwxref/write/midpos");
1284            }
1285        }
1286
1287
1288        DBXxribp->xrxrpos= -thispos;      /* flag last block */
1289
1290        for (n=0; n<thisidx; n++)
1291            DBXxribp->xrmfptr[n] = xrftiv;
1292
1293        DBXxribp->xrmfptr[thisidx] = pointer;
1294
1295        xrftiv= (0)*XRXDIVIDE + (0);      /* EOF pointer */
1296
1297        for (n=thisidx+1; n<XRMAXTIV; n++)
1298            DBXxribp->xrmfptr[n] = xrftiv;
1299
1300#if CNV_PCBINUM
1301        memcpy(cnv_pcbuff,DBXxribp,XRBSIZ);
1302        ConvertXRF_REC(cnv_pcbuff);
1303        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRBSIZ)) != XRBSIZ) {
1304#else
1305        if ((n=CIWRITE(DBXxropn,(char *)DBXxribp,XRBSIZ)) != XRBSIZ) {
1306#endif
1307#if RUCTRACX
1308printf("recwxref - write/thispos  n=%d\n",n);
1309#endif
1310            fatal("recwxref/write/thispos");
1311        }
1312    }
1313
1314
1315    else /* 21/01/91 */
1316
1317    if (thispos == lastpos) {
1318
1319#if RUCTRACX
1320printf("recwxref - thispos == lastpos\n");
1321#endif
1322
1323        recxref(recp,mfn,&wcomb,&wcomp);
1324
1325        if (labs(DBXxribp->xrxrpos) != thispos)
1326            fatal("recwxref/check/lastpos");
1327
1328        k=j=0;
1329#if DBXMSTXL /* AOT, 07/04/2003 */
1330    xrftiv = (-1) * (XRXDIVIDE>>DBXmstxl) + ((0)>>DBXmstxl);  /* PDEL pointer */
1331#else
1332        xrftiv=(-1)*XRXDIVIDE + (0);      /* PDEL pointer */
1333#endif
1334
1335        for (n=lastidx+1; n<thisidx; n++) {
1336            DBXxribp->xrmfptr[n] = xrftiv;
1337            k+=XRPTRSIZ; j++;
1338        }
1339
1340        DBXxribp->xrmfptr[thisidx] = pointer;
1341        k+=XRPTRSIZ;
1342
1343        xbyte=(off_t)( (((off_t)(thispos-1))<<XRSHIFT)+XRPOSSIZ+(thisidx-j)*XRPTRSIZ );
1344        if (LSEEK64(DBXxropn,xbyte,SEEK_SET) != xbyte)
1345            fatal("recwxref/lseek/mfptrs");
1346        p=(char *)&DBXxribp->xrmfptr[thisidx-j];
1347
1348#if CNV_PCBINUM
1349        xrp=(XRSTRU *)cnv_pcbuff;
1350        memcpy(cnv_pcbuff,p,k);
1351        for (n=0; n <= j; n++) /* (j+1) ptr's*/
1352            ConvertXRF_PTR(&cnv_pcbuff[n*XRPTRSIZ]);
1353        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,k)) != k) {
1354#else
1355        if ((n=CIWRITE(DBXxropn,p,k)) != k) {
1356#endif
1357#if RUCTRACX
1358printf("recwxref - rewrite/mfptrs  k=%d  n=%d\n",k,n);
1359#endif
1360            fatal("recwxref/rewrite/mfptrs");
1361        }
1362    }
1363
1364
1365    if (mfn > lastmfn && (mfn % XRMAXTIV) == 0) {       /* 127 ok */
1366
1367#if RUCTRACX
1368printf("recwxref - thispos == lastpos 127\n");
1369#endif
1370
1371        if (recxref(recp,mfn,&wcomb,&wcomp) == RCEOF)   /* 08/08/91 */
1372            fatal("recwxref/recxref/mfn127");
1373//printf("mfn=%ld comp=%ld comb=%ld\n", mfn, (long)wcomp, (long)wcomb);
1374        if (DBXxribp->xrxrpos != -thispos) {
1375            printf("*** %ld/%ld ",DBXxribp->xrxrpos,thispos);
1376            fatal("recwxref/xrpos/thispos");
1377        }
1378
1379        DBXxribp->xrxrpos=thispos;        /* unflag last block */
1380
1381        xbyte=(((off_t)(thispos-1))<<XRSHIFT);
1382        if (LSEEK64(DBXxropn,xbyte,SEEK_SET) != xbyte)
1383            fatal("recwxref/lseek/thispos/last");
1384        /* should write only xrxrpos and lseek next blk */
1385#if CNV_PCBINUM
1386        memcpy(cnv_pcbuff,DBXxribp,XRBSIZ);
1387        ConvertXRF_REC(cnv_pcbuff);
1388        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRBSIZ)) != XRBSIZ) {
1389#else
1390        if ((n=CIWRITE(DBXxropn,(char *)DBXxribp,XRBSIZ)) != XRBSIZ) {
1391#endif
1392#if RUCTRACX
1393printf("recwxref - rewrite/thispos/last  n=%d\n",n);
1394#endif
1395            fatal("recwxref/rewrite/thispos/last");
1396        }
1397
1398
1399        DBXxribp->xrxrpos= -(thispos+1);  /* flag last block */
1400
1401        xrftiv= (0)*XRXDIVIDE + (0);      /* EOF pointer */
1402
1403        for (n=0; n < XRMAXTIV; )
1404            DBXxribp->xrmfptr[n++] = xrftiv;
1405
1406#if CNV_PCBINUM
1407        memcpy(cnv_pcbuff,DBXxribp,XRBSIZ);
1408        ConvertXRF_REC(cnv_pcbuff);
1409        if ((n=CIWRITE(DBXxropn,cnv_pcbuff,XRBSIZ)) != XRBSIZ) {
1410#else
1411        if ((n=CIWRITE(DBXxropn,(char *)DBXxribp,XRBSIZ)) != XRBSIZ) {
1412#endif
1413#if RUCTRACX
1414printf("recwxref - write/newpos  n=%d\n",n);
1415#endif
1416            fatal("recwxref/write/newpos");
1417        }
1418    }
1419
1420    return(RCNORMAL);
1421}
1422
1423
1424
1425#include "cihsh.c"   /* CISIS Interface hashing & binary table search source code */
1426#if CIWTF                                /* WTFUN support */
1427#if !CICPP
1428#if !CIAPI
1429//#include "cihsh.c"   /* CISIS Interface hashing & binary table search source code */
1430#include "wtrun.c"   /* wtfnew(); wtfset(); wtfdel(); wtnew(); wtexit(); loadcoll() source code */
1431#endif /* CIWTF */
1432#endif /* CIAPI */
1433#endif /* CICPP */
1434
1435#if INCPRCCX
1436/* procx.c */
1437#include "ciupdsocy.c"       /* mainfile() source code */
1438#if PROCXSOCKREC
1439#include "ciupdsocx.c"       /* mainclient() source code */
1440#endif /* PROCXSOCKREC */
1441#endif /* INCPRCCX */
1442
1443#if INCPRSSX
1444#define PROCXSERVREC 1
1445#if PROCXSERVREC
1446#if PC
1447#include "ciupdserwpc.c"
1448#else
1449#include "ciupdserw.c"
1450#endif
1451#endif /* PROCXSERVREC */
1452#endif /* INCPRSSX */
1453
1454
1455
1456
1457#if CICPP
1458char * RECSTRU :: xfldupdat(char *batchp)
1459#else /* CICPP */
1460char *fldupdat(irec,batchp)                                           /*
1461--------------
1462                    abenda se vrecp nao inicializado;
1463                    abenda se registro irec ainda nao alocado;
1464                    abenda se tipo de irec diferente de TYPEMFR;
1465                    executa comandos desde batchp sobre registro irec;
1466                    retorna NULL ou .ptr erro
1467                                                                      */
1468LONGX irec;          /* indice de vrecp, para recwrite() */
1469char *batchp;       /* ptr comandos Dtag ou Atag'string' */
1470#endif /* CICPP */
1471{
1472#if !CICPP
1473    extern int bugadddel;               /* 13/03/94 */
1474#endif /* CICPP */
1475    RECSTRU *recp;
1476
1477    DIRSTRU *mfdirp,*dirarea=NULL,*dirp,*dp,*dxp;
1478    char *srcareap=NULL;                                             /* v3.4 */
1479    FFI realmfrl;
1480
1481    int maxdirs,dirsleft;
1482    FFI ndel,nadd;
1483    FFI vlendel,vlenadd;
1484    FFI lastpos,nxtpos;
1485    char *mfp,*nxtp,*newp;
1486
1487    char *p,c,cc,*errp,*sp,*sxp;
1488    int tag;
1489    FFI n,k,loop,reploop;
1490
1491    int iocc,tagocc;
1492    LONGX nbytes,mfn;
1493
1494    int i,j,anychange,nn;
1495    char tempdir[sizeof(DIRSTRU)];
1496    int sort=0;
1497
1498#define STRIPMARKUP 1
1499
1500#if STRIPMARKUP
1501    FFI smumaxlen=(FFI)MFRL_MAX;
1502    FFI fldlenmin=0;
1503    FFI fldleft,fldqleft,striplen,erased;
1504    LONGX l1,l2;
1505    int nn1,nn2;
1506    int match,endmatch,tagmatch;
1507    char *xp,*fldp,*fldq;
1508#endif /* STRIPMARKUP */
1509
1510/* procx.c */
1511#define PROCXMFUPDATE 1
1512#if PROCXMFUPDATE
1513int xfd/*,n*/,parmcopy;
1514#if CICPP
1515RECSTRU *upirecp,*upcrecp;
1516#else /* CICPP */
1517LONGX upirec,upcrec;
1518/*char *p;*/
1519#endif /* CICPP */
1520#endif /* PROCXMFUPDATE */
1521
1522/* procx.c */
1523#define PROCXWRITEFILE 1
1524#if PROCXWRITEFILE
1525char *wfnamp;
1526int wffd,wflen;
1527char *wfxp;
1528char *wfmtspecp;
1529#define KEEPDBX 1
1530#if KEEPDBX
1531LONGX keepndbx;
1532LONGX idbx;
1533#endif /* KEEPDBX */
1534#endif /* PROCXWRITEFILE */
1535
1536/* procx.c */
1537#if RECGIZM
1538#define PROCXGIZMREC 1
1539#endif
1540#if PROCXGIZMREC
1541#if RECDECO
1542#define PROCXDECOREC 1
1543#endif
1544#define PROCXSPLIREC 1
1545#define PROCXCLPSREC 1
1546#endif /* PROCXGIZMREC */
1547
1548/* precx.c */
1549#if INCPRECX
1550#define PROCXMARKREC 1
1551#if PROCXMARKREC
1552#define upmF1 '1'
1553#define upmF2 '2'
1554#define upmF3 '3'
1555#define upmF4 '4'
1556#endif /* PROCXMARKREC */
1557#endif /* INCPRECX */
1558
1559/* procx.c */
1560#define PROCXLOADREC 1
1561#if PROCXLOADREC
1562#endif /* PROCXLOADREC */
1563
1564
1565/* procx.c */
1566#define PROCXDUMPREC 1
1567#if PROCXDUMPREC
1568int isgdump=0;
1569#endif /* PROCXDUMPREC */
1570
1571/* procx.c */
1572#define PROCXREADREC 1
1573#if PROCXREADREC
1574char *rfnamp;
1575char *rfmfnp;
1576LONGX rfmfn;
1577#if CICPP
1578RECSTRU *uprrecp,*uprrexp;
1579#else /* CICPP */
1580LONGX uprrec,uprrex;
1581#endif /* CICPP */
1582int xdir;
1583RECSTRU *keeprecp;
1584char *rp;
1585#endif /* PROCXREADREC */
1586
1587/* procx.c */
1588#if !CICPP /* porque falta implementar em c++ */
1589#define PROCXIFPRESET 1
1590#if PROCXIFPRESET
1591char *ifprnamp;
1592char *ifprmfnp;
1593LONGX ifprmfn;
1594#endif /* PROCXIFPRESET */
1595#endif /* CICPP */
1596
1597#if INCPROCX /* usa CIIFU (+FST(+FMT)) */
1598/* procx.c */
1599#if !CICPP /* porque falta implementar em c++ */
1600#define PROCXIFUPDATE 1
1601#if PROCXIFUPDATE
1602int pstflag=IFUPISIS;
1603int endup=IFUPWRIT; /* single record */
1604char *stwp=NULL;
1605FST_CODE *fstpgmp=NULL;
1606LONGX maxlk1=1000;
1607LONGX maxlk2=500;
1608char *fstspecp=NULL;
1609char *ifnamp;
1610char *mfnamp;
1611char *mfnp;
1612LONGX ifmfn;
1613int yfd;
1614#endif /* PROCXIFUPDATE */
1615#endif /* CICPP */
1616#endif /* INCPROCX */
1617
1618#if INCPROCXT /* usa CIFST(+FMT) */
1619/* procx.c */
1620#if !CICPP /* porque falta implementar em c++ */
1621#define PROCXFSUPDATE 1
1622#if PROCXFSUPDATE
1623int tyyopth=0;
1624#endif /* PROCXFSUPDATE */
1625#endif /* CICPP */
1626#endif /* INCPROCXT */
1627
1628#if CICPP
1629#define freex(srcareap,dirarea) {\
1630                if (srcareap) delete[] srcareap; if (dirarea) delete[] dirarea; }
1631#else /* CICPP */
1632#define freex(srcareap,dirarea) {\
1633                  if (srcareap) { \
1634            FREE(srcareap); srcareap=NULL; } \
1635          if (dirarea) { \
1636            FREE(dirarea); dirarea=NULL; } \
1637        }
1638#endif /* CICPP */
1639
1640#if CICPP
1641#if RUFTRACE
1642    LONGX irec = NO_IREC;
1643#endif
1644    recp=this;
1645#else /* CICPP */
1646    if (!nrecs)
1647        fatal("fldupdat/RECINIT");
1648
1649    recp=vrecp[irec];
1650#endif /* CICPP */
1651    if (!recp)
1652        fatal("fldupdat/RECALLOC");
1653
1654    if (RECtype != TYPEMFR)
1655        fatal("fldupdat/TYPEMFR");
1656
1657#if RUFTRACE
1658printf("fldupdat - irec=%ld  nbytes=%ld  batchp='%s'\n",
1659 irec,RECnbytes,batchp);
1660#endif
1661
1662#define PROCG  1
1663#if PROCG
1664#include "ciupg.c"
1665#endif /* PROCG */
1666
1667#if 0
1668    nbytes = (RECnbytes < MAXMFRL) ? RECnbytes : MAXMFRL;
1669    nbytes = (RECnbytes < rec_maxmfrl) ? RECnbytes : rec_maxmfrl;
1670    nbytes = rec_maxmfrl;
1671#endif
1672    nbytes = (RECnbytes > rec_maxmfrl) ? RECnbytes : rec_maxmfrl;
1673
1674#if CICPP
1675    try { dirarea = (DIRSTRU *) new char [nbytes]; }
1676    catch (BAD_ALLOC) { dirarea = (DIRSTRU *)ALLONULL; }
1677#else /* CICPP */
1678    dirarea=(DIRSTRU *)ALLOC((ALLOPARM)nbytes);
1679#endif /* CICPP */
1680    if (dirarea == (DIRSTRU *)ALLONULL)
1681        fatal("fldupdat/ALLOC/dir");
1682
1683    maxdirs=nbytes/sizeof(DIRSTRU);
1684#if CICPP
1685    try { srcareap = (char *) new char [maxdirs]; }
1686    catch (BAD_ALLOC) { srcareap = (char *)ALLONULL; }
1687#else /* CICPP */
1688    srcareap=(char *)ALLOC((ALLOPARM)maxdirs);                  /* v3.4 */
1689#endif /* CICPP */
1690    if (srcareap == (char *)ALLONULL) {
1691        freex(srcareap,dirarea);
1692            fatal("fldupdat/ALLOC/src");
1693    }
1694
1695    memset(srcareap,'?',maxdirs);       /* no default */        /* v3.4 */
1696
1697
1698    dirsleft=MFRnvf;
1699
1700    realmfrl=MFRbase;
1701
1702    sp=srcareap; dirp=dirarea;
1703    for (mfdirp=MFRdir, n=dirsleft; n--; mfdirp++, dirp++, sp++) {
1704        dirp->tag = mfdirp->tag;
1705        dirp->pos = mfdirp->pos;
1706        dirp->len = mfdirp->len;
1707        *sp = 'r';              /* source is record */          /* v3.4 */
1708        realmfrl+=mfdirp->len;
1709    }
1710#if RUFTRACE
1711printf("fldupdat - RECrc=%d  Leader: %ld,%d,%ld,%d,%d,%d,%d\n",
1712 RECrc,MFRmfn,MFRmfrl,MFRmfbwb,MFRmfbwp,MFRbase,MFRnvf,MFRstatus);
1713printf("fldupdat - dirsleft=%d  realmfrl=%d\n",dirsleft,realmfrl);
1714for (dirp=dirarea, loop=0; loop<dirsleft; loop++, dirp++)
1715 printf("fldupdat - dir[%d]: tag=%d  pos=%d  len=%d\n",
1716  loop,dirp->tag,dirp->pos,dirp->len);
1717#endif
1718
1719    MFRmfrl=realmfrl;
1720
1721
1722    for (ndel=nadd=0, vlendel=vlenadd=0, p=batchp; *p; ) {
1723
1724        if (isspace(*p))  {
1725            p++;
1726            continue;
1727        }
1728
1729        c=toupper(*p); errp=p++;
1730        switch (c) {
1731
1732        case 'S':
1733                for (tag=0; isdigit(*p); p++) tag=tag*10+(*p-'0');
1734            if (*p) {
1735            freex(srcareap,dirarea);
1736                    return(errp);
1737            }
1738        if (tag) {
1739            int len,cmp;
1740                for (i=0; i+1 < MFRnvf; i++) {
1741                    if (DIRtag(i) != tag) continue;
1742                    for (j=i+1; j < MFRnvf; j++) {
1743                        if (DIRtag(j) != tag) continue;
1744                    len=DIRlen(i); if (len>DIRlen(j)) len=DIRlen(j);
1745                    cmp=memcmp(FIELDP(i),FIELDP(j),len);
1746                            if (cmp > 0 || cmp==0 && DIRlen(i) > DIRlen(j)) {
1747                                memcpy(tempdir,&MFRdir[i],sizeof(DIRSTRU));
1748                                memcpy(&MFRdir[i],&MFRdir[j],sizeof(DIRSTRU));
1749                                memcpy(&MFRdir[j],tempdir,sizeof(DIRSTRU));
1750                        }
1751                }
1752                }
1753                break;
1754        }
1755            for (anychange=1; anychange; ) {
1756                anychange=0;
1757                for (i=0; i+1 < MFRnvf; i++) {
1758                    j=i+1;
1759                    if (DIRtag(i) > DIRtag(j)) {
1760                                memcpy(tempdir,&MFRdir[i],sizeof(DIRSTRU));
1761                                memcpy(&MFRdir[i],&MFRdir[j],sizeof(DIRSTRU));
1762                                memcpy(&MFRdir[j],tempdir,sizeof(DIRSTRU));
1763                                anychange=1; sort=1;
1764                        }
1765                }
1766        }
1767            break;
1768
1769        case '=':
1770            for (mfn=0; isdigit(*p); p++) 
1771                mfn=mfn*10+(*p-'0');
1772            if (mfn == 0) {
1773        freex(srcareap,dirarea);
1774                return(errp);
1775            }
1776            MFRmfn=mfn;
1777            break;
1778
1779        case 'D':
1780            while (isspace(*p))
1781                p++;
1782            if (*p == '.') {                    /* logically deleted */
1783                MFRstatus=DELETED;
1784                p++;
1785                break;
1786            }
1787            if (*p == ':') {            /* logically deleted/active */
1788                MFRstatus=(MFRstatus==DELETED)?ACTIVE:DELETED;
1789                p++;
1790                break;
1791            }
1792            if (*p == '*') {
1793                tag=0;
1794                p++;
1795            }
1796            else {
1797                for (tag=0; isdigit(*p); p++)
1798                    tag=tag*10+(*p-'0');
1799                if (tag == 0) {
1800            freex(srcareap,dirarea);
1801                    return(errp);
1802                }
1803            }
1804            while (isspace(*p))
1805                p++;
1806            if (tag > 0 && *p == '/') {
1807                p++;
1808                while (isspace(*p))
1809                    p++;
1810                for (tagocc=0; isdigit(*p); p++)
1811                    tagocc=tagocc*10+(*p-'0');
1812#if RUJTRACE
1813printf("fldupdat - D/r - tag=%d  tagocc=%d\n",
1814 tag,tagocc);
1815#endif
1816            }
1817            else
1818                tagocc=0;
1819            for (sp=srcareap, iocc=0, dirp=dirarea, n=dirsleft; n--; ) {
1820                if (dirp->tag == tag || tag == 0) {
1821                    if (tagocc) {
1822                        iocc++;
1823                        if (iocc != tagocc) {
1824                            dirp++; sp++;                       /* v3.4 */
1825                            continue;
1826                        }
1827                    }
1828#if RUJTRACE
1829printf("fldupdat - D/r - tag=%d  tagocc=%d  iocc=%d\n",
1830 tag,tagocc,iocc);
1831#endif
1832                    if (*sp != 'r') {                           /* v3.4 */
1833            freex(srcareap,dirarea);
1834                        return(errp);
1835                    }
1836#if 1 /* BUGADDDEL */
1837                    if (bugadddel) if (nadd) {
1838            freex(srcareap,dirarea);
1839                        return(errp);
1840                    }
1841#endif
1842                    vlendel+=dirp->len;
1843                    for (sxp=sp, dp=dirp, loop=n; loop--; ) {
1844                        dxp=dp; dp++;
1845                        dxp->tag = dp->tag;
1846                        dxp->pos = dp->pos;
1847                        dxp->len = dp->len;
1848                        *sxp = *(sxp+1); sxp++;                 /* v3.4 */
1849                    }
1850                    dirsleft--;
1851                    ndel++;
1852#if RUFTRACE
1853printf("fldupdat - D - tag=%d  dirsleft=%d  vlendel=%d\n",
1854 tag,dirsleft,vlendel);
1855for (sxp=srcareap, dp=dirarea, loop=0; loop<dirsleft; loop++, dp++, sxp++)
1856 printf("fldupdat - dir[%d]: tag=%d  pos=%d(%c)  len=%d\n",
1857  loop,dp->tag,dp->pos,*sxp,dp->len);
1858#endif
1859                }
1860                else
1861                    dirp++;
1862            }
1863            break;
1864
1865        case 'A':
1866        case 'H':
1867#if STRIPMARKUP
1868        case '<':
1869        erased=0; endmatch=0;
1870#endif /* STRIPMARKUP */
1871            cc=c;
1872            while (isspace(*p))
1873                p++;
1874            for (tag=0; isdigit(*p); p++)
1875                tag=tag*10+(*p-'0');
1876            if (*p == '\0' || tag == 0) {
1877            freex(srcareap,dirarea);
1878                    return(errp);
1879            }
1880            while (*p == ' ')           /* enable any delimiter, but space */
1881                p++;
1882/* CMD 'H' */
1883            if (c == 'H') {
1884                for (nn=n=0; isdigit(*p); p++, nn++)
1885                    n=n*10+(*p-'0');
1886#if RUKTRACE
1887printf("+++c=%c tag=%d n=%d *p='%c'\n",c,tag,n,*p);
1888#endif
1889                if (!nn || (n && !isspace(*p))) {
1890            freex(srcareap,dirarea);
1891                    return(errp);
1892                }
1893                if (n) p++;
1894                p+=n;
1895            }
1896#if STRIPMARKUP
1897/* CMD '<' */
1898            else if (c == '<') {
1899
1900                nn1=0; l1=0;
1901                nn2=0; l2=0;
1902        if (isdigit(*p)) {
1903            for (; isdigit(*p); ) { l1=l1*10+(*p-'0'); p++, nn1++; }
1904                    if (nn1) while (isspace(*p)) p++;
1905            for (; isdigit(*p); ) { l2=l2*10+(*p-'0'); p++, nn2++; }
1906                    if (nn2) while (isspace(*p)) p++;
1907        }
1908        else while (*p) {
1909            if (*p == '>') break;
1910            if (strncmp(p,"markmax=",8) == 0) {
1911                for (p+=8; isdigit(*p); ) { l1=l1*10+(*p-'0'); p++, nn1++; }
1912                if (nn1) nn1+=8;
1913                while (isspace(*p)) p++;
1914                continue;
1915            }
1916            if (strncmp(p,"flenmin=",8) == 0) {
1917                for (p+=8; isdigit(*p); ) { l2=l2*10+(*p-'0'); p++, nn2++; }
1918                if (nn2) nn2+=8;
1919                while (isspace(*p)) p++;
1920                continue;
1921            }
1922            break;
1923        }
1924                if (*p++ != '>') {
1925            freex(srcareap,dirarea);
1926                    return(errp);
1927                }
1928        if (nn1) smumaxlen=(FFI)l1;
1929        if (nn2) fldlenmin=(FFI)l2;
1930        /*...*/
1931            for (n=0, fldp=p; *fldp; fldp++, n++) {
1932                xp=fldp;
1933                if (*xp++ != '<') continue;
1934                if (*xp++ != '/') continue;
1935                nn=0; while (isspace(*xp)) { xp++; nn++; }
1936                for (tagmatch=0; isdigit(*xp); xp++, nn++)
1937                    tagmatch=tagmatch*10+(*xp-'0');
1938                while (isspace(*xp)) { xp++; nn++; }
1939                if (*xp++ != '>') continue;
1940                if (tagmatch != tag) continue;
1941                endmatch=2+nn+1; break;
1942            }
1943            if (!endmatch) {
1944                freex(srcareap,dirarea);
1945                return(errp);
1946            }
1947
1948            fldp=p;
1949            fldleft=n;
1950            for (xp=fldp; fldleft > 0; ) {
1951                if (*fldp != '<') {
1952                    if (erased) *xp = *fldp; xp++; fldp++; fldleft--; continue;
1953                }
1954                for (striplen=1, match=0, fldq=fldp, fldqleft=fldleft; fldqleft > 0; ) {
1955                    if (striplen > smumaxlen) break;
1956                    if (*fldq == '>') { match=1; break; }
1957                    fldq++; fldqleft--; striplen++; continue;
1958                }
1959                if (!match) {
1960                    if (erased) *xp = *fldp; xp++; fldp++; fldleft--; continue;
1961                }
1962                fldp+=striplen; fldleft-=striplen; erased+=striplen;
1963            }
1964        if (erased) memset(xp,' ',erased);
1965        /*...*/
1966                p+=n;
1967        /*... p+=endmatch; ...*/
1968        /*... n-=erased; ...*/
1969        }
1970#endif /* STRIPMARKUP */
1971/* CMD 'A' */
1972/* CMD '{' */
1973        else {
1974            c= *p++;
1975#if RUFxRACE
1976printf("+++c=%c\n",c);
1977#endif
1978            for (n=0; *p; p++, n++)
1979                if (*p == c) break;
1980#if RUFxRACE
1981else printf("+++%d  p=%c\n",n,*p);
1982printf("+++%d\n",n);
1983#endif
1984            if (*p != c) {
1985                freex(srcareap,dirarea);
1986                return(errp);
1987            }
1988        }
1989/* END CMD 'A' */
1990/* END CMD 'H' */
1991/* END CMD '<' */
1992/* END CMD '{' */
1993
1994#if STRIPMARKUP
1995            if (cc == '<' && n /*...*/ -erased /*...*/ < fldlenmin) {
1996        /*...*/ p+=endmatch; /*...*/
1997        }
1998        else {
1999#endif /* STRIPMARKUP */
2000        sp=srcareap+dirsleft;
2001            for (reploop=1, dirp=dirarea+dirsleft; reploop-- ; dirp++, sp++) {
2002                if (dirsleft >= maxdirs) {
2003            freex(srcareap,dirarea);
2004                    return(errp);
2005                }
2006                dirp->tag = (UWORD)tag;
2007                dirp->pos = (FFI)(p-batchp)-n;                  /* v3.4 */
2008#if STRIPMARKUP
2009        /*...*/ p+=endmatch; /*...*/
2010        /*...*/ n-=erased; /*...*/
2011#endif /* STRIPMARKUP */
2012                dirp->len = (FFI)n;
2013                *sp = 'b';      /* source is batchp */          /* v3.4 */
2014                vlenadd+=dirp->len;
2015                dirsleft++;
2016                nadd++;
2017#if RUFTRACE
2018printf("fldupdat - A - tag=%d  dirsleft=%d  vlenadd=%d\n",
2019tag,dirsleft,vlenadd);
2020for (sxp=srcareap, dp=dirarea, loop=0; loop<dirsleft; loop++, dp++, sxp++)
2021 printf("fldupdat - dir[%d]: tag=%d  pos=%d(%c)  len=%d\n",
2022  loop,dp->tag,dp->pos,*sxp,dp->len);
2023#endif
2024            }
2025#if STRIPMARKUP
2026        }
2027            if (cc != 'H' && cc != '<')
2028#else /* STRIPMARKUP */
2029            if (cc != 'H')
2030#endif /* STRIPMARKUP */
2031        p++;
2032            break;
2033
2034        default:
2035        freex(srcareap,dirarea);
2036            return(errp);
2037        }
2038    }
2039#if BEFORE20000426
2040    if ((MFRmfrl+(nadd-ndel)*sizeof(DIRSTRU)-vlendel+vlenadd) > RECnbytes) {
2041#else
2042    if ((LONGX)(MFRmfrl+(nadd-ndel)*sizeof(DIRSTRU)-vlendel+vlenadd) >
2043        (LONGX)RECnbytes) { /* AOT/RP - 26/04/2000 - para ALPHACPU (IPEN) */
2044#endif
2045    freex(srcareap,dirarea);
2046        return(batchp);
2047    }
2048
2049    if (ndel) {
2050        mfdirp=MFRdir;
2051        newp=MFX+MFRbase-(k=sizeof(DIRSTRU)*ndel); lastpos=0;
2052        sp=srcareap;
2053        for (dirp=dirarea, n=dirsleft; n--; dirp++, sp++)
2054            if (*sp == 'r') {                                   /* v3.4 */
2055                mfdirp->tag = dirp->tag;
2056                mfdirp->pos = lastpos;
2057                mfdirp->len = dirp->len;
2058                p=MFX+MFRbase+dirp->pos;
2059                memcpy(newp,p,dirp->len); newp+=dirp->len;
2060                lastpos+=dirp->len;
2061                mfdirp++;
2062            }
2063        MFRbase-=k;
2064        MFRnvf-=ndel;
2065        MFRmfrl-=(k+vlendel);
2066    }
2067
2068    if (nadd) {
2069        nxtpos=MFRmfrl-MFRbase;
2070        nxtp=MFX+MFRmfrl+(k=sizeof(DIRSTRU)*nadd);
2071        for (p=(mfp=nxtp-1)-k, mfdirp=MFRdir, n=MFRnvf; n--; ) {
2072            for (loop=mfdirp->len; loop--; )
2073                    *mfp-- = *p--;
2074            /* mfdirp->pos+=k;  MFRbase will be changed */
2075            mfdirp++;
2076        }
2077        if (mfdirp != &MFRdir[MFRnvf])
2078            fatal("fldupdat/bug");
2079        sp=srcareap;                                            /* v3.4 */
2080        for (mfp=nxtp, dirp=dirarea, n=dirsleft; n--; dirp++, sp++) {
2081            if (*sp == 'r')                                     /* v3.4 */
2082                continue;
2083            p=batchp+dirp->pos;                                 /* v3.4 */
2084            memcpy(mfp,p,dirp->len); mfp+=dirp->len;
2085            mfdirp->tag = dirp->tag;
2086            mfdirp->pos = nxtpos;
2087            mfdirp->len = dirp->len;
2088            mfdirp++;
2089            nxtpos+=dirp->len;
2090        }
2091        MFRbase+=k;
2092        MFRnvf+=nadd;
2093        MFRmfrl+=(k+vlenadd);
2094    }
2095
2096#if RUGTRACE
2097    printf("fldupdat - RECrc=%d  Leader: %ld,%d,%ld,%d,%d,%d,%d\n",
2098        RECrc,MFRmfn,MFRmfrl,MFRmfbwb,MFRmfbwp,MFRbase,MFRnvf,MFRstatus);
2099for (mfdirp=MFRdir, loop=0; loop<MFRnvf; loop++, mfdirp++) {
2100 printf("fldupdat - dir[%d]: tag=%d  pos=%d  len=%d",
2101  loop,mfdirp->tag,mfdirp->pos,mfdirp->len);
2102#if RUHTRACE
2103 printf("  ->");
2104 for (p=MFX+MFRbase+mfdirp->pos, n=mfdirp->len; n--; p++)
2105  printf("%c",*p);
2106 printf("<-");
2107#endif
2108printf("\n");
2109}
2110#endif
2111
2112    freex(srcareap,dirarea);
2113
2114    if (sort) {
2115#if CICPP
2116        try { srcareap = (char *) new char [MFRmfrl-MFRbase+1]; }
2117        catch (BAD_ALLOC) { srcareap = (char *)ALLONULL; }
2118#else /* CICPP */
2119        srcareap=(char *)ALLOC((ALLOPARM)(MFRmfrl-MFRbase+1));
2120#endif /* CICPP */
2121        if (srcareap == (char *)ALLONULL) fatal("fldupdat/ALLOC/sort");
2122        dirarea=NULL;
2123        dirp=MFRdir;
2124        sp=srcareap;
2125        lastpos=0;
2126        for (n=MFRnvf; n--; dirp++) {
2127            p=MFX+MFRbase+dirp->pos;
2128            memcpy(sp,p,dirp->len); sp+=dirp->len;
2129            dirp->pos = lastpos;
2130            lastpos+=dirp->len;
2131        }
2132        memcpy(MFX+MFRbase,srcareap,MFRmfrl-MFRbase);
2133    freex(srcareap,dirarea);
2134    }
2135
2136    return(NULL);
2137#undef freex
2138}
Note: See TracBrowser for help on using the browser.