root/trunk/aotmsa12.c

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

essage first commit
Line 
1/* =============================================================================
2   AOTMSA2     Adalberto Otranto Tardelli / Meide da Silva Ancao
3               Application 2
4               by AOT, 05/02/2002
5
6   aotmsa2.c   CI/tabula casos segundo variavel/variaveis de controle
7   -----------------------------------------------------------------------------
8
9   aotmsa2 <action>[,...] [<option> [...]]
10
11      actions:   C  - get parameters from cgi
12                 1  - display header MDL:
13                TB  - search amdl
14                      tabulate amdl (v351/)
15                      store F tab and W tab
16                DB  - read F tab and W tab
17                      display formA results
18
19      options:  bool=<expr>
20                cip=<>                             c:/2001x300/usersaot/cip.cip
21                decs=<>                            decs
22                amdl=<>                            amdl351
23                atmdl=<>                           atmdl (000001..039999)
24                name=<>                            c:\windows\temp\tmp1.$$$
25                pft=<>                             aotmsa2A.pft
26                atmdl99                            amdl351.maxmfn
27                {from||loop|count|tell|setno}=<n>
28   -----------------------------------------------------------------------------
29============================================================================= */
30
31#include <stdio.h>
32#include <string.h>
33#include <ctype.h>
34#include <time.h>
35#include "cisis.h"          /* CISIS Interface header file */
36#include "cirun.h"          /* CISIS Interface runtime declarations */
37#include "cib70.h"          /* CISIS Interface search engine */
38
39
40#if 1  /* ANSITABS */
41/* ---------------------------------------------------------------------- ansiuc.tab -- */
42unsigned char ansiuctab[256]=
43{
44          0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
45         16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
46         32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
47         48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
48         64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
49         80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
50         96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
51         80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
52        128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
53        144,145,146,147,148,149,150,151,152,153,138,155,140,157,158,159,
54        160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
55        176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
56         65, 65, 65, 65, 65, 65, 65, 67, 69, 69, 69, 69, 73, 73, 73, 73,
57         68, 78, 79, 79, 79, 79, 79,215,216, 85, 85, 85, 85, 89,222,223,
58         65, 65, 65, 65, 65, 65, 65, 67, 69, 69, 69, 69, 73, 73, 73, 73,
59        208, 78, 79, 79, 79, 79, 79,247,216, 85, 85, 85, 85,221,222,221
60};
61/* ---------------------------------------------------------------------- ansiac.tab -- */
62unsigned char ansiactab[] = {
63 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
64 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
65 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99,100,101,102,103,104,
66 105,106,107,108,109,110,111,112,113,114,115,116,117,
67118,119,120,121,122,128,129,130,131,132,133,134,135,136,137,138,139,140,141,
68142,143,144,145,146,147,148,149,150,151,152,153,154,
69160,161,162,163,164,165,168,192,193,194,195,196,199,200,201,202,203,204,205,
70206,207,209,210,211,212,213,214,217,218,219,220,221,
71224,225,226,227,228,231,232,233,234,235,236,237,238,239,241,242,243,244,245,
72246,249,250,251,252,253,255
73,000
74};
75/* ------------------------------------------------------------------------------------ */
76#endif /* 0000 */
77
78
79#define CLASSES   40000     /* default */
80
81#define TAG351      351     /* DecsMfn tag - MH by serverw::\bases\mdl.006\aot\get*\ */
82#define TAG020       20     /* DecsCateg tag - standard A00.000.000.000...000 - currently up to 39 chrs */
83
84#define MAXCATLEN    47     /* 111.222.333.444.555.666.777.888.999.000.111.222 */
85
86#define TAG022       22     /* DecsCDallCategs tag  */
87#define TAG005        5     /* DecsCDCateg1MFN tag  */
88
89#define ATMDLTAG999 999     /* atmdl/999999 tag 999 = amdl351.maxmfn */
90
91typedef struct tabfreqf_entry {
92    LONGX v351;
93    LONGX freq;         /*           = docs de TT em xA */
94} TABFREQF_ENTRY;
95
96typedef struct tabfreqd_entry {
97    LONGX v351;
98//    LONGX delta;
99    char delca[MAXCATLEN+1];
100    LONGX gmfn;
101} TABFREQD_ENTRY;
102
103typedef struct tabfreqw_entry {
104    LONGX v351;
105    float peso;
106    LONGX docsTTxA;       /*  v999[1] = docs de TT em xA */
107    LONGX docsTTamdl;     /*  v999[2] = docs de TT em amdl = postings de TT em amdl */
108//    LONGX docsTOTxA;    /* v9991[1] = docs de xA - nao vazios */
109//    LONGX docsTOTamdl;  /* v9991[2] = docs de amdl */
110    float frelTTxA;      /* v1991[1] = frelTTxA = docs de TT em xA / docs de xA */
111    float frelTTamdl;    /* v1991[2] = frelTTamdl = docs de TT em amdl / docs de amdl */
112//see peso    float pesoTTxA;      /* v2991[1] = frelTTxA / frelTTamdl */
113//    char pesoTTxAout[4]; /* v2221[1] = 'out' se peso < 1 */
114} TABFREQW_ENTRY;
115
116/* prototypes */
117#if ANSI
118int rutfreqF(LONGX *tabcntA, int ntabs, LONGX drec, LONGX *tabcntArankF, TABFREQF_ENTRY **tabfreqFp);
119int outfreqF(int ntabs, char *dbnoutp, LONGX *tabcntArankW, LONGX *tabcntArankD, TABFREQF_ENTRY *tabfreqFp);
120int rutfreqW(TABFREQF_ENTRY *tabfreqF, int ntabs, char *amdlname, LONGX docsTOTxA, LONGX docsTOTamdl, LONGX *tabcntArankF, LONGX *tabcntArankW, TABFREQW_ENTRY **tabfreqWp, LONGX *tabcntMDL, LONGX *gtabcntA);
121int outfreqW(int ntabs, char *dbnoutp, LONGX docsTOTxA, LONGX docsTOTamdl, LONGX *tabcntArankF, LONGX *tabcntArankD, TABFREQD_ENTRY *tabfreqD, TABFREQW_ENTRY *tabfreqW);
122int rutfreqD(TABFREQF_ENTRY *tabfreqF, int ntabs, LONGX *tabcntArankF, LONGX *tabcntArankW, LONGX *tabcntArankD, TABFREQD_ENTRY **tabfreqDp, LONGX *tabcntGMDL, LONGX *gtabcntA);
123int outfreqD(int ntabs, char *dbnoutp, LONGX *tabcntArankF, LONGX *tabcntArankW, TABFREQD_ENTRY *tabfreqD);
124
125char *recsfldv(char *areap, char *fldp, FFI fldlen, char *defaultp);
126#else
127int rutfreqF();
128int outfreqF();
129int rutfreqW();
130int outfreqW();
131int rutfreqD();
132int outfreqD();
133char *recsfldv();
134#endif
135
136                                      /* <========================= */
137LONGX ddrec;
138char *ddecsdbnp;
139                                      /* <========================= */
140
141/* tabs here */
142    int  ntabs=0;                  /* numero de entradas de tabcntA/tabcntArankx */
143    LONGX tabcntA     [CLASSES+1];  /* indexed by DecsMfn */ /* avoid -1 */
144    LONGX tabcntArankF[CLASSES+1];  /* indexed by DecsMfn */
145    LONGX tabcntArankW[CLASSES+1];  /* indexed by DecsMfn */
146    LONGX tabcntArankD[CLASSES+1];  /* indexed by DecsMfn */
147
148    int  gntabs=0;                  /* numero de entradas de gtabcntA */
149    LONGX gtabcntA    [CLASSES+1];   /* indexed by DecsMfn */
150
151    LONGX tabcntMDL   [CLASSES+1];  /* indexed by DecsMfn */
152    LONGX tabcntGMDL  [CLASSES+1];  /* indexed by DecsMfn */
153
154#define MAXTABV05  42099
155    LONGX vcategmfn[26][10][10];    /* indexed by [A][0][0] */  /* 10K */
156    int ntabv05=0;                 /* avail */
157    LONGX vtabv05[MAXTABV05];       /* indexed by vtabv05xrf[DecsMnf] */
158    int  vtabv05xrf[CLASSES+1];    /* starting index 0..MAXTABV05-1 */
159    int  vtabv05len[CLASSES+1];    /* number of entries */
160/* tabs here */
161
162
163void main(argc,argv_main)
164int argc;
165char *argv_main[];
166{
167#define MAXARGS 512
168    char *argv[MAXARGS+1];
169    int i,argnext=1;
170
171    void *ciapip = NULL;
172
173    RECSTRU *recp;
174    LONGX irec=0L;
175    unsigned char *p,*q;
176
177    LONGX   vtime[100];   /* watch */
178    char *vtimid[100];   /* watch */
179    int      ntimes=0;   /* watch */
180
181    int parmtime=0;
182    int parmloadmdl=1;
183
184    int parmgroup=0;
185    LONGX mydrec=0L;
186
187    char parmsortx='\0'; /* actual sort parameter */
188    int parmshowgrp1=0;  /* show group01.w information */       /* 1 */
189    int parmshowcat1=0;  /* show first cat1 - name */           /* c */
190    int parmshowtree=0;  /* show hierarchy?? lines */           /* t */
191    int parmshowzero=0;  /* don't show condition lines */       /* z */
192   
193       
194#define ENVASIZE  8000
195    char envarea[ENVASIZE];
196
197    char *usernamp="aot";
198    char *parmaid=NULL;
199
200    /* ---------------------------------------------------------------------- */
201    LONGX boolridx=0L;
202    LONGX booldbcrec=0L; /* b5_exp usa booldbcrec condicionado a namedbnp */
203
204    LONGX boolhits=0;
205    LONGX boolh;
206    LONGX booltell=0L;               /* 0L = no msg; 1L = tell; 2L = tell+root */
207    LONGX booltlir=0L;               /* b70 invx */
208    b7_CIB7 *cib7p=NULL;
209    B7HITLIST *hitlistp;            /* hit processing */
210    LONGX *mfnlistp;                 /* hit processing */
211
212    char booltmpnam[128]={'\0'};    /* b72 MFQTHMEM tmp file */
213
214    /* ---------------------------------------------------------------------- */
215/* tabs here */
216    TABFREQF_ENTRY *tabfreqF=NULL; /* indexed by rankF */
217    TABFREQW_ENTRY *tabfreqW=NULL; /* indexed by rankW */
218    TABFREQD_ENTRY *tabfreqD=NULL; /* indexed by rankD */
219
220    LONGX docsTOTxA;    /* v9991[1] = docs de xA - nao vazios */
221    LONGX docsTOTamdl;  /* v9991[2] = docs de amdl */
222
223    LONGX count1=0L;                /* registros lidos */
224    LONGX count2=0L;                /* casos tabulados */
225
226    LONGX drec=0L;
227    char *gidbnp=NULL;
228
229    int parmtrace=0;
230/*nu     LONGX parmfrom=1,parmto=999999999L,parmcount=0; */
231
232/* -------------------------------------------------------------------------- */
233    char *cipfnamp=NULL;
234    char *decsdbnp=NULL;
235    char *amdldbnp=NULL;
236    char *atmdldbnp=NULL;
237    char *tmp1dbnp=NULL;
238    char *pftfnamp=NULL;
239    char *langp=NULL;
240    LONGX  parmloopTB=0;
241    LONGX  parmtellTA=0;
242    LONGX  parmfromDB=0;
243    LONGX  parmcountDB=0;
244    char *parmsortp=NULL;
245    char *parmdownp=NULL;
246    char *namedbnp=NULL;     /* b7x query dbn */
247    char *boolqryp=NULL;     /* bool= */
248    LONGX  boolsetno=0;       /* b7x set no. */
249    int   parmatmdl99=0;
250
251    char *prmloopTA =NULL;
252    char *prmfromDB =NULL;
253    char *prmcountDB=NULL;
254    char *prmboolset=NULL;
255    char *prmatmdl99=NULL;
256
257    char *actionp=NULL;
258
259    int   actionCG=0;
260    int   actionDD=0;
261    int   actionTB=0;
262    int   actionDB=0;
263
264    int   parmdown=0;
265
266/* -------------------------------------------------------------------------- */
267    char namedbnarea[BUFSIZ];
268
269    char dbnoutF[BUFSIZ];
270    char dbnoutW[BUFSIZ];
271    char dbnoutD[BUFSIZ];
272/* -------------------------------------------------------------------------- */
273
274#if CICGI
275    char *cgipfxp="tag";
276    UWORD cgitag=2000;
277    char *wwwp=NULL;
278    LONGX wrec;
279#endif
280
281    /* here we go..
282    */
283#if CIAPI
284    ciapip = cisisApplication( MAXNREC,MAXNTRM );/* mandatory for CIAPI definitions */
285#endif /* CIAPI */
286
287    /* get calling arguments
288    */
289    for (i=0; i < argc; i++) argv[i]=argv_main[i];
290
291    /* set watch
292    */
293    vtimid[ntimes]="start"; time(&vtime[ntimes++]); /* watch */
294
295    /* set ansiuc & ansiac
296    */
297#if 1  /* ANSITABS */
298    memcpy(isisuctab,ansiuctab,sizeof(ansiuctab));
299    memset(isiswctab,0x00,256);
300    for (isiswctot=0; ansiactab[isiswctot]; isiswctot=isiswctot+1) isiswctab[ansiactab[isiswctot]]=1;
301#endif /* 0000 */
302
303    /* check if trace is present */
304    for (i=0; i < argc; i++) {
305        p=argv[i];
306        if (strncmp(p,"trace?",6) == 0 || strncmp(p,"trace=",6) == 0) {
307            if (sscanf(p+6,"%d",&parmtrace) != 1) fatal(p);
308              if (parmtrace) {
309                  printf("+++trace: trace='%.11s\n'",p);
310                  printf("Content-type: text/plain\n\n");
311                  printf("+++trace: \n");
312              }
313            break;
314        }
315    }
316
317#ifndef FORCECGI
318#define FORCECGI 0
319#endif
320#if FORCECGI
321    putenv("REQUEST_METHOD=GET");
322    putenv("QUERY_STRING=lang=p&action=C%2CTB%2CDB&amdl=amdl351&bool=009068&bool=034268&bool=034269&loop=100&sort=f&from=1&count=20&x=39&y=3");
323#endif
324
325
326    /* get CGI data
327    */
328#if CICGI
329    RECORD(wrec=nrecs,"null",1L); RECrc=RCNORMAL; MFRstatus=ACTIVE;
330    wwwp=NULL; cicgi0(&argc, argv, &wwwp, cgitag, cgipfxp);
331
332    if (wwwp) {
333
334      DIRSTRU *dirp;
335      int xdir,iocc,loop;
336      if (fldupdat(wrec,wwwp)) fatal(wwwp);
337
338      /* check if trace is present */
339      for (parmtrace=0, dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++)
340        if (dirp->tag == cgitag) {
341          p=FIELDP(xdir);
342          if (strncmp(p,"^ntrace^v",2+5+2) == 0) {
343              parmtrace=1;
344              if (parmtrace) {
345                  printf("+++trace: trace='%.11s\n'",p);
346                  printf("Content-type: text/plain\n\n");
347                  printf("+++trace: \n");
348                  break;
349              }
350          }
351        }
352
353      /* check if cgi is enabled */
354      for (actionCG=0, dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++)
355        if (dirp->tag == cgitag) {
356          p=FIELDP(xdir);
357          if (strncmp(p,"^naction^vC",2+6+2+1) == 0) {
358              actionCG=1;
359              if (parmtrace) printf("+++trace: action='%.11s'\n",p);
360              break;
361          }
362        }
363
364      if (actionCG) { /* cgi is enabled */
365
366      for (dirp=MFRdir, xdir=iocc=0, loop=MFRnvf; loop--; dirp++, xdir++) {
367        if (dirp->tag == cgitag) {
368          FFI plen;
369          p=FIELDP(xdir); plen=dirp->len; iocc++;
370          /* get CGI by name
371          */
372          if (strncmp(p,"^ncip^v"    , 3+4) == 0)   cipfnamp  =recsfldv(NULL,p,plen,"");
373          if (strncmp(p,"^ndecs^v"   , 4+4) == 0)   decsdbnp  =recsfldv(NULL,p,plen,"");
374          if (strncmp(p,"^namdl^v"   , 4+4) == 0)   amdldbnp  =recsfldv(NULL,p,plen,"");
375          if (strncmp(p,"^natmdl^v"  , 5+4) == 0)   atmdldbnp =recsfldv(NULL,p,plen,"");
376          if (strncmp(p,"^ntmp1^v"   , 4+4) == 0)   tmp1dbnp  =recsfldv(NULL,p,plen,"");
377          if (strncmp(p,"^npft^v"    , 3+4) == 0)   pftfnamp  =recsfldv(NULL,p,plen,"");
378          if (strncmp(p,"^nlang^v"   , 4+4) == 0)   langp     =recsfldv(NULL,p,plen,"");
379          if (strncmp(p,"^nloop^v"   , 4+4) == 0) { prmloopTA =recsfldv(NULL,p,plen,""); parmloopTB =atol(prmloopTA ); }
380          if (strncmp(p,"^nfrom^v"   , 4+4) == 0) { prmfromDB =recsfldv(NULL,p,plen,""); parmfromDB =atol(prmfromDB ); }
381          if (strncmp(p,"^ncount^v"  , 5+4) == 0) { prmcountDB=recsfldv(NULL,p,plen,""); parmcountDB=atol(prmcountDB); }
382          if (strncmp(p,"^nsort^v"   , 4+4) == 0)   parmsortp =recsfldv(NULL,p,plen,"");
383          if (strncmp(p,"^ndown^v"   , 4+4) == 0)   parmdownp =recsfldv(NULL,p,plen,"");
384          q=NULL;
385          if (strncmp(p,"^nbool^v"   , 4+4) == 0)   q         =recsfldv(NULL,p,plen,"");
386          if (q) {
387              if (boolqryp) {
388                  sprintf(envarea,"%s or %s",boolqryp,q);
389                  boolqryp=strdup(envarea);
390              }
391              else boolqryp=q;
392          }
393          if (strncmp(p,"^nname^v"   , 4+4) == 0)   namedbnp  =recsfldv(NULL,p,plen,"");
394          if (strncmp(p,"^natmdl99^v", 7+4) == 0) { prmatmdl99=recsfldv(NULL,p,plen,""); parmatmdl99=atoi(prmatmdl99); }
395          if (strncmp(p,"^naction^v" , 6+4) == 0)   actionp   =recsfldv(NULL,p,plen,"");
396          if (strncmp(p,"^nsetno^v"   , 5+4) == 0) { prmboolset=recsfldv(NULL,p,plen,""); boolsetno=atol(prmboolset); }
397
398        } /* end if (dirp->tag == cgitag) */
399      } /* end for (dirp=MFRdir) */
400    } /* end if (cgi is enabled */
401    } /* end if (wwwp) */
402#endif /* CICGI */
403
404
405    /* set default values
406    */
407    if (!cipfnamp)    cipfnamp    = "c:/2001x300/usersaot/cip.cip";
408    if (!decsdbnp)    decsdbnp    = "decs";
409    if (!amdldbnp)    amdldbnp    = "amdl351";
410    if (!atmdldbnp)   atmdldbnp   = "atmdl";
411    if (!tmp1dbnp)    tmp1dbnp    = NULL;
412    if (!pftfnamp)    pftfnamp    = "aotmsa2A.pft";
413    if (!langp)       langp       = "p";
414    if (!parmloopTB)  parmloopTB  = 1;
415    if (!parmtellTA)  parmtellTA  = 0; /* */
416    if (!parmfromDB)  parmfromDB  = 1;
417    if (!parmcountDB) parmcountDB = 0;
418    if (!parmsortp)   parmsortp   = "f";
419    if (!parmdownp)   parmdownp   = "0";
420    if (!parmatmdl99) parmatmdl99 = 0;
421    if (!actionp)    {actionCG    = 0;
422                      actionDD    = 0;
423                      actionTB    = 0;
424                      actionDB    = 0; }
425    if (!boolsetno)   boolsetno   = 0;
426
427    dbnoutF[0]='\0';   /* .f */
428    dbnoutW[0]='\0';   /* .w */
429    dbnoutD[0]='\0';   /* .w */
430
431
432    if (argc < 2 && !wwwp) {
433        printf("%s",cicopyr("Application AOTMSA2"));
434        printf(" \n");
435        printf("aotmsa2 <action>[,...] [<option> [...]] \n");
436        printf(" \n");
437        printf("actions:  C   - get parameters from cgi \n");
438        printf("          TB  - search amdl \n");
439        printf("                tabulate amdl (v351/) \n");
440        printf("                store tableF and tableW \n");
441        printf("                DB  - read tableF or tableW \n");
442        printf("                      display formA results \n");
443        printf(" \n");
444        printf("options: loop=<n>       \n");
445        printf("         from|count=<n> \n");
446        printf("         sort={f|w} \n");
447        printf("         btell|tell=<n> \n");
448        printf("         bool=<expr> [setno=<n>]  \n");
449        printf("         atmdl99    \n");
450        printf(" \n");
451        printf("         cip    ,                              %s \n",  cipfnamp    );
452        printf("         decs   ,                              %s \n",  decsdbnp    );
453        printf("         amdl   ,                              %s \n",  amdldbnp    );
454        printf("         atmdl  ,                              %s \n",  atmdldbnp   );
455        printf("         tmp1   ,                              %s \n",  tmp1dbnp    );
456        printf("         pft    ,                              %s \n",  pftfnamp    );
457        printf("         lang   ,                              %s \n",  langp       );
458        printf("         loop   ,                              %"_LD_" \n",  parmloopTB  );
459        printf("         from   ,                              %"_LD_" \n",  parmfromDB  );
460        printf("         count  ,                              %"_LD_" \n",  parmcountDB );
461        printf("         sort   ,                              %s \n",  parmsortp   );
462        printf("         down   ,                              %s \n",  parmdownp   );
463        printf("         bool   ,                              %s \n",  boolqryp    );
464        printf("         name   ,                              %s \n",  namedbnp    );
465        printf("         atmdl99,                              %d \n",  parmatmdl99 );
466        printf("         action ,                              %s \n",  actionp     );
467        printf("         setno  ,                              %"_LD_" \n",  boolsetno );
468        printf(" \n");
469        exit(1);
470        }
471
472
473    /*
474        get options
475    */
476    for (; argnext < argc; argnext++) {
477        p=argv[argnext];
478
479        if (strncmp(p,"cip?",4) == 0 || strncmp(p,"cip=",4) == 0) {
480            cipfnamp=p+4;
481            continue;
482        }
483        if (strncmp(p,"decs?",5) == 0 || strncmp(p,"decs=",5) == 0) {
484            decsdbnp=p+5;
485            continue;
486        }
487        if (strncmp(p,"amdl?",5) == 0 || strncmp(p,"amdl=",5) == 0) {
488            amdldbnp=p+5;
489            continue;
490        }
491        if (strncmp(p,"atmdl?",6) == 0 || strncmp(p,"atmdl=",6) == 0) {
492            atmdldbnp=p+6;
493            continue;
494        }
495        if (strncmp(p,"tmp1?",5) == 0 || strncmp(p,"tmp1=",5) == 0) {
496            tmp1dbnp=p+5;
497            continue;
498        }
499        if (strncmp(p,"pft?",4) == 0 || strncmp(p,"pft=",4) == 0) {
500            pftfnamp=p+4;
501            continue;
502        }
503        if (strncmp(p,"loop?",5) == 0 || strncmp(p,"loop=",5) == 0) {
504            if (sscanf(p+5,"%"_LD_,&parmloopTB) != 1) fatal(p);
505            continue;
506        }
507        if (strncmp(p,"from?",5) == 0 || strncmp(p,"from=",5) == 0) {
508            if (sscanf(p+5,"%"_LD_,&parmfromDB) != 1) fatal(p);
509            continue;
510        }
511        if (strncmp(p,"count?",6) == 0 || strncmp(p,"count=",6) == 0) {
512            if (sscanf(p+6,"%"_LD_,&parmcountDB) != 1) fatal(p);
513            continue;
514        }
515        if (strncmp(p,"sort?",5) == 0 || strncmp(p,"sort=",5) == 0) {
516            parmsortp=p+5;
517            continue;
518        }
519        if (strncmp(p,"down?",5) == 0 || strncmp(p,"down=",5) == 0) {
520            parmdownp=p+5;
521            if (sscanf(parmdownp,"%d",&parmdown) != 1) fatal(p);
522            continue;
523        }
524        if (!strncmp(p,"bool=",5)) {
525            q=loadfile(gidbnp,'@',p+5,NULL,0L,'\n');
526            if (!q) fatal(p);
527            if (boolqryp) {
528                  sprintf(envarea,"%s or %s",boolqryp,q);
529                  boolqryp=strdup(envarea);
530            }
531            else boolqryp=q;
532            continue;
533        }
534        if (strncmp(p,"name?",5) == 0 || strncmp(p,"name=",5) == 0) {
535            namedbnp=p+5;
536            strcpy(namedbnarea,namedbnp);
537            continue;
538        }
539        if (strcmp(p,"atmdl99") == 0) {
540            parmatmdl99=1;
541            continue;
542        }
543        if (strncmp(p,"action?",7) == 0 || strncmp(p,"action=",7) == 0) {
544            actionp=q=p+7;
545            if (!*q) fatal(p);
546            continue;
547        }
548        if (strncmp(p,"setno?",6) == 0 || strncmp(p,"setno=",6) == 0) {
549            if (sscanf(p+6,"%"_LD_,&boolsetno) != 1) fatal(p);
550            continue;
551        }
552        /* offer */
553        if (strncmp(p,"tell?",5) == 0 || strncmp(p,"tell=",5) == 0) {
554            if (sscanf(p+5,"%"_LD_,&parmtellTA) != 1) fatal(p);
555            continue;
556        }
557        if (strncmp(p,"btell?",6) == 0 || strncmp(p,"btell=",6) == 0) {
558            if (sscanf(p+6,"%"_LD_,&booltell) != 1) fatal(p);
559            continue;
560        }
561        if (strcmp(p,"trace") == 0) {
562            parmtrace=1;
563            continue;
564        }
565
566        fatal(p);
567    }
568
569
570    /* actions */
571    if (actionp) {
572      for (q=actionp; *q; ) {
573
574         if (*q == 'C' && strncmp(q,"C" ,1) == 0)
575                   { /*actionCG=1;*/                  if (*(q+=1) == ',') q++; continue; }
576
577         if (isdigit(*q))
578                   {   actionDD=(int)(*q)-(int)'0';   if (*(q+=1) == ',') q++; continue; }
579
580         if (*q == 'T' && strncmp(q,"TB",2) == 0)
581                   {   actionTB=1;                    if (*(q+=2) == ',') q++; continue; }
582
583         if (*q == 'D' && strncmp(q,"DB",2) == 0)
584                   {   actionDB=1;                    if (*(q+=2) == ',') q++; continue; }
585
586         if (*q) fatal(p);
587      }
588    }
589
590    if (parmsortp) {
591        q=parmsortp;
592        if (*q == 'g') { parmgroup=1;    q++; parmsortp=q; }
593        if (*q == '1') { parmshowgrp1=1; q++; }
594        if (*q == 'c') { parmshowcat1=1; q++; }
595        if (*q == 't') { parmshowtree=1; q++; }
596        if (*q == 'z') { parmshowzero=1; q++; }
597        if (strcmp(q,"f") && strcmp(q,"w") && strcmp(q,"d")) fatal(parmsortp);
598        parmsortx= *q;
599    }
600#if 0
601    for (q=parmsortp; *q; q++) {
602        if (*q == 'g') { parmgroup=1; parmsortp=q+1; }
603        if (*q == '1') { parmshowgrp1=1; }
604        if (*q == 'c') { parmshowcat1=1; }
605        if (*q == 't') { parmshowtree=1; }
606        if (*q == 'z') { parmshowzero=1; }
607        if (*q == 'f' || *q == 'w' || *q == 'd') { parmsortx= *q; }
608    }
609#endif
610
611if (parmtrace) {
612  printf("+++trace: tmp1dbnp=%s\n",tmp1dbnp);
613  printf("+++trace: actionp=%s\n",actionp);
614  printf("+++trace: actionDD=%d\n",actionDD);
615  printf("+++trace: actionTB=%d\n",actionTB);
616  printf("+++trace: actionDB=%d\n",actionDB);
617  printf("+++trace:     sort=%s\n",parmsortp);
618  printf("+++trace:    group=%d\n",parmgroup);
619}
620
621
622    /* Common setup
623    */
624
625    /* set cipar */
626    if ((dbxcipfp=fopen(cipfnamp,"r")) == NULL) fatal(cipfnamp);
627    /* rec_maxmfrl */
628    p=dbxcipar(NULL,"maxmfrl",'='); if (dbxcipok) { sscanf(p,"%"_LD_,&rec_maxmfrl); }
629
630    /* set tempfile */
631    if (tmp1dbnp) strcpy(booltmpnam,tmp1dbnp);
632
633    /* set query db */
634    if (namedbnp) {
635        if (strncmp(namedbnp,"create=",7) == 0) {
636            namedbnp+=7;
637            recisis0(namedbnp);
638        } else {
639            int xfd;
640            dbxopt_fatal=0; xfd=dbxopen("",namedbnp,xx1extp);
641            if (xfd > 0) CLOSE(xfd); else recisis0(namedbnp);
642        }
643        RECORD(boolridx=nrecs,namedbnp,0L);
644        if (boolsetno < 1 || boolsetno > MF0nxtmfn-1) boolsetno=MF0nxtmfn-1; /* last set */
645    }
646    else {
647        if (!dbxtmpnm("CI_TEMPDIR", 0, namedbnarea)) fatal("aotmsa2/dbxtmpnm");
648        namedbnp=namedbnarea;
649        if (parmtrace) printf("+++trace: namedbnp=%s\n",namedbnp);
650        recisis0(namedbnp);
651        boolsetno=1L; /* set#1 */
652    }
653
654    /* make output file names
655    */
656    sprintf(dbnoutF,"%s%s",namedbnp,".f");
657    sprintf(dbnoutW,"%s%s",namedbnp,".w");
658    sprintf(dbnoutD,"%s%s",namedbnp,".d");
659
660    parmdown=atoi(parmdownp);
661    if (parmdown < 0x00 || parmdown > 0xFF) parmdown=0;
662
663
664/* =======================         =============          ================== */
665/* =======================         =============          ================== */
666if (actionTB) {
667
668    /* Tabulate A
669    */
670
671    /* init docsTOTamdl - number of docs in Cluster MDL */
672    /* init reading */
673    if (!irec) irec=nrecs;
674    RECORD(irec,amdldbnp,0L);
675    docsTOTamdl=MF0nxtmfn-1;
676    if (parmatmdl99) {
677        RECSTRU *recp;
678        TRMSTRU *trmp;
679        LONGX /*nu irec,*/itrm;
680        char *p;
681        TERM(itrm=ntrms,atmdldbnp,"999999"); if (TRMrc != RCNORMAL) fatal("aotmsa2/atmdl/TERM");
682        RECORD(/*nu irec=*/nrecs,atmdldbnp,posting(itrm,1));  if (TRMrc != RCNORMAL) fatal("aotmsa2/atmdl/RECORD");
683        p=recfield(NULL,boolridx,ATMDLTAG999,1,"");
684        docsTOTamdl = atol(p); if (docsTOTamdl < 1) fatal("aotmsa2/atmdl/999999");
685    }
686
687    /* init docsTOTxa - number of docs in Cluster A */
688    docsTOTxA=docsTOTamdl;
689
690    vtimid[ntimes]="search"; time(&vtime[ntimes++]); /* watch */
691    /*
692        Search "bool=" parameter
693    */
694    if (boolqryp) { /* mxbool/boolh */
695
696        RECSTRU *recp;
697        char *p;
698        LONGX mfn;
699        int errno;
700
701        LONGX asize=strlen(amdldbnp) +                 /* field MFQTDBN0=11 (may be longer than 128+4+1) */
702                   strlen(boolqryp) +                 /* the expression */
703                   2*strlen(boolqryp) +               /* the terms + pseudo operators _1termX+11X */
704                   BUFSIZ+strlen(amdldbnp) +          /* field MFQSWDBN=20 + a diferent db */
705                   24*(strlen(B7DELADD)+3*B7UPLEN) +  /* 2 duzias de control fields */  /* DxxAxx|xxx| */ 
706                   strlen(boolqryp)+4 +               /* tmpfile .%03x */
707                   BUFSIZ;                            /* por si las moscas */
708                   
709        char *buffup=loadfile(NULL,'@',"",NULL,asize,'\0');
710
711        cib7p=b7_cib7(cib7p,ciapip);
712
713        /* initialize ridx and b7_xxx() parameters and run b7_run()
714        */
715        for (boolridx=nrecs, mfn=1; ; mfn++) { /* get actual maxmfn */
716            RECORD(boolridx,amdldbnp,mfn);
717            if (RECrc == RCEOF) fatal(amdldbnp);
718            if (RECrc == RCNORMAL) break;
719        }
720
721        if (namedbnp) {
722            if (!booldbcrec) booldbcrec=nrecs;
723            /*RECORD(booldbcrec,namedbnp,0L); */ /* b7_exp faz "record(crec,qrydbnp,0L)"
724                                                          (se houver "qrydbnp")
725                                                       */
726/*<R>
727            vrecp[boolridx]->recdbxp=RECdbxp;
728*/          /* VRECdbxp(boolridx)=RECdbxp; */ /* b7_exp faz "RECdbxp = dbxstorp(qrydbnp)" */
729        }
730        else {
731            VRECdbxp(boolridx)=NULL; /* nao usa base de log */
732            VMFRmfn(boolridx)=0L;
733        }
734
735        /* run b7_exp() / b7_run() / b7_hit(0)
736        */
737        p=b7_exp(cib7p,boolridx,amdldbnp,boolqryp,buffup,namedbnp,booldbcrec,&errno);
738        if (p || errno) printf("Expression syntax error %d: '%s'\n",errno,p);
739        else {
740            LONGX bufsiz;
741            /* .. sprintf(buffup,"%s.%03x",RDBname,(int)b7setno) .. */
742            char *hitfnamp="null";
743            if (booltmpnam[0]) hitfnamp=booltmpnam;
744            sprintf(buffup,"D%dA%d|%s|",MFQTHMEM,MFQTHMEM,hitfnamp);
745            if (fldupdat(boolridx,buffup) != NULL) fatal("aotmsa2/fldupdat/boolridx");
746
747            /* b7_run faz "trirecp=vrep[tlirec]" */
748            if (!booltlir) record(booltlir=nrecs,"null",1L);
749
750            /* alloc buffer for 20000 hits = 80Kbytes */
751            bufsiz=20000*sizeof(LONGX);
752            if (b7bufferp) b7_hbfree(cib7p,&b7bufferp);
753            b7_hballoc(cib7p,bufsiz,&b7bufferp);
754
755            /* run search */
756            p=b7_run(cib7p,boolridx,amdldbnp,buffup,asize,
757                booltell,isisuctab,""/*btch0p*/,booltlir,booldbcrec,&errno);
758            if (p || errno) printf("Execution error %d: '%s'\n",errno,p);
759            else {
760                // if (b7bufferp->hcase != MFNSTRING) fatal("aotmsa2/MFNSTRING");
761                boolhits=b7bufferp->ndocs; /* b7_hit(cib7p,boolridx,0L,b7setno); */
762                if (booltell) printf("Hits=%"_LD_"\n",boolhits);
763            }
764        }
765        if (p || errno) fatal("Expression execution error");
766
767        /* set# */
768        boolsetno=b7setno;  /* last mfn */
769
770        /* set docsTOTxa - number of docs in Cluster A */
771        docsTOTxA=boolhits;
772
773    } /* mxbool/boolh */
774
775
776    vtimid[ntimes]="set"; time(&vtime[ntimes++]); /* watch */
777
778    /* init tabcntMDL
779    */
780    if (parmloadmdl) {
781        /* loadcnt(amdldbnp,treecase,tabcntMDL,CLASSES);
782AMDL351  CNT            52  12-21-01  9:54p amdl351.cnt
783AMDL351  N01        21,216  12-21-01 10:00p amdl351.n01
784AMDL351  N02             0  12-21-01 10:00p amdl351.n02
785AMDL351  LY1       269,064  12-21-01  9:55p amdl351.ly1
786AMDL351  LY2             0  12-21-01  9:55p amdl351.ly2
787AMDL351  IYP    48,611,328  12-21-01  9:55p amdl351.iyp
788        */
789        int treecase=0;
790        INVMAP *invp;
791        LONGX punt,punt2;
792        char lparea[sizeof(L1STRU)];
793        L1STRU *l1p=(L1STRU *)lparea;
794        int loop;
795        char *keyp;
796        int v351;
797        LONGX ndocs;
798        LONGX tell=0;
799
800        memset(tabcntMDL,0x00,sizeof(tabcntMDL));
801        invsetup(amdldbnp,0L,0L,0L);
802        invp=dbxstorp(amdldbnp)->dbxifmap;
803        if (parmtellTA) tell=(punt2=invp->cn[treecase].fmaxpos)/10+1;
804        if (parmtrace) fprintf(stderr,"+++ punt2=%"_LD_"\n",punt2);
805        /* for each leaf */
806        for (punt=1; punt; punt=l1p->ps) {
807            leafread(lparea,invp,treecase,punt,0); /* read a leaf */
808            /* for each term */
809            for (loop=0; loop < l1p->ock; loop++) {
810                keyp=l1p->idx[loop].key;
811                v351=atoi(keyp); /* LE1 */
812                ndocs=l1p->idx[loop].info2;
813                tabcntMDL[v351]=ndocs;
814            }
815            if (parmtrace) if (tell) if (punt%tell==0) fprintf(stderr,"+++ punt=%"_LD_"\n",punt);
816        }
817
818        memset(tabcntGMDL,0x00,sizeof(tabcntGMDL));
819        if (parmgroup) {
820            RECSTRU *recp;
821            LONGX irec=nrecs;
822            LONGX mfn;
823            char x351[6+1];
824            LONGX v351;
825            DIRSTRU *dirp;
826            int xdir,loop;
827
828            for (mfn=1; ; mfn++) {
829                RECORD(irec,"group01.f",mfn);
830                if (RECrc == RCEOF) break;
831                if (RECrc != RCNORMAL) continue;
832                /* get total records for each group */
833#define G01TAG999 999
834#define G01TAG001   1
835                for (dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++) {
836                    if (dirp->tag == G01TAG999) {
837                       LONGX ndocs=0;
838                       char *p=FIELDP(xdir);
839                       int loop;
840                       for (loop=dirp->len; loop--; p++) ndocs=ndocs*10+((int)(*p)-(int)'0');
841                       recfield(x351,irec,G01TAG001,1,""); v351=atol(x351);
842                       tabcntGMDL[v351]=ndocs;
843#if 0
844printf("+++tabcntGMDL[%"_LD_"]=%"_LD_"\n",v351,tabcntGMDL[v351]);
845getchar();
846#endif
847                       break;
848                    } /* end tag == 999 */
849                } /* end for dirp */
850            } /* end for mfn */
851        }
852
853        /* VTABV05*/
854        memset(vcategmfn,0x00,sizeof(vcategmfn));
855        memset(vtabv05len,0x00,sizeof(vcategmfn)); ntabv05=0;
856
857    }
858
859
860    /* init mxtb
861    */
862    memset(tabcntA,0x00,sizeof(tabcntA));
863    memset(gtabcntA,0x00,sizeof(gtabcntA));
864
865    /* create output
866    */
867    recisis0(dbnoutF);
868    recisis0(dbnoutW);
869    recisis0(dbnoutD);
870
871
872    vtimid[ntimes]="loop"; time(&vtime[ntimes++]); /* watch */
873
874    /*
875        loop principal
876    */
877
878#define MAXN20 30
879#define MAXZ20 12 /* hoje=10 (1*3+9*4=39) */
880#define MAXL20 (MAXZ20*4)
881
882#define MAXNVG 30
883#define MAXN05 30
884
885    for (boolh=1; boolh <= boolhits; boolh+=parmloopTB) {
886
887        LONGX mfn;
888        int v351,v351nocc,xdir,loop;
889        DIRSTRU *dirp;
890        char area[BUFSIZ];
891
892        LONGX vgmfns[MAXNVG];
893        int nvgs=0;
894        int ivg;
895
896        /* hit processing */
897
898        if (boolh == 1) {
899            hitlistp=(B7HITLIST *)b7bufferp->area;
900            mfnlistp=hitlistp->mfnlist;
901        }
902
903        /* get next hit */
904        if (b7bufferp->hcase == BITSTRING)
905            mfn=b7_hit(cib7p,boolridx,boolh,b7setno);
906        else
907            mfn = *mfnlistp; mfnlistp+=parmloopTB;
908
909        if (mfn <= 0) fatal("aotmsa2/TA/amdldbnp/hit");
910
911        if (parmtrace) printf("+++ hit#%"_LD_" mfn=%"_LD_"\n",boolh,mfn);
912
913        RECORD(irec,amdldbnp,mfn);
914        if (RECrc != RCNORMAL) fatal("aotmsa2/TA/amdldbnp/RCNORMAL");
915
916        /* tabulate (v351/) in tabcntA, exploding in gtabcntA
917        */
918        /* get a subject descriptor */
919        v351nocc=0;
920        for (dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++) {
921            if (dirp->tag == TAG351) {
922
923                /* tabulate it */
924                memcpy(area,FIELDP(xdir),dirp->len); area[dirp->len]='\0';
925                v351=atoi(area);
926                if (1/*parmgroup*/)  {
927#if 1 /*V02BAK9J*/ /* v0.2bak9j */
928                    RECSTRU *recp; /* local */
929                    int xdir,loop;
930                    DIRSTRU *dirp;
931#if 0
932                    int parmgrouplen=4;
933                    LONGX mfn;
934                    char *p;
935                    char v20[MAXN20][MAXL20+1];
936                    int n20=0;
937                    char x20[MAXL20+1];
938                    int len,found;
939                    int glen=(parmgroup*parmgrouplen)-1;
940#else
941                    LONGX v05[MAXN05];
942                    int n05=0;
943#endif
944
945                    if (!mydrec) {
946                        LONGX loadxrf=200000;
947                        LONGX loadmst=4000000;
948                        mstsetup("mydecs",loadxrf,loadmst);
949                        mydrec=nrecs;
950                    }
951                    RECORD(mydrec,"mydecs",v351);
952                    if (RECrc != RCNORMAL) fatal("aotmsa2/TA/mydecs/RCNORMAL");
953#if 0
954                    /* build v351groups in v20[] from mydecs (v20/) */
955                    for (dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++) {
956                        if (dirp->tag == TAG020) {
957                            p=FIELDP(xdir);
958                            if (*p == 'C' or *p == 'D') { /* ... */
959                                if ((len=dirp->len) > glen) len=glen;
960                                memcpy(x20,p,len);
961                                if (len < glen) memset(x20+len,' ',glen-len)
962                                for (found=0, i=0; i<n20; i++)
963                                    if (memcmp(x20,v20[i],parmgrouplen1) == 0) { found=1; break; }
964                                if (!found) {
965                                    if (n20 >= MAXN20) fatal("aotmsa2/TA/mydecs/MAXN20");
966                                    memcpy(v20[n20++],x20,parmgrouplen);
967                                }
968                            } /* end 'C' or 'D' */
969                        } /* end tag == TAG020 */
970                    } /* end for dirp */
971#else
972                    /* store v351groups in v05[] from mydecs (v5/) */
973                    for (dirp=MFRdir, xdir=0, loop=MFRnvf; loop--; dirp++, xdir++) {
974                        if (dirp->tag == TAG005) {
975                           LONGX mfn=0;
976                           char *p=FIELDP(xdir);
977                           int loop;
978                           for (loop=dirp->len; loop--; p++) mfn=mfn*10+((int)(*p)-(int)'0');
979                           if (n05 >= MAXN05) fatal("aotmsa2/TA/mydecs/MAXN05");
980                           v05[n05++]=mfn;
981                        } /* end tag == TAG005 */
982                    } /* end for dirp */
983#endif
984                    /* store v05groups in vgmfns[] */
985                    for (i=0; i<n05; i++) {
986                        LONGX mfn=v05[i];
987                        int found;
988                        for (found=0, ivg=0; ivg < nvgs; ivg++)
989                            if (mfn == vgmfns[ivg]) { found=1; break; }
990                        if (!found) {
991                            if (nvgs >= MAXNVG) fatal("aotmsa2/TA/mydecs/MAXNVG");
992                            vgmfns[nvgs++]=mfn;
993                        }
994                    } /* end for v05[] */
995#else /* v0.2bak9j */
996#endif /* v0.2bak9j */
997                } /* end if (1 parmgroup) */
998
999                if (v351 >= CLASSES) fatal("aotmsa2/CLASSES overflow/v351");
1000                if (!tabcntA[v351]) ntabs++;
1001                tabcntA[v351]++;
1002                v351nocc++;
1003
1004            } /* end if (dirp->tag == TAG351) */
1005        } /* end for (dirp=MFRdir, ) */
1006
1007        if (v351nocc) count2++;
1008       
1009        /*
1010           tabulate groups
1011        */
1012        for (ivg=0; ivg < nvgs; ivg++) {
1013            LONGX gmfn=vgmfns[ivg];
1014            if (gmfn >= CLASSES) fatal("aotmsa2/CLASSES overflow/gmfn");
1015            if (!gtabcntA[gmfn]) gntabs++;
1016            gtabcntA[gmfn]++;
1017        } /* end for vgmfns[] */
1018
1019
1020        /* .... */
1021
1022        count1++;
1023        if (parmtellTA) if ((count1 % parmtellTA) == 0)
1024          fprintf(stderr,"+++ %"_LD_": %"_LD_"/%d \n",count1,count2,ntabs);
1025   
1026    } /* end for (boolh=1; boolh <= boolhits;  ) */
1027
1028    /*
1029    if (booltmpnam[0]) remove(booltmpnam);   / * b72 MFQTHMEM tmp file * /
1030    */
1031   
1032
1033
1034    /* run tabfreqF, tabfreqW and tabfreqD
1035    */
1036    if (ntabs) {
1037#if DCTFILTER
1038        /* set docsTOTxa - number of docs in Cluster A */
1039        docsTOTxA=count2_filtered;
1040#endif
1041
1042        /* run tabfreqF
1043        */
1044        vtimid[ntimes]="freqF"; time(&vtime[ntimes++]); /* watch */
1045        if (parmtrace) fprintf(stderr,"+++ ntabs=%d ..\n",ntabs);
1046        if (parmtrace) fprintf(stderr,"+++ running %s ..\n",dbnoutF);
1047        if (!drec) record(drec=nrecs,decsdbnp,0L);
1048ddrec=drec;
1049ddecsdbnp=decsdbnp;
1050        if (rutfreqF(tabcntA,ntabs,drec,tabcntArankF,&tabfreqF)) exit(3);
1051
1052        /* run tabfreqW
1053        */
1054        vtimid[ntimes]="freqW"; time(&vtime[ntimes++]); /* watch */
1055        if (parmtrace) fprintf(stderr,"+++ runing %s ..\n",dbnoutW);
1056        if (rutfreqW(tabfreqF,ntabs,amdldbnp,docsTOTxA,docsTOTamdl,tabcntArankF,tabcntArankW,&tabfreqW,(parmloadmdl?tabcntMDL:NULL),gtabcntA)) exit(4);
1057
1058        /* run tabfreqD
1059        */
1060        vtimid[ntimes]="freqD"; time(&vtime[ntimes++]); /* watch */
1061        if (parmtrace) fprintf(stderr,"+++ runing %s ..\n",dbnoutD);
1062        if (rutfreqD(tabfreqF,ntabs,tabcntArankF,tabcntArankW,tabcntArankD,&tabfreqD,tabcntGMDL, gtabcntA)) exit(5);
1063
1064        /* output tabfreqD
1065        */
1066        vtimid[ntimes]="outD"; time(&vtime[ntimes++]); /* watch */
1067        if (parmtrace) fprintf(stderr,"+++ updating %s ..\n",dbnoutD);
1068        if (outfreqD(ntabs,dbnoutD,tabcntArankF,tabcntArankW,tabfreqD)) exit(6);
1069        /* output tabfreqF
1070        */
1071        vtimid[ntimes]="outF"; time(&vtime[ntimes++]); /* watch */
1072        if (parmtrace) fprintf(stderr,"+++ updating %s ..\n",dbnoutF);
1073        if (outfreqF(ntabs,dbnoutF,tabcntArankW,tabcntArankD,tabfreqF)) exit(7);
1074        /* output tabfreqW
1075        */
1076        vtimid[ntimes]="outW"; time(&vtime[ntimes++]); /* watch */
1077        if (parmtrace) fprintf(stderr,"+++ updating %s ..\n",dbnoutW);
1078        if (outfreqW(ntabs,dbnoutW,docsTOTxA,docsTOTamdl,tabcntArankF,tabcntArankD,tabfreqD,tabfreqW)) exit(8);
1079    }
1080
1081if (ntabs) {
1082
1083    /* log A1
1084    */
1085    if (!parmaid) parmaid="A1";
1086    if (strcmp(parmaid,"A1") == 0) {
1087        char *batchp=envarea;
1088    /* environment */
1089    if (usernamp   ) { sprintf(batchp,"a3300|%s|" , usernamp    ); batchp+=strlen(batchp); }
1090    if (cipfnamp   ) { sprintf(batchp,"a3000|%s|" , cipfnamp    ); batchp+=strlen(batchp); }
1091    if (decsdbnp   ) { sprintf(batchp,"a3001|%s|" , decsdbnp    ); batchp+=strlen(batchp); }
1092    if (amdldbnp   ) { sprintf(batchp,"a3002|%s|" , amdldbnp/**/); batchp+=strlen(batchp); }
1093    if (atmdldbnp  ) { sprintf(batchp,"a3003|%s|" , atmdldbnp   ); batchp+=strlen(batchp); }
1094    if (tmp1dbnp   ) { sprintf(batchp,"a3004|%s|" , tmp1dbnp    ); batchp+=strlen(batchp); }
1095    if (pftfnamp   ) { sprintf(batchp,"a3005|%s|" , pftfnamp    ); batchp+=strlen(batchp); }
1096    if (langp      ) { sprintf(batchp,"a3006|%s|" , langp       ); batchp+=strlen(batchp); }
1097    if (parmloopTB ) { sprintf(batchp,"a3007|%"_LD_"|", parmloopTB  ); batchp+=strlen(batchp); }
1098    if (parmfromDB ) { sprintf(batchp,"a3008|%"_LD_"|", parmfromDB  ); batchp+=strlen(batchp); }
1099    if (parmcountDB) { sprintf(batchp,"a3009|%"_LD_"|", parmcountDB ); batchp+=strlen(batchp); }
1100    if (parmsortp  ) { sprintf(batchp,"a3010|%s|" , parmsortp   ); batchp+=strlen(batchp); }
1101    if (boolqryp   ) { sprintf(batchp,"a3011|%s|" , boolqryp    ); batchp+=strlen(batchp); }
1102    if (namedbnp   ) { sprintf(batchp,"a3012|%s|" , namedbnp    ); batchp+=strlen(batchp); }
1103    if (parmatmdl99) { sprintf(batchp,"a3013|%d|" , parmatmdl99 ); batchp+=strlen(batchp); }
1104    if (actionp    ) { sprintf(batchp,"a3014|%s|" , actionp     ); batchp+=strlen(batchp); }
1105/**/
1106                       sprintf(batchp,"a3015|%"_LD_"|", boolsetno   ); batchp+=strlen(batchp);
1107                       sprintf(batchp,"a4001|%d|" , ntabs       ); batchp+=strlen(batchp);
1108/**/
1109        if (1) {
1110        /* add watch */
1111            int hours,mins,secs;
1112            int i;
1113            vtimid[ntimes]="end1"; time(&vtime[ntimes++]); /* watch */
1114            //vtimid[ntimes]="xT";   time(&vtime[ntimes++]); /* watch */
1115            secs=vtime[ntimes-1]-vtime[0];
1116            hours=secs/3600; secs-=hours*3600;
1117            mins=secs/60; secs-=mins*60;
1118            sprintf(batchp,"a3216|%02d:%02d:%02d|",hours,mins,secs); batchp+=strlen(batchp);
1119            for (i=0; i<ntimes-1; i++) {
1120                sprintf(batchp,"a3214|%s|",  vtimid[i]);             batchp+=strlen(batchp);
1121                sprintf(batchp,"a3215|%"_LD_"|", vtime[i+1]-vtime[i]);   batchp+=strlen(batchp);
1122            }
1123            //ntimes--;
1124        }
1125
1126        if (fldupdat(boolridx,envarea)) fatal("aotmsa2/TA/env/fldupdat");
1127        if (recupdat(booldbcrec,boolridx)) fatal("aotmsa2/TA/env/fldupdat");
1128    }
1129
1130    /* done
1131    */
1132    if (parmtellTA)
1133        fprintf(stderr,"aotmsa2: %"_LD_" recs in | %"_LD_" tabs | %d recs out\n",count1,count2,ntabs);
1134
1135} else { /* else if (ntabs) */
1136    actionDB=0;
1137} /* end if (ntabs) */
1138
1139} /* end actionTB */
1140
1141
1142/* =======================         =============          ================== */
1143/* =======================         =============          ================== */
1144
1145
1146if (actionDB) {
1147
1148    /* List tableF/tableW
1149    */
1150
1151#define DECSTAGP     3
1152#define MFQTAENV   102
1153
1154#define FMTASIZE 32000
1155
1156    FMT_CODE *tabfmtp=NULL;           /* formato para tab= */
1157    LONGX ntabfmts=0;
1158    char fmtspec[BUFSIZ];
1159    char *batchp;
1160    LONGX parmfrom,parmto;
1161    LONGX parmtell=/*0*/parmtellTA;
1162    LONGX mfn1;
1163    char *file1p;
1164    DBXSTRU *dbx1p;
1165   
1166    char fmtarea[FMTASIZE+1];
1167    LONGX fmtasize=FMTASIZE;
1168
1169    char *vMFQTQRY0=NULL;
1170    char *vMFQTHITS=NULL;
1171/*nu     char *vMFQTAENV; */
1172    char *p;
1173
1174    char vbreak[2][3];
1175    int nbreak;
1176    char v2992[MAXCATLEN+1];
1177    LONGX mfn351;
1178
1179    LONGX setno=boolsetno;
1180
1181    int ndownf=parmdown;
1182    int ndownw=parmdown;
1183    int ncolors=5;
1184    int kdownf=ndownf/ncolors;
1185    int kdownw=ndownw/ncolors;
1186    float rangef,stepf;
1187    float rangew,stepw;
1188    LONGX freq1,freq2,freq;
1189    float peso1,peso2,peso;
1190    int fcolor=0;
1191    char x999[20];
1192    int wcolor=0;
1193    char x2991[20];
1194
1195    if (parmtrace) printf("+++trace: DB/namedbnp=%s\n",namedbnp);
1196
1197    vtimid[ntimes]="fmt1"; time(&vtime[ntimes++]); /* watch */
1198
1199    if (!booldbcrec) RECORD(booldbcrec=nrecs,namedbnp,0L);
1200    if (!boolridx) boolridx=nrecs;
1201
1202    RECORD(boolridx,namedbnp,setno);
1203
1204    vMFQTQRY0 = recfield(NULL,boolridx,MFQTQRY0,1,"");
1205    if (!boolqryp) boolqryp=vMFQTQRY0;
1206
1207    vMFQTHITS = recfield(NULL,boolridx,MFQTHITS,1,"");
1208
1209    /* get booldbn environment  */
1210/*nu     vMFQTAENV = recfield(NULL,boolridx,MFQTAENV,1,""); */
1211    /* p=vMFQTAENV; ... */
1212
1213    /* set master file */
1214    if (parmsortx == 'f') file1p=dbnoutF; /* alternate file is dbnoutW */
1215    if (parmsortx == 'w') file1p=dbnoutW;
1216    if (parmsortx == 'd') file1p=dbnoutD; /* alternate file is dbnoutW */
1217    dbx1p=dbxstorp(file1p);
1218
1219    /* init reading */
1220    if (!irec) irec=nrecs;
1221    RECORD(irec,file1p,0L);
1222    parmto=MF0nxtmfn-1; if (!ntabs) ntabs=parmto;
1223    count1=0;
1224    if (parmsortx == 'd') parmfrom=1;
1225    else {
1226        parmfrom=parmfromDB;
1227        if (parmcountDB) parmto=parmfromDB+parmcountDB-1;
1228        if (parmto > MF0nxtmfn-1) parmto=MF0nxtmfn-1;
1229        count2=parmto-parmfromDB+1;
1230    }
1231
1232    /* environment */
1233    batchp=envarea;
1234    if (cipfnamp   ) { sprintf(batchp,"a3000|%s|" , cipfnamp    ); batchp+=strlen(batchp); }
1235    if (decsdbnp   ) { sprintf(batchp,"a3001|%s|" , decsdbnp    ); batchp+=strlen(batchp); }
1236    if (amdldbnp   ) { sprintf(batchp,"a3002|%s|" , amdldbnp    ); batchp+=strlen(batchp); }
1237    if (atmdldbnp  ) { sprintf(batchp,"a3003|%s|" , atmdldbnp   ); batchp+=strlen(batchp); }
1238    if (tmp1dbnp   ) { sprintf(batchp,"a3004|%s|" , tmp1dbnp    ); batchp+=strlen(batchp); }
1239    if (pftfnamp   ) { sprintf(batchp,"a3005|%s|" , pftfnamp    ); batchp+=strlen(batchp); }
1240    if (langp      ) { sprintf(batchp,"a3006|%s|" , langp       ); batchp+=strlen(batchp); }
1241    if (parmloopTB ) { sprintf(batchp,"a3007|%"_LD_"|", parmloopTB  ); batchp+=strlen(batchp); }
1242    if (parmfromDB ) { sprintf(batchp,"a3008|%"_LD_"|", parmfromDB  ); batchp+=strlen(batchp); }
1243    if (parmcountDB) { sprintf(batchp,"a3009|%"_LD_"|", parmcountDB ); batchp+=strlen(batchp); }
1244    if (parmsortp  ) { sprintf(batchp,"a3010|%s|" , parmsortp   ); batchp+=strlen(batchp); }
1245    if (boolqryp   ) { sprintf(batchp,"a3011|%s|" , boolqryp    ); batchp+=strlen(batchp); }
1246    if (namedbnp   ) { sprintf(batchp,"a3012|%s|" , namedbnp    ); batchp+=strlen(batchp); }
1247    if (parmatmdl99) { sprintf(batchp,"a3013|%d|" , parmatmdl99 ); batchp+=strlen(batchp); }
1248    if (actionp    ) { sprintf(batchp,"a3014|%s|" , actionp     ); batchp+=strlen(batchp); }
1249/**/
1250                       sprintf(batchp,"a3015|%"_LD_"|", setno       ); batchp+=strlen(batchp);
1251                       sprintf(batchp,"a4001|%d|" , ntabs       ); batchp+=strlen(batchp);
1252/**/
1253
1254
1255/* -----------------------------------------------------------------------------
1256v4001 = ntabs
1257
1258v3210[1] = 'A'
1259v3211[1] = Aboolqryp
1260v3212 = hits
1261v3213[1] = Aboolqrypdecs
1262
1263p/ v1001='1'
1264  v3214[] = time id
1265  v3215[] = seconds
1266  v3216   = elapsed "%02d:%02d:%02d",hours,mins,secs
1267
1268decs data fields
1269  v3203 = v3
1270*/
1271
1272    if (vMFQTQRY0) {
1273        int v351;
1274        RECSTRU *recp;
1275        sprintf(batchp,"a3210|%s|" , "A"             ); batchp+=strlen(batchp);
1276        sprintf(batchp,"a3211|%s|" , vMFQTQRY0       ); batchp+=strlen(batchp);
1277        sprintf(batchp,"a3212|%"_LD_"|", atol(vMFQTHITS) ); batchp+=strlen(batchp);
1278        sprintf(batchp,"a3213|"                      ); batchp+=strlen(batchp);
1279        for (p=vMFQTQRY0; *p; ) {
1280            for (v351=0; isdigit(*p); p++) v351=v351*10+((int)(*p)-(int)'0');
1281            if (v351) {
1282                if (!drec) drec=nrecs;
1283                RECORD(drec,decsdbnp,v351);
1284                recfield(batchp,drec,DECSTAGP,1,"");    batchp+=strlen(batchp);
1285            }
1286            else { *batchp++ = *p; if (*p) p++; }
1287        }
1288        sprintf(batchp,"|"                           ); /*nu batchp+=strlen(batchp); */
1289    }
1290    /* end of envarea */
1291
1292    /* init summary */
1293    memset(vbreak,0x00,sizeof(vbreak));
1294
1295    /* do it */
1296    for (mfn1=parmfrom/*DB*/; mfn1 <= parmto; mfn1++) {
1297
1298        /* compile strip CR if CRLF + display format */
1299        if (!tabfmtp) {
1300            /* use fmtarea for actual format specification */
1301            sprintf(fmtspec,"@%s",pftfnamp);
1302            if (!loadfile(NULL,'@',fmtspec,fmtarea,fmtasize,'\0')) {
1303                printf("Content-type: text/plain\n\n");
1304                printf("format error: file %s not found \n",pftfnamp);
1305                exit(12);
1306            }
1307            if (fmt_gener(&tabfmtp,fmtarea)) {
1308                printf("Content-type: text/plain\n\n");
1309                printf("format error: file %s error#%d offset %"_LD_" [%.512s%s]\n",
1310                        pftfnamp,fmt_error,fmt_errof,fmtarea+fmt_errof,"...");
1311                exit(12);
1312            }
1313        }
1314
1315        /* get color limits */
1316        if (parmdown) if ((count1+1) == 1) {
1317            RECORD(irec,dbnoutF,1L);
1318            freq1=atol(recfield(x999,irec,999,1,""));
1319            RECORD(irec,dbnoutF,0L);
1320            freq2=freq1;
1321            if (MF0nxtmfn-1 > 1) {
1322                RECORD(irec,dbnoutF,MF0nxtmfn-1);
1323                freq2=atol(recfield(x999,irec,999,1,""));
1324            }
1325            rangef=freq1-freq2; if (rangef < 0) rangef = -rangef; /* ok */
1326            stepf=(rangef+1)/(float)ncolors;
1327            if (stepf <= 0) { stepf=1; kdownf=1; ndownf=0; }
1328
1329            RECORD(irec,dbnoutW,1L);
1330            peso1=atof(recfield(x2991,irec,2991,1,""));
1331            RECORD(irec,dbnoutW,0L);
1332            peso2=peso1;
1333            if (MF0nxtmfn-1 > 1) {
1334                RECORD(irec,dbnoutW,MF0nxtmfn-1);
1335                peso2=atof(recfield(x2991,irec,2991,1,""));
1336            }
1337            rangew=peso1-peso2; if (rangew < 0) rangew = -rangew; /* ok */
1338            stepw=(rangew+1)/(float)ncolors;
1339            if (stepw <= 0) { stepw=1; kdownw=1; ndownw=0; }
1340        }
1341
1342        /* get record */
1343        RECORD(irec,file1p,mfn1);
1344        if (RECrc != RCNORMAL) fatal("aotmsa2/DB/RCNORMAL");
1345        count1++;
1346        if (parmtrace) printf("+++ mfnDB=%"_LD_"\n",mfn1);
1347
1348        /* process parmsort
1349        */
1350        batchp=fmtarea;
1351        if (file1p == dbnoutW /* parmsortx=='w' */) {
1352/*
1353            LONGX rankf=atol(recfield(fmtarea,irec,2220,1,""));
1354            LONGX rankd=atol(recfield(fmtarea,irec,2220,2,""));
1355            sprintf(batchp,"D2220A2220/%"_LD_"/A2220/%"_LD_"/A2220/%"_LD_"/",rankf,MFRmfn,rankd); batchp+=strlen(batchp);
1356*/
1357        }
1358        else {
1359/*
1360            LONGX rank1=atol(recfield(fmtarea,irec,2220,1,""));
1361*/
1362            LONGX rankw=atol(recfield(fmtarea,irec,2220,2,""));
1363            char *v1f=recfield(fmtarea,irec,1,1,"");
1364            char *v1w=fmtarea+strlen(fmtarea)+1;
1365            RECORD(irec,dbnoutW,rankw); RECdbxp=dbx1p;
1366            recfield(v1w,irec,1,1,"");
1367            if (!*v1f || !*v1w || strcmp(v1f,v1w)) fatal("aotmsa2/DB/join");
1368/*
1369            sprintf(batchp,"D2220A2220/%"_LD_"/A2220/%"_LD_"/",mfn1,MFRmfn); batchp+=strlen(batchp);
1370*/
1371        }
1372
1373        /* process summary */
1374        memset(v2992,0x00,sizeof(v2992));
1375        nbreak=0;
1376        p=recfield(v2992,irec,2992,1,""); /* 1st mesh C/D */
1377        if (memcmp(vbreak[0],p+0,3)) {
1378            memcpy(vbreak[0],p+0,3); nbreak+=1; *vbreak[1]='\0';
1379        }
1380        if (memcmp(vbreak[1],p+4,3)) {
1381            memcpy(vbreak[1],p+4,3); nbreak+=2;
1382        }
1383
1384        if (nbreak) {
1385
1386            if (nbreak & 0x01) {
1387                sprintf(batchp,"A3994/%d/"  ,nbreak&0x01);  batchp+=strlen(batchp);
1388                sprintf(batchp,"A3995/%.3s/",v2992      );  batchp+=strlen(batchp);
1389                if (nbreak & 0x02) {
1390                sprintf(batchp,"A3995/%.7s/",v2992      );  batchp+=strlen(batchp);
1391                }
1392                nbreak=1;
1393            }
1394            else {
1395                nbreak=2;
1396                sprintf(batchp,"A3994/%d/",nbreak       ); batchp+=strlen(batchp);
1397                sprintf(batchp,"A3995//"                ); batchp+=strlen(batchp);
1398                sprintf(batchp,"A3995/%.7s/",v2992      ); batchp+=strlen(batchp);
1399            }
1400   
1401        } /* end if (nbreak) */
1402
1403        /* skip records if parmshowzero
1404        */
1405        if (parmshowzero)
1406            if (!nbreak)
1407                if (count1 > 1)
1408                    if (count1 < count2)
1409                        continue;
1410
1411        /* add CGI and +hits data fields
1412        */
1413        sprintf(batchp,"A1001/%"_LD_"/A1002/%"_LD_"/",count1,count2); batchp+=strlen(batchp);
1414
1415        /* add decs data fields
1416        */
1417        mfn351=atol(recfield(batchp,irec,1,1,"")); /* the condition */
1418        sprintf(batchp,"a3203|"                      ); batchp+=strlen(batchp);
1419        if (!drec) drec=nrecs;
1420        RECORD(drec,"mydecs",mfn351);
1421        recfield(batchp,drec,DECSTAGP,1,"");            batchp+=strlen(batchp);
1422        sprintf(batchp,"|"                           ); batchp+=strlen(batchp);
1423
1424        /* add watch */
1425        if (count1 == 1) {
1426            int hours,mins,secs;
1427            int i;
1428            vtimid[ntimes]="fmt2"; time(&vtime[ntimes++]); /* watch */
1429            secs=vtime[ntimes-1]-vtime[0];
1430            hours=secs/3600; secs-=hours*3600;
1431            mins=secs/60; secs-=mins*60;
1432            sprintf(batchp,"a3216|%02d:%02d:%02d|",hours,mins,secs); batchp+=strlen(batchp);
1433            for (i=0; i<ntimes-1; i++) {
1434                sprintf(batchp,"a3214|%s|",  vtimid[i]);             batchp+=strlen(batchp);
1435                sprintf(batchp,"a3215|%"_LD_"|", vtime[i+1]-vtime[i]);   batchp+=strlen(batchp);
1436            }
1437        }
1438
1439        /* get color */
1440        if (parmdown) {
1441            freq=atol(recfield(x999,irec,999,1,""));
1442            fcolor=(int)(0xFF-ndownf+(freq/stepf)*kdownf);
1443            peso=atof(recfield(x2991,irec,2991,1,""));
1444            wcolor=(int)(0xFF-ndownw+(peso/stepw)*kdownw);
1445            sprintf(batchp,"a1515/%02x/",fcolor);   batchp+=strlen(batchp);
1446            sprintf(batchp,"a1515/%02x/",wcolor);   batchp+=strlen(batchp);
1447        }
1448
1449
1450        /* add/del fields */
1451        if (fldupdat(irec,fmtarea)) fatal("aotmsa2/DB/fldupdat/fmt");
1452        if (fldupdat(irec,envarea)) fatal("aotmsa2/DB/fldupdat/env");
1453
1454        /* apply display format */
1455        if (fmt_inter(tabfmtp,irec,fmtasize,fmtarea,fmtasize) < 0) {
1456            printf("Content-type: text/plain\n\n");
1457            printf("error: %s [format execution error %d]\n",pftfnamp,fmt_error);
1458            exit(21);
1459        }
1460        /* close fmt_ every each MAXTABFMTS calls */
1461        if (++ntabfmts == 1000 /*MAXTABFMTS*/) {
1462            fmt_free(tabfmtp); tabfmtp=(FMT_CODE *)NULL;
1463            ntabfmts=0;
1464        }
1465
1466        /* output format results
1467        */
1468        puts(fmtarea); /* for (left=strlen(fmtarea), p=fmtarea; left; ) .s{ int len=BUFSIZ/2; char c;
1469                            if (len > left) len=left; c=p[len]; p[len]='\0'; puts(p); p[len]=c;
1470                            p+=len; left-=len; } */
1471
1472        if (parmtell) if ((count1 % parmtell) == 0)
1473            fprintf(stderr,"+++ %"_LD_"/%"_LD_" \n",count1,count2);
1474        if (parmtrace)
1475            fprintf(stderr,"+++ %"_LD_"/%"_LD_" \n",count1,count2);
1476
1477    }
1478
1479    vtimid[ntimes]="end2"; time(&vtime[ntimes++]); /* watch */
1480
1481} /* actionDB */
1482
1483
1484/* =======================         =============          ================== */
1485/* =======================         =============          ================== */
1486if (actionDD) {
1487
1488    int errno1=0;
1489    int errno2=0;
1490    char *p1=NULL;
1491    char *p2=NULL;
1492    LONGX decsnxtmfn;
1493    char *decsdbp=decsdbnp;
1494
1495    /* Search DECS
1496    */
1497    boolsetno=0;
1498    boolhits=0;
1499
1500    /* init reading */
1501    if (!drec) drec=nrecs;
1502    RECORD(drec,decsdbnp,0L);
1503    decsnxtmfn=MF0nxtmfn;
1504   
1505    /* will call format even on error and/or expression missing */
1506    count2=1;
1507
1508    /* display MeSH Diseases (cat C$)
1509    */
1510    if (actionDD == 2) if (!boolqryp) {
1511        boolqryp="CAT1=C$";
1512        decsdbp="mydecs";
1513    }
1514   
1515    /*
1516        Search "bool=" parameter
1517    */
1518    if (boolqryp) { /* boolqryp */
1519
1520        LONGX mfn;
1521
1522        LONGX asize=strlen(decsdbp) +                  /* field MFQTDBN0=11 (may be longer than 128+4+1) */
1523                   strlen(boolqryp) +                 /* the expression */
1524                   2*strlen(boolqryp) +               /* the terms + pseudo operators _1termX+11X */
1525                   BUFSIZ+strlen(amdldbnp) +          /* field MFQSWDBN=20 + a diferent db */
1526                   24*(strlen(B7DELADD)+3*B7UPLEN) +  /* 2 duzias de control fields */  /* DxxAxx|xxx| */ 
1527                   strlen(boolqryp)+4 +               /* tmpfile .%03x */
1528                   BUFSIZ;                            /* por si las moscas */
1529                   
1530        char *buffup=loadfile(NULL,'@',"",NULL,asize,'\0');
1531
1532        if (!cib7p) cib7p=b7_cib7(cib7p,ciapip);
1533
1534        /* initialize ridx and b7_xxx() parameters and run b7_run()
1535        */
1536        for (boolridx=nrecs, mfn=1; ; mfn++) { /* get actual maxmfn */
1537            RECORD(boolridx,decsdbp,mfn);
1538            if (RECrc == RCEOF) fatal(decsdbp);
1539            if (RECrc == RCNORMAL) break;
1540        }
1541        RECdbxp=NULL;                /* nao usa base de log */
1542        MFRmfn=0L;
1543
1544        /* run b7_exp() / b7_run() / b7_hit(0)
1545        */
1546        p1=b7_exp(cib7p,boolridx,decsdbp,boolqryp,buffup,NULL,0L,&errno1);
1547        if (p1 || errno1) ; /* printf("Expression syntax error %d: '%s'\n",errno1,p1); */
1548        else {
1549            LONGX bufsiz;
1550            char *hitfnamp="null";
1551            if (booltmpnam[0]) hitfnamp=booltmpnam;
1552            sprintf(buffup,"D%dA%d|%s|",MFQTHMEM,MFQTHMEM,hitfnamp);
1553            if (fldupdat(boolridx,buffup) != NULL) fatal("aotmsa2/DD/fldupdat/boolridx");
1554
1555            /* b7_run faz "trirecp=vrep[tlirec]" */
1556            if (!booltlir) record(booltlir=nrecs,"null",1L);
1557
1558            /* alloc buffer for 20000 hits = 80Kbytes */
1559            bufsiz=20000*sizeof(LONGX);
1560            if (b7bufferp) b7_hbfree(cib7p,&b7bufferp);
1561            b7_hballoc(cib7p,bufsiz,&b7bufferp);
1562
1563            /* run search */
1564            p2=b7_run(cib7p,boolridx,decsdbp,buffup,sizeof(buffup),
1565                booltell,isisuctab,""/*btch0p*/,booltlir,0L,&errno2);
1566            if (p2 || errno2) ; /* printf("Execution error %d: '%s'\n",errno2,p2); */
1567            else {
1568                boolsetno=b7setno;  /* =1 ??? */
1569                boolhits=b7bufferp->ndocs; /* b7_hit(cib7p,boolridx,0L,b7setno); */
1570                if (booltell) printf("Hits=%"_LD_"\n",boolhits);
1571            }
1572        }
1573        if (p2 || errno2) fatal("Expression execution error");
1574
1575    } /* boolqryp */
1576
1577    /* set number of times format is called */
1578    if (boolhits) count2=boolhits;
1579
1580    if (p1 || errno1 /* || p2 || errno2*/) { ; }
1581
1582    if (1) { /* errno */
1583//#define FMTASIZE 32000
1584        FMT_CODE *tabfmtp=NULL;           /* formato para tab= */
1585        char fmtspec[BUFSIZ];
1586        char *batchp;
1587        char fmtarea[FMTASIZE+1];
1588        LONGX fmtasize=FMTASIZE;
1589
1590        count1=0;
1591
1592        /* environment */
1593        batchp=envarea;
1594        if (cipfnamp   ) { sprintf(batchp,"a3000|%s|" , cipfnamp    ); batchp+=strlen(batchp); }
1595        if (decsdbnp   ) { sprintf(batchp,"a3001|%s|" , decsdbnp    ); batchp+=strlen(batchp); }
1596        if (amdldbnp   ) { sprintf(batchp,"a3002|%s|" , amdldbnp    ); batchp+=strlen(batchp); }
1597        if (atmdldbnp  ) { sprintf(batchp,"a3003|%s|" , atmdldbnp   ); batchp+=strlen(batchp); }
1598        if (tmp1dbnp   ) { sprintf(batchp,"a3004|%s|" , tmp1dbnp    ); batchp+=strlen(batchp); }
1599        if (pftfnamp   ) { sprintf(batchp,"a3005|%s|" , pftfnamp    ); batchp+=strlen(batchp); }
1600        if (langp      ) { sprintf(batchp,"a3006|%s|" , langp       ); batchp+=strlen(batchp); }
1601        if (parmloopTB ) { sprintf(batchp,"a3007|%"_LD_"|", parmloopTB  ); batchp+=strlen(batchp); }
1602        if (parmfromDB ) { sprintf(batchp,"a3008|%"_LD_"|", parmfromDB  ); batchp+=strlen(batchp); }
1603        if (parmcountDB) { sprintf(batchp,"a3009|%"_LD_"|", parmcountDB ); batchp+=strlen(batchp); }
1604        if (parmsortp  ) { sprintf(batchp,"a3010|%s|" , parmsortp   ); batchp+=strlen(batchp); }
1605//        if (boolqryp   ) { sprintf(batchp,"a3011|%s|" , boolqryp    ); batchp+=strlen(batchp); }
1606        if (namedbnp   ) { sprintf(batchp,"a3012|%s|" , namedbnp    ); batchp+=strlen(batchp); }
1607        if (parmatmdl99) { sprintf(batchp,"a3013|%d|" , parmatmdl99 ); batchp+=strlen(batchp); }
1608        if (actionp    ) { sprintf(batchp,"a3014|%s|" , actionp     ); batchp+=strlen(batchp); }
1609/**/
1610//                           sprintf(batchp,"a3015|%"_LD_"|", setno       ); batchp+=strlen(batchp);
1611//                           sprintf(batchp,"a4001|%d|" , ntabs       ); batchp+=strlen(batchp);
1612/**/
1613        /* end of envarea */
1614
1615        /* compile strip CR if CRLF + display format */
1616        pftfnamp="aotmsa2D.pft";
1617        sprintf(fmtspec,"%s,@%s","if size(s(#))=2 then newline(s(#)*1) fi",pftfnamp);
1618        if (fmt_gener(&tabfmtp,fmtspec)) {
1619            printf("Content-type: text/plain\n\n");
1620            printf("error: %s [format error %d:%s]\n",pftfnamp,fmt_error,fmtspec+fmt_errof);
1621            exit(12);
1622        }
1623
1624
1625        /*
1626            loop decs
1627        */
1628
1629        for (boolh=1; ; boolh++) {
1630
1631            LONGX mfn;
1632
1633            /* hit processing */
1634            if (boolhits) {
1635
1636                if (boolh > boolhits) break;
1637               
1638                if (boolh == 1) {
1639                    hitlistp=(B7HITLIST *)b7bufferp->area;
1640                    mfnlistp=hitlistp->mfnlist;
1641                }
1642                if (b7bufferp->hcase == BITSTRING)
1643                    mfn=b7_hit(cib7p,boolridx,boolh,b7setno);
1644                else
1645                    mfn = *mfnlistp; mfnlistp++;
1646
1647                if (mfn <= 0) fatal("aotmsa2/DD/decsdbnp/hit");
1648   
1649                if (parmtrace) printf("+++ hit#%"_LD_" mfn=%"_LD_"\n",boolh,mfn);
1650   
1651                RECORD(drec,decsdbnp,mfn);
1652                if (RECrc != RCNORMAL) fatal("aotmsa2/DD/decsdbnp/RCNORMAL");
1653
1654            }
1655            else {
1656                RECORD(drec,decsdbnp,mfn=decsnxtmfn);
1657                RECrc=RCNORMAL; MFRstatus=ACTIVE;
1658//                sprintf(fmtarea,"a%"_LD_"|x|",(LONGX)DECSTAGP);
1659//                if (fldupdat(drec,fmtarea)) fatal("aotmsa2/DD/fldupdat/x");
1660            }
1661
1662            count1++;
1663            if (parmtrace) printf("+++ mfnDD=%"_LD_"\n",mfn);
1664   
1665            /* process record
1666            */
1667            batchp=fmtarea;
1668   
1669            /* add CGI and +hits data fields
1670            */
1671            sprintf(batchp,"A1001/%"_LD_"/A1002/%"_LD_"/",count1,count2); batchp+=strlen(batchp);
1672   
1673            /* add decs data fields
1674            */
1675            sprintf(batchp,"a3203|"                      ); batchp+=strlen(batchp);
1676            recfield(batchp,drec,DECSTAGP,1,"");            batchp+=strlen(batchp);
1677            sprintf(batchp,"|"                           ); batchp+=strlen(batchp);
1678
1679            if (fldupdat(drec,fmtarea)) fatal("aotmsa2/DD/fldupdat/fmt");
1680            if (fldupdat(drec,envarea)) fatal("aotmsa2/DD/fldupdat/env");
1681
1682            if (fmt_inter(tabfmtp,drec,fmtasize,fmtarea,fmtasize) < 0) {
1683                printf("Content-type: text/plain\n\n");
1684                printf("error: %s [format execution error %d]\n",pftfnamp,fmt_error);
1685                exit(21);
1686            }
1687
1688            /* output format results
1689            */
1690            puts(fmtarea);
1691           
1692            if (!boolhits) break;
1693
1694        } /* end for (boolh=1; ;  ) */
1695
1696    } /* errno */
1697
1698} /* end actionDD */
1699
1700/* =======================         =============          ================== */
1701/* =======================         =============          ================== */
1702
1703    /* watch */
1704    time(&vtime[ntimes++]);
1705    if (parmtime) {
1706        struct tm *tp;
1707        char fmt_time[21+1]; /* aaaammdd hhmmss WDAY YDAY */
1708                             /* 1234567890123456 7  8 901 */
1709        int hours,mins,secs;
1710        LONGX time_start=vtime[0];
1711        LONGX time_elapsed;
1712        vtimid[ntimes]="exit"; time(&vtime[ntimes++]); /* watch */
1713        time_elapsed=vtime[ntimes-1];
1714        tp=localtime(&time_elapsed);
1715        sprintf(fmt_time,"%02d/%02d/%02d %02d:%02d:%02d",
1716                           tp->tm_mday,tp->tm_mon+1,tp->tm_year%100,
1717                           tp->tm_hour,tp->tm_min,tp->tm_sec);
1718        fprintf(stderr,"+++ localtime %s \n",fmt_time);
1719        secs=time_elapsed - time_start;
1720        hours=secs/3600; secs-=hours*3600;
1721        mins=secs/60; secs-=mins*60;
1722        sprintf(fmt_time,"%02d:%02d:%02d",hours,mins,secs);
1723        fprintf(stderr,"+++ elapsed %s \n",fmt_time);
1724    }
1725
1726    /* exit
1727    */
1728    if (cib7p) cib7p=b7_cib7_delete(cib7p);
1729#if CIAPI
1730    cisisApplicationDelete(ciapip);
1731    ciapip=NULL;
1732#endif /* CIAPI */
1733
1734    exit(0);
1735}
1736
1737
1738/* =======================         =============          ================== */
1739/* =======================         =============          ================== */
1740
1741#if ANSI
1742int rutfreqF(LONGX *tabcntA, int ntabs, LONGX drec, LONGX *tabcntArankF, TABFREQF_ENTRY **tabfreqFp)
1743#else
1744int rutfreqF(tabcntA, ntabs, dbnoutp, drec, tabcntArankF, tabfreqFp)
1745LONGX *tabcntA;
1746int ntabs;
1747LONGX drec;
1748LONGX *tabcntArankF;
1749TABFREQF_ENTRY **tabfreqFp;
1750#endif
1751{
1752    LONGX mfn;
1753    char buffup[BUFSIZ];
1754    int v351;
1755
1756    LONGX nbytes;
1757    char *p;
1758
1759    TABFREQF_ENTRY *tabfreqF,*tabF;
1760
1761typedef struct outfreqF_sort_entry {
1762    char x999[10];
1763    char categ[39];
1764    char null[1];
1765    char align[2];
1766    LONGX v351;
1767    LONGX freq;
1768} OUTFREQF_SORT_ENTRY;
1769
1770    OUTFREQF_SORT_ENTRY *sort_tab,*sort_tmp,*sortp,*ip,*jp;
1771    int catlen;
1772    int i,j,k;
1773
1774    int keylen=sizeof(sortp->x999)+sizeof(sortp->categ);
1775
1776
1777    /* init tabcntArankF (indexed by DecsMfn)
1778    */
1779    memset(tabcntArankF,0,sizeof(LONGX)*CLASSES);
1780
1781    *tabfreqFp=NULL;
1782    if (!ntabs) return(0);
1783
1784    /* alloc tabfreqF (indexed by rankF)
1785    */
1786    nbytes=sizeof(TABFREQF_ENTRY)*ntabs;
1787    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqF/tabfreqF/ALLOMAXV");
1788    p=(char *)ALLOC((ALLOPARM)(nbytes));
1789    if (p == ALLONULL) fatal("aotmsa2/rutfreqF/tabfreqF/ALLOC");
1790    memset(p,0,nbytes); /* init */
1791    tabfreqF=(TABFREQF_ENTRY *)p;
1792    *tabfreqFp=tabfreqF;
1793
1794    nbytes=sizeof(OUTFREQF_SORT_ENTRY)*ntabs+sizeof(OUTFREQF_SORT_ENTRY);
1795    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqF/sort_tab/ALLOMAXV");
1796    p=(char *)ALLOC((ALLOPARM)(nbytes));
1797    if (p == ALLONULL) fatal("aotmsa2/rutfreqF/sort_tab/ALLOC");
1798    sort_tab=(OUTFREQF_SORT_ENTRY *)p;
1799    sort_tmp=sort_tab+ntabs;
1800
1801    for (mfn=0L, v351=1; mfn<ntabs; v351++) {
1802        if (!tabcntA[v351]) continue;
1803        sortp=sort_tab+mfn;
1804        sprintf(sortp->x999,"%10"_LD_,999999999L-tabcntA[v351]);
1805        if (drec) { /* use decs/v20 as 2nd sort key for sortF */
1806            record(drec,ddecsdbnp,(LONGX)v351);
1807            recfield(buffup,drec,TAG020,1,""); if (!*buffup) fatal("aotmsa2/rutfreqF/decs/TAG020");
1808            catlen=strlen(buffup); if (catlen>sizeof(sortp->categ)) buffup[catlen=sizeof(sortp->categ)]='\0';
1809            memset(buffup+catlen,(int)' ',sizeof(sortp->categ)-catlen);
1810            memcpy(sortp->categ,buffup,sizeof(sortp->categ));
1811        } else memset(sortp->categ,(int)' ',sizeof(sortp->categ));
1812        sortp->null[0]='\0';
1813        sortp->v351=v351;
1814        sortp->freq=tabcntA[v351];
1815        mfn++;
1816    }
1817
1818    /* sort F
1819    */
1820    for (k=ntabs-1, i=0; i<k; i++) {
1821        ip=sort_tab+i;
1822        for (j=i+1; j<ntabs; j++) {
1823            jp=sort_tab+j;
1824            if (memcmp((void *)ip,(void *)jp,keylen) > 0) {
1825                memcpy((void *)sort_tmp,(void *)ip,      sizeof(OUTFREQF_SORT_ENTRY));
1826                memcpy((void *)ip      ,(void *)jp,      sizeof(OUTFREQF_SORT_ENTRY));
1827                memcpy((void *)jp      ,(void *)sort_tmp,sizeof(OUTFREQF_SORT_ENTRY));
1828            }
1829        }
1830    }
1831
1832    /* store tabcntArankF (indexed by DecsMfn) and tabfreqF (indexed by rankF)
1833    */
1834    for (sortp=sort_tab, tabF=tabfreqF, mfn=1L; mfn<=ntabs; mfn++, sortp++, tabF++) {
1835        tabF->v351=sortp->v351;
1836        tabF->freq=sortp->freq;
1837        tabcntArankF[sortp->v351]=mfn;
1838    }
1839
1840    return(0);
1841}
1842
1843
1844#if ANSI
1845int outfreqF(int ntabs, char *dbnoutp, LONGX *tabcntArankW, LONGX *tabcntArankD, TABFREQF_ENTRY *tabfreqF)
1846#else
1847int outfreqF(ntabs, dbnoutp, tabcntArankW, tabcntArankD, tabfreqF)
1848int ntabs;
1849char *dbnoutp;
1850LONGX *tabcntArankW;
1851LONGX *tabcntArankD;
1852TABFREQF_ENTRY *tabfreqF;
1853#endif
1854{
1855    RECSTRU *recp;
1856    LONGX mfn;
1857    char buffup[BUFSIZ],*batchp;
1858    LONGX upirec;
1859    LONGX upcrec;
1860    TABFREQF_ENTRY *tabF;
1861
1862    if (!ntabs) return(0);
1863
1864    /* output tabfreqF (indexed by rankF) and tabcntArankW (indexed by DecsMfn)
1865    */
1866    record(upcrec=nrecs,dbnoutp,0L);
1867    record(upirec=nrecs,dbnoutp,1L);
1868    for (tabF=tabfreqF, mfn=1L; mfn<=ntabs; mfn++, tabF++) {
1869        batchp=buffup;
1870        sprintf(batchp,"A1/%06"_LD_"/A999/%"_LD_"/",tabF->v351,tabF->freq); batchp+=strlen(batchp);
1871        sprintf(batchp,"A2220/%"_LD_"/"    ,mfn                     ); batchp+=strlen(batchp);
1872        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankW[tabF->v351]); batchp+=strlen(batchp);
1873        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankD[tabF->v351]); batchp+=strlen(batchp);
1874        *batchp='\0';
1875        RECORD(upirec,dbnoutp,mfn); MFRstatus=ACTIVE;
1876        if (fldupdat(upirec,buffup)) return(mfn);
1877        recupdat(upcrec,upirec);
1878    }
1879
1880    return(0);
1881}
1882
1883
1884
1885#if ANSI
1886int rutfreqW(TABFREQF_ENTRY *tabfreqF, int ntabs, char *amdlname, LONGX docsTOTxA, LONGX docsTOTamdl, LONGX *tabcntArankF, LONGX *tabcntArankW, TABFREQW_ENTRY **tabfreqWp, LONGX *tabcntMDL, LONGX *gtabcntA)
1887#else
1888int rutfreqW(tabfreqF, ntabs, amdlname, docsTOTxA, docsTOTamdl, tabcntArankF, tabcntArankW, tabfreqWp, tabcntMDL, gtabcntA)
1889TABFREQF_ENTRY *tabfreqF;
1890int ntabs;
1891char *amdlname;
1892LONGX docsTOTxA;    /* v9991[1] = docs de xA - nao vazios */
1893LONGX docsTOTamdl;  /* v9991[2] = docs de amdl */
1894LONGX *tabcntArankF;
1895LONGX *tabcntArankW;
1896TABFREQW_ENTRY **tabfreqWp;
1897LONGX *tabcntMDL;
1898LONGX *gtabcntA;
1899#endif
1900{
1901    LONGX mfn;
1902    int v351;
1903
1904    LONGX nbytes;
1905    char *p;
1906
1907    TABFREQW_ENTRY *tabfreqW,*tabW;
1908    TABFREQF_ENTRY *tabF;
1909
1910typedef struct outfreqW_sort_entry {
1911    char x2991[10];
1912    char xrankF[6];
1913    char null[1];
1914    char align[3];
1915    LONGX v351;
1916    LONGX docsTTxA;         /*  v999[1] = docs de TT em xA */
1917    LONGX docsTTamdl;       /*  v999[2] = docs de TT em amdl = postings de TT em amdl */
1918    float frelTTxA;        /* v1991[1] = frelTTxA = docs de TT em xA / docs de xA */
1919    float frelTTamdl;      /* v1991[2] = frelTTamdl = docs de TT em amdl / docs de amdl */
1920    float pesoTTxA;        /* v2991[1] = frelTTxA / frelTTamdl */
1921//    char pesoTTxAout[4]; /* v2221[1] = 'out' se peso < 1 */
1922} OUTFREQW_SORT_ENTRY;
1923
1924    OUTFREQW_SORT_ENTRY *sort_tab,*sort_tmp,*sortp,*ip,*jp;
1925    int i,j,k;
1926
1927    TRMSTRU *trmp;
1928    LONGX itrm;
1929    char x351[6+1];
1930
1931    int keylen=sizeof(sortp->x2991)+sizeof(sortp->xrankF);
1932
1933#if XPROCIN
1934proc= /* v999[1] = docs de TT em xA */
1935proc='a999|',f(npost(['c:\2001x300\usersaot\amdl351']v1),1,0),'|'/* docs de TT em amdl = postings de TT em amdl */
1936proc='a9991|',ref([getenv('T999999')]1,v999),'|',   /* docs de xA - nao vazios */
1937proc='a9991|',ref(['c:\2001x300\usersaot\atmdl']l(['c:\2001x300\usersaot\atmdl']'999999'),v999),'|'  /* docs de amdl */
1938proc='a1991|',if val(v9991[1])> 0 then f(val(v999[1])/val(v9991[1]),10,8) else f(0,10,8) fi,'|' /* frelTTxA = docs de TT em xA / docs de xA */
1939proc='a1991|',if val(v9991[2])> 0 then f(val(v999[2])/val(v9991[2]),10,8) else f(0,10,8) fi,'|' /* frelTTamdl = docs de TT em amdl / docs de amdl */
1940proc='a2991|',if val(v1991[2])> 0 then f(val(v1991[1])/val(v1991[2]),5,3) else f(0,5,3) fi,'|'  /* frelTTxA / frelTTamdl */
1941proc=/* if v1991[1]<v1991[2] then 'a2221|out|' fi */
1942#endif
1943
1944    /* init tabcntArankW (indexed by DecsMfn)
1945    */
1946    memset(tabcntArankW,0,sizeof(LONGX)*CLASSES);
1947
1948    *tabfreqWp=NULL;
1949    if (!ntabs) return(0);
1950
1951    /* alloc tabfreqW (indexed by rankW)
1952    */
1953    nbytes=sizeof(TABFREQW_ENTRY)*ntabs;
1954    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqW/tabfreqW/ALLOMAXV");
1955    p=(char *)ALLOC((ALLOPARM)(nbytes));
1956    if (p == ALLONULL) fatal("aotmsa2/rutfreqW/tabfreqW/ALLOC");
1957    memset(p,0,nbytes); /* init */
1958    tabfreqW=(TABFREQW_ENTRY *)p;
1959    *tabfreqWp=tabfreqW;
1960
1961    nbytes=sizeof(OUTFREQW_SORT_ENTRY)*ntabs+sizeof(OUTFREQW_SORT_ENTRY);
1962    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqW/sort_tab/ALLOMAXV");
1963    p=(char *)ALLOC((ALLOPARM)(nbytes));
1964    if (p == ALLONULL) fatal("aotmsa2/rutfreqW/sort_tab/ALLOC");
1965    sort_tab=(OUTFREQW_SORT_ENTRY *)p;
1966    sort_tmp=sort_tab+ntabs;
1967
1968
1969    if (!tabcntMDL) TRMALLOC((itrm=1L),0L); /* do not load .iyp */
1970
1971    for (sortp=sort_tab, tabF=tabfreqF, mfn=1L; mfn<=ntabs; mfn++, tabF++, sortp++) {
1972        v351=tabF->v351;
1973        /* */
1974        sortp->docsTTxA   = tabF->freq;     /* v999[1] = docs de TT em xA */
1975        if (tabcntMDL)
1976            sortp->docsTTamdl = tabcntMDL[v351];   /*  v999[2] = docs de TT em amdl = postings de TT em amdl */
1977        else {
1978            sprintf(x351,"%06"_LD_,v351);
1979            TERM(itrm,amdlname,x351); if (TRMrc != RCNORMAL) fatal("aotmsa2/rutfreqW/TERM/amdl");
1980            sortp->docsTTamdl = TRMxytotp;         /*  v999[2] = docs de TT em amdl = postings de TT em amdl */
1981        }
1982        sortp->frelTTxA   = (docsTOTxA   > 0) ? sortp->docsTTxA   / (float)docsTOTxA   : 0;   /* v1991[1] = frelTTxA = docs de TT em xA / docs de xA */
1983        sortp->frelTTamdl = (docsTOTamdl > 0) ? sortp->docsTTamdl / (float)docsTOTamdl : 0;   /* v1991[2] = frelTTamdl = docs de TT em amdl / docs de amdl */
1984        sortp->pesoTTxA   = (sortp->frelTTamdl > 0)  ? sortp->frelTTxA   / sortp->frelTTamdl  : 0;   /* v2991[1] = frelTTxA / frelTTamdl */
1985        //memcpy(sortp->pesoTTxAout,(frelTTxA < frelTTamdl)?"out":"  ",sizeof(sortp->pesoTTxA)); /* if v1991[1]<v1991[2] then 'a2221|out|' fi */
1986        /* */
1987        sprintf(sortp->x2991,"%10.3f",999999.999-sortp->pesoTTxA);
1988        sprintf(sortp->xrankF,"%6"_LD_,tabcntArankF[v351]); /* key */
1989        sortp->null[0]='\0';
1990        memset(sortp->align,(int)' ',sizeof(sortp->align));
1991        sortp->v351=v351;
1992    }
1993
1994    /* sort W
1995    */
1996    for (k=ntabs-1, i=0; i<k; i++) {
1997        ip=sort_tab+i;
1998        for (j=i+1; j<ntabs; j++) {
1999            jp=sort_tab+j;
2000            if (memcmp((void *)ip,(void *)jp,keylen) > 0) {
2001                memcpy((void *)sort_tmp,(void *)ip,      sizeof(OUTFREQW_SORT_ENTRY));
2002                memcpy((void *)ip      ,(void *)jp,      sizeof(OUTFREQW_SORT_ENTRY));
2003                memcpy((void *)jp      ,(void *)sort_tmp,sizeof(OUTFREQW_SORT_ENTRY));
2004            }
2005        }
2006    }
2007
2008
2009    /* store tabcntArankW (indexed by DecsMfn) and tabfreqW (indexed by rankW)
2010    */
2011    for (sortp=sort_tab, tabW=tabfreqW, mfn=1L; mfn<=ntabs; mfn++, sortp++, tabW++) {
2012        tabW->v351=sortp->v351;
2013        tabW->docsTTxA=sortp->docsTTxA;       /*  v999[1] = docs de TT em xA */
2014        tabW->docsTTamdl=sortp->docsTTamdl;   /*  v999[2] = docs de TT em amdl = postings de TT em amdl */
2015        tabW->frelTTxA=sortp->frelTTxA;       /* v1991[1] = frelTTxA = docs de TT em xA / docs de xA */
2016        tabW->frelTTamdl=sortp->frelTTamdl;   /* v1991[2] = frelTTamdl = docs de TT em amdl / docs de amdl */
2017        tabW->peso=sortp->pesoTTxA;           /* v2991    = frelTTxA / frelTTamdl */
2018//        strcpy(tabW->pesoTTxAout,(sortp->frelTTxA < sortp->frelTTamdl)?"out":""); /* if v1991[1]<v1991[2] then 'a2221|out|' fi */
2019        tabcntArankW[sortp->v351]=mfn;
2020    }
2021
2022
2023    return(0);
2024}
2025
2026
2027#if ANSI
2028int outfreqW(int ntabs, char *dbnoutp, LONGX docsTOTxA, LONGX docsTOTamdl, LONGX *tabcntArankF, LONGX *tabcntArankD, TABFREQD_ENTRY *tabfreqD, TABFREQW_ENTRY *tabfreqW)
2029#else
2030int outfreqW(ntabs, dbnoutp, docsTOTxA, docsTOTamdl, tabcntArankF, tabcntArankD, tabfreqD, tabfreqW)
2031int ntabs;
2032char *dbnoutp;
2033LONGX docsTOTxA;    /* v9991[1] = docs de xA - nao vazios */
2034LONGX docsTOTamdl;  /* v9991[2] = docs de amdl */
2035LONGX *tabcntArankF;
2036LONGX *tabcntArankD;
2037TABFREQD_ENTRY *tabfreqD;
2038TABFREQW_ENTRY *tabfreqW;
2039#endif
2040{
2041    RECSTRU *recp;
2042    LONGX mfn;
2043    char buffup[BUFSIZ],*batchp;
2044
2045    LONGX upirec;
2046    LONGX upcrec;
2047
2048    TABFREQD_ENTRY *tabD;
2049    LONGX xrankD;
2050
2051    TABFREQW_ENTRY *tabW;
2052
2053    if (!ntabs) return(0);
2054
2055    /* output
2056    */
2057    record(upcrec=nrecs,dbnoutp,0L);
2058    record(upirec=nrecs,dbnoutp,1L);
2059    for (tabW=tabfreqW, mfn=1L; mfn<=ntabs; mfn++, tabW++) {
2060        batchp=buffup;
2061
2062        sprintf(batchp,"A1/%06"_LD_"/"     ,tabW->v351              ); batchp+=strlen(batchp);
2063        sprintf(batchp,"A999/%"_LD_"/"     ,tabW->docsTTxA          ); batchp+=strlen(batchp);
2064        sprintf(batchp,"A999/%"_LD_"/"     ,tabW->docsTTamdl        ); batchp+=strlen(batchp);
2065
2066        sprintf(batchp,"A9991/%"_LD_"/"    ,      docsTOTxA         ); batchp+=strlen(batchp);
2067        sprintf(batchp,"A9991/%"_LD_"/"    ,      docsTOTamdl       ); batchp+=strlen(batchp);
2068
2069        sprintf(batchp,"A1991/%10.8f/" ,tabW->frelTTxA          ); batchp+=strlen(batchp);
2070        sprintf(batchp,"A1991/%10.8f/" ,tabW->frelTTamdl        ); batchp+=strlen(batchp);
2071        sprintf(batchp,"A2991/%5.3f/"  ,tabW->peso              ); batchp+=strlen(batchp);
2072
2073//        if (tabW->pesoTTxAout[0])
2074//      sprintf(batchp,"A2221/%s/"     ,tabW->pesoTTxAout       ); batchp+=strlen(batchp);
2075
2076        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankF[tabW->v351]); batchp+=strlen(batchp);
2077        sprintf(batchp,"A2220/%"_LD_"/"    ,mfn                     ); batchp+=strlen(batchp);
2078        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankD[tabW->v351]); batchp+=strlen(batchp);
2079
2080        xrankD=tabcntArankD[tabW->v351];
2081        tabD=tabfreqD; tabD+=(xrankD-1);
2082        sprintf(batchp,"A2992/%s/"     ,tabD->delca             ); batchp+=strlen(batchp);
2083        sprintf(batchp,"A2993/%"_LD_"/"    ,gtabcntA[tabD->gmfn]    ); batchp+=strlen(batchp);
2084        sprintf(batchp,"A2994/%06"_LD_"/"  ,tabD->gmfn              ); batchp+=strlen(batchp);
2085
2086        *batchp='\0';
2087        RECORD(upirec,dbnoutp,mfn); MFRstatus=ACTIVE;
2088        if (fldupdat(upirec,buffup)) return(mfn);
2089        recupdat(upcrec,upirec);
2090    }
2091
2092    return(0);
2093}
2094
2095
2096
2097#if ANSI
2098int rutfreqD(TABFREQF_ENTRY *tabfreqF, int ntabs, LONGX *tabcntArankF, LONGX *tabcntArankW, LONGX *tabcntArankD, TABFREQD_ENTRY **tabfreqDp, LONGX *tabcntGMDL, LONGX *gtabcntA)
2099#else
2100int rutfreqD(tabfreqF, ntabs,tabcntArankF, tabcntArankW, tabcntArankD, tabfreqDp, gtabcntA)
2101TABFREQF_ENTRY *tabfreqF;
2102int ntabs;
2103LONGX *tabcntArankF;
2104LONGX *tabcntArankW;
2105LONGX *tabcntArankD;
2106TABFREQD_ENTRY **tabfreqDp;
2107LONGX *tabcntGMDL;
2108LONGX *gtabcntA;
2109#endif
2110{
2111    LONGX mfn;
2112    int v351;
2113
2114    LONGX nbytes;
2115    char *p;
2116
2117    TABFREQD_ENTRY *tabfreqD,*tabD;
2118    TABFREQF_ENTRY *tabF;
2119
2120typedef struct outfreqD_sort_entry {
2121//    char x2992[10];
2122    char x2992_cat[1]; /* memcpy(,,1) */
2123    char x2993[10];
2124    char x2992[MAXCATLEN+1];
2125    char xrankF[6];
2126    LONGX v351;
2127    LONGX gmfn;
2128//    LONGX delta;
2129} OUTFREQD_SORT_ENTRY;
2130
2131    OUTFREQD_SORT_ENTRY *sort_tab,*sort_tmp,*sortp,*ip,*jp;
2132    int i,j,k;
2133
2134    int keylen=sizeof(sortp->x2992_cat)+sizeof(sortp->x2993)+sizeof(sortp->x2992)+sizeof(sortp->xrankF);
2135
2136
2137    /* init tabcntArankD (indexed by DecsMfn)
2138    */
2139    memset(tabcntArankD,0,sizeof(LONGX)*CLASSES);
2140
2141    *tabfreqDp=NULL;
2142    if (!ntabs) return(0);
2143
2144    /* alloc tabfreqD (indexed by rankD)
2145    */
2146    nbytes=sizeof(TABFREQD_ENTRY)*ntabs;
2147    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqD/tabfreqD/ALLOMAXV");
2148    p=(char *)ALLOC((ALLOPARM)(nbytes));
2149    if (p == ALLONULL) fatal("aotmsa2/rutfreqD/tabfreqD/ALLOC");
2150    memset(p,0,nbytes); /* init */
2151    tabfreqD=(TABFREQD_ENTRY *)p;
2152    *tabfreqDp=tabfreqD;
2153
2154    nbytes=sizeof(OUTFREQD_SORT_ENTRY)*ntabs+sizeof(OUTFREQD_SORT_ENTRY);
2155    if (nbytes >= (LONGX)ALLOMAXV) fatal("aotmsa2/rutfreqD/sort_tab/ALLOMAXV");
2156    p=(char *)ALLOC((ALLOPARM)(nbytes));
2157    if (p == ALLONULL) fatal("aotmsa2/rutfreqD/sort_tab/ALLOC");
2158    sort_tab=(OUTFREQD_SORT_ENTRY *)p;
2159    sort_tmp=sort_tab+ntabs;
2160
2161    for (sortp=sort_tab, tabF=tabfreqF, mfn=1L; mfn<=ntabs; mfn++, tabF++, sortp++) {
2162        v351=tabF->v351;
2163////        sortp->delta=tabcntArankW[v351]-tabcntArankF[v351];
2164////        sprintf(sortp->x2992,"%10"_LD_,555555555-sortp->delta);
2165//        sortp->delta=tabcntGMDL[v351];
2166//        sprintf(sortp->x2992,"%10"_LD_,999999999-sortp->delta);
2167
2168
2169#if 0
2170            (if v20.1='C' or v20.1='D'
2171                then v20,break
2172                else if iocc=1 then v20'<br>' fi
2173             fi
2174            )
2175#endif
2176          if (1) {
2177              DIRSTRU *dirp;
2178              int len,xdir;
2179              RECSTRU *recp;
2180       
2181              RECORD(ddrec,"mydecs",v351); //        recfield(sortp->x2992,ddrec,20,1,"");
2182       
2183              for (dirp=MFRdir, xdir=0; xdir < MFRnvf; dirp++, xdir++)
2184                if (dirp->tag == TAG005) {
2185                    int loop;
2186                    LONGX mfn=0;
2187                    p=FIELDP(xdir);
2188                    for (loop=dirp->len; loop--; p++) mfn=mfn*10+((int)(*p)-(int)'0');
2189                    if (mfn > CLASSES) fatal("aotmsa2/rutfreqD/TAG005/CLASSES");
2190                    sprintf(sortp->x2993,"%10"_LD_,999999999L-gtabcntA[mfn]);
2191                    sortp->gmfn=mfn;
2192                    break;
2193                }
2194              for (dirp=MFRdir, xdir=0; xdir < MFRnvf; dirp++, xdir++)
2195                if (dirp->tag == TAG022) {
2196                    p=FIELDP(xdir);
2197                    if (*p == 'C' || *p == 'D') ; else fatal("aotmsa2/rutfreqD/TAG022/CD");
2198                    len=dirp->len; if (len>=sizeof(sortp->x2992)) len=sizeof(sortp->x2992)-1;
2199                    strncpy(sortp->x2992,p,len); sortp->x2992[len]='\0';
2200                    memcpy(sortp->x2992_cat,p,1); /* memcpy(,,1) */
2201                    break;
2202                }
2203          }
2204          sprintf(sortp->xrankF,"%6"_LD_,tabcntArankF[v351]); /* key */
2205          sortp->v351=v351;
2206         
2207    } /* end for (sortp=sort_tab) */
2208
2209    /* sort D
2210    */
2211    for (k=ntabs-1, i=0; i<k; i++) {
2212        ip=sort_tab+i;
2213        for (j=i+1; j<ntabs; j++) {
2214            jp=sort_tab+j;
2215            if (memcmp((void *)ip,(void *)jp,keylen) > 0) {
2216                memcpy((void *)sort_tmp,(void *)ip,      sizeof(OUTFREQD_SORT_ENTRY));
2217                memcpy((void *)ip      ,(void *)jp,      sizeof(OUTFREQD_SORT_ENTRY));
2218                memcpy((void *)jp      ,(void *)sort_tmp,sizeof(OUTFREQD_SORT_ENTRY));
2219            }
2220        }
2221    }
2222
2223
2224    /* store tabcntArankD (indexed by DecsMfn) and tabfreqD (indexed by rankD)
2225    */
2226    for (sortp=sort_tab, tabD=tabfreqD, mfn=1L; mfn<=ntabs; mfn++, sortp++, tabD++) {
2227        tabD->v351=sortp->v351;
2228//        tabD->delta=sortp->delta;
2229        memcpy(tabD->delca,sortp->x2992,MAXCATLEN);
2230        tabD->gmfn=sortp->gmfn;
2231        tabcntArankD[sortp->v351]=mfn;
2232    }
2233
2234    return(0);
2235}
2236
2237#if ANSI
2238int outfreqD(int ntabs, char *dbnoutp, LONGX *tabcntArankF, LONGX *tabcntArankW, TABFREQD_ENTRY *tabfreqD)
2239#else
2240int outfreqD(ntabs, dbnoutp, tabcntArankF, tabcntArankW, tabfreqD)
2241int ntabs;
2242char *dbnoutp;
2243LONGX *tabcntArankF;
2244LONGX *tabcntArankW;
2245TABFREQD_ENTRY *tabfreqD;
2246#endif
2247{
2248    RECSTRU *recp;
2249    LONGX mfn;
2250    char buffup[BUFSIZ],*batchp;
2251
2252    LONGX upirec;
2253    LONGX upcrec;
2254
2255    TABFREQD_ENTRY *tabD;
2256
2257    if (!ntabs) return(0);
2258
2259    /* output
2260    */
2261    record(upcrec=nrecs,dbnoutp,0L);
2262    record(upirec=nrecs,dbnoutp,1L);
2263    for (tabD=tabfreqD, mfn=1L; mfn<=ntabs; mfn++, tabD++) {
2264        batchp=buffup;
2265
2266        sprintf(batchp,"A1/%06"_LD_"/"     ,tabD->v351              ); batchp+=strlen(batchp);
2267
2268        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankF[tabD->v351]); batchp+=strlen(batchp);
2269        sprintf(batchp,"A2220/%"_LD_"/"    ,tabcntArankW[tabD->v351]); batchp+=strlen(batchp);
2270        sprintf(batchp,"A2220/%"_LD_"/"    ,mfn                     ); batchp+=strlen(batchp);
2271
2272        *batchp='\0';
2273        RECORD(upirec,dbnoutp,mfn); MFRstatus=ACTIVE;
2274        if (fldupdat(upirec,buffup)) return(mfn);
2275        recupdat(upcrec,upirec);
2276    }
2277
2278    return(0);
2279}
2280
2281
2282#if 0
2283#define MFQTDBN0        11
2284#define MFQTQRY0        12
2285#define MFQTOBJ0        13
2286
2287#define MFQTXCTS        20
2288
2289#define MFQSWTIM        't'
2290#define MFQSWDBN        'd'
2291#define MFQSWQTY        'q'
2292
2293#define MFQTASET        21
2294#define MFQTALCC        22
2295
2296#define MFQTHITS        31
2297#define MFQTHCUR        32
2298#define MFQTHMFN        33
2299#define MFQTHSIZ        34
2300#define MFQTHMEM        35
2301
2302#define OPRNULL         0x01
2303#define OPRXEND         0x02
2304#define PSTLEVEL        0x03
2305#define ACCLEVEL        0x04
2306
2307#define B7UPLEN         9               /* length for b40 numeric fields */
2308#define B7DELADD        "D%dA%d|%09"_LD_"|" /* sprintf format for dir/field */
2309#define B7EDIT1         "%09"_LD_         /* sprintf format for field edit */
2310
2311#define MFQTXTAG        101             /* inverted files prefixes */
2312
2313#endif
2314
2315
2316#if ANSI
2317char *recsfldv(char *areap, char *fldp, FFI fldlen, char *defaultp)
2318#else
2319char *recsfldv(areap,fldp,fldlen,defaultp)
2320char *areap;
2321char *fldp;
2322FFI fldlen;
2323char *defaultp;
2324#endif /* CIAPI_SOURCE */
2325{
2326    FFI n;
2327    unsigned char *p;
2328
2329    p=subfldp(fldp,'v',&fldlen);
2330
2331    if (p) n=fldlen; /* ja' decrementado */
2332    else
2333        if (defaultp)
2334            n=(FFI)strlen((char*)(p=(unsigned char*)defaultp));
2335        else
2336            n=(FFI)strlen((char*)(p=(unsigned char*)"\0"));
2337    if (!areap)
2338        if ((areap=(char *)ALLOC((ALLOPARM)n+1)) == (char *)ALLONULL)
2339            fatal("aotmsa2/recsfldv/ALLOC");
2340    memcpy(areap,p,n); areap[n]='\0';
2341    return(areap);
2342}
2343
Note: See TracBrowser for help on using the browser.