![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Text.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / bcp|
Return to Text.c CVS log | Up to [Research Unix] / researchv10no / cmd / bcp |
1.1 root 1: /* Copyright (c) 1989, 1990 AT&T --- All Rights Reserved. */
2: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T. */
3: /* The copyright notice does not imply actual or intended publication. */
4: /* AUTHORS: */
5: /* H. S. Baird - ATT-BL MH - first versions */
6:
7: /* Text.c - functions for Document-image file ("dim" file) handling
8:
9: General Introduction
10: --------------------
11:
12: Dim files describe a document as a collection of records of these types:
13: Page full page
14: Block block (often a column) of text
15: Txtln line of text
16: Word word
17: Char character, isolated symbol, `graph'
18: Interp interpretation of a character (result of classification)
19: Sfeats scalar features of a character
20: Shapes local shape features of a character
21: Bfeats binary indicator features of a character
22: Blob connected component (maximal subset of 8-connected black pixels)
23: Lag line-adjacency graph of runs
24: Run horizontal run of black pixels
25: Pixel bilevel (black/white) picture element (symbols are expected to
26: be black against a white background); usually square
27:
28: They may be organized hierarchically --
29: a Page may own : Blocks, Txtlns, Words, Chars, & Blobs
30: a Block may own : Blocks, Txtlns, Words, Chars, & Blobs
31: a Txtln may own : Txtlns, Words, Chars, & Blobs
32: a Word may own : Words, Chars & Blobs
33: a Char may own : Blobs, Interps, Sfeats, Shapes, & Bfeats
34: a Blob may own : Runs (variously represented)
35: a Run owns : black Pixels
36: Note that the hierarchy is strict except that Blocks, Txtlns, & Words may
37: own records of their own type. This serves several functions:
38: -- a Block may own other Blocks, conventionally nested within it, to
39: represent a physical or logical page layout decomposition;
40: -- a Txtln may have alternative interpretations & segmentations into Words;
41: -- a Word may have alternative segmentations into Chars.
42:
43: For each record type R, there should exist these data-structures:
44: R struct
45: Init_R #define'd initialization string
46: empty_R an extern ``empty'' (initialized) instance of R
47: Also there are library functions (in which _R is spelled in lower-case):
48: R *alloc_R() allocate memory and initialize to ``empty''
49: free_R(R *) free memory (only of record R, not what it owns)
50: free_R_etc(R *,ids) free R and what it owns (as specified by `ids')
51: R *dup_R(R *) return distinct copy, with duplicated contents
52: R *dup_R_etc(R *,ids) return distinct copy, duplicated contents & parts
53: char *R_toa(R *) convert to printable ASCII string
54: frdb_R(FILE *, R *) fread R (binary) from file thru pointer
55: frdb_R_etc(",",ids) fread R (binary) and what it owns (as specified)
56: fwrb_R(FILE *, R *) fwrite R (binary) to file thru pointer
57: fwrb_R_etc(",",ids) fwrite R (binary) and what it owns (as specified)
58: (some of these may be unimplemented if they haven't yet been needed)
59:
60: I/O conventions:
61: -- frd?_... return one of:
62: 1 normal & successful
63: 0 EOF
64: <0 I/O errors
65: Quite a few functions don't obey this rule yet.
66: Many intermediate fns that don't directly perform I/O
67: don't bother passing back status from fns they call.
68: Those that perform I/O directly often complain to stderr and exit(2).
69: The situation is fairly chaotic, and has already caused bugs.
70:
71: Generally:
72: -- An `etc' argument is a set of Ident bits specifying a set of record types;
73: it is passed along unchanged in calls to other _etc functions.
74: -- `fwrb_R_etc' fns obey the `etc' instructions carefully, writing only those
75: record types specified
76: -- `frdb_R_etc' fns mostly ignore `etc', blindly reading everything they
77: see (since they aren't clever enough to skip past yet); however, the
78: Blob-reading fns look at the Runs_?? bits to select a main memory
79: format for Runs
80: -- `frdb_R_etc' uses alloc_Y to allocate all new Y
81: -- `fwrb_R_etc', however, does NOT free anything: this must be done explicitly
82: afterwards.
83:
84: Ownership of a set of records is implemented by two fields in the owner record:
85: (1) a count of the number of members, and (2) either a ``set'' or a ``list''
86: pointer:
87: set: to a NULL-terminated array of pointers to records
88: list: to the first in a singly-linked, NULL-terminated, chain
89: sets are used for sets of Blocks, Txtlns, Words, Chars, and Blobs
90: lists are used for Interpl, and for Blobs owned by Chars, since they tend
91: to be fewer
92:
93: Blobs and Runs are treated more elaborately than other records. Blobs are
94: collected in lists when owned by Chars, but in sets otherwise --
95: the motivation was that the Char lists are usually very short, and the malloc
96: overhead of creating them might be unpleasant -- however, maintaining two
97: kinds of sets has caused other headaches; it might be good someday to
98: abolish lists in favor of sets throughout.
99: Runs can often be compressed to about half the usual size by using char
100: fields instead of shorts, and this is done automatically when writing to files. There is both a set and a list form of Run.
101:
102: The peripheral file format is:
103: - deliberately decoupled from the internal (main memory) format: i.e.
104: the main memory structs can be (and are) changed frequently for
105: purposes of experimentation without forcing frequent reformatting
106: of the (by now large) backlog of archived files (particularly the
107: character image databases). To bring such files up-to-date, the program
108: `renew' should be used: it must be edited to reflect changes since
109: the last overhaul of the file format.
110: - designed to be ``scannable'': that is, one can skip rapidly from record
111: to record (using the Ident headers) without minding the hierarchy.
112: This is most useful for the graphics editor "met", where it permits
113: quick response at the outset. It is also used widely in the
114: off-line training programs, where main memory is at a premium.
115: - machine-independent: floating-point representations are forced to
116: fixed point and scaled to integer; all integer representations are
117: written as a sequence of bytes in a fixed order, via putc()/getc().
118: fwrite()/fread() are never used for binary I/O. This seems to work
119: on virtually all UNIX machines. See fioi.h.
120:
121: CCITT Group 4 encodings have been implemented and are available
122: as a peripheral file format for Blobs. They offer a large compression
123: factor (x8) over RunF and RunFS records, and the CPU overhead is not
124: excessive. It turns out that the connectivity information represented
125: explicitly in Run records but lost in ccitt-g4 can be recovered in linear
126: time and space (see fix_lag()); in practice the extra recovery time is
127: negligible and the extra space is 0. This is possible because Blobs are
128: known to be connected: if not, then (I suspect that) superlinear time is
129: required in general to recover the lag.
130:
131: */
132:
133: #include <stdio.h>
134: #include <math.h>
135: #define LIBC_INCL 1
136: #include "CPU.h"
137: #include "stdocr.h"
138: #include "rle.h"
139: #include "Text.h"
140: #include "bitio.h"
141: #include "CCITT.h"
142:
143: long fseek(),lseek();
144:
145: #define dbg_fwrb T /* failsafe consistency checking */
146: #define dbg_frdb T /* failsafe consistency checking */
147: #define dbg_fwrb_runs F /* announce no. bytes used to write each Blob's Runs */
148: #define dbg_frdb_runs F /* announce no. bytes used to write each Blob's Runs */
149:
150: /* return ASCII string describing ident bits */
151: char *ident_toa(id)
152: Ident id;
153: { static char s[80];
154: s[0]='\0';
155: if((id&IsALL)==IsALL) strcat(s,"ALL");
156: else {
157: if(id&IsPage) {
158: strcat(s,"PG");
159: if(id&(Page_label)) {
160: strcat(s,".");
161: if(id&Page_label) strcat(s,"l");
162: };
163: }
164: if(id&IsBlock) {
165: strcat(s,"BK");
166: if(id&(Block_wst|Block_label)) {
167: strcat(s,".");
168: if(id&Block_wst) strcat(s,"w");
169: if(id&Block_label) strcat(s,"l");
170: };
171: };
172: if(id&IsTxtln) {
173: strcat(s,"TL");
174: if(id&(Txtln_basl|Txtln_size|Txtln_label)) {
175: strcat(s,".");
176: if(id&Txtln_basl) strcat(s,"b");
177: if(id&Txtln_size) strcat(s,"s");
178: if(id&Txtln_label) strcat(s,"l");
179: };
180: };
181: if(id&IsWord) {
182: strcat(s,"WD");
183: if(id&(Word_spelled|Word_label)) {
184: strcat(s,".");
185: if(id&Word_spelled) strcat(s,"s");
186: if(id&Word_label) strcat(s,"l");
187: };
188: };
189: if(id&IsWordInterp) {
190: strcat(s,"WI");
191: if(id&(Word_spelled|Word_numeric|Word_initcap|Word_allcaps|Word_hyphens|Word_slashes|Word_termhyp|Word_endsent)) {
192: strcat(s,".");
193: if(id&Word_spelled) strcat(s,"s");
194: if(id&Word_numeric) strcat(s,"n");
195: if(id&Word_initcap) strcat(s,"i");
196: if(id&Word_allcaps) strcat(s,"a");
197: if(id&Word_hyphens) strcat(s,"-");
198: if(id&Word_slashes) strcat(s,"/");
199: if(id&Word_termhyp) strcat(s,"h");
200: if(id&Word_endsent) strcat(s,".");
201: };
202: };
203: if(id&IsChar) {
204: strcat(s,"CH");
205: if(id&(Char_spelled|Char_confused|Char_termhyp|Char_omit|Char_label|Char_ranparms)) {
206: strcat(s,".");
207: if(id&Char_spelled) strcat(s,"s");
208: if(id&Char_confused) strcat(s,"c");
209: if(id&Char_termhyp) strcat(s,"h");
210: if(id&Char_omit) strcat(s,"o");
211: if(id&Char_label) strcat(s,"l");
212: if(id&Char_ranparms) strcat(s,"r");
213: if(id&Char_split) strcat(s,"S");
214: if(id&Char_merged) strcat(s,"M");
215: };
216: };
217: if(id&IsInterp) {
218: strcat(s,"IN");
219: if(id&Interp_spelled) {
220: strcat(s,".s");
221: };
222: };
223: if(id&IsBlob) {
224: strcat(s,"BB");
225: if( id&(Blob_lm|Blob_rm|Blob_tm|Blob_bm
226: |Blob_chopt|Blob_chopb|Blob_chopl|Blob_chopr
227: |Blob_small|Blob_local)
228: ) {
229: strcat(s,".");
230: if(id&(Blob_tm|Blob_bm|Blob_lm|Blob_rm)) {
231: if(id&Blob_lm) strcat(s,"l");
232: if(id&Blob_rm) strcat(s,"r");
233: if(id&Blob_tm) strcat(s,"t");
234: if(id&Blob_bm) strcat(s,"b");
235: };
236: if(id&(Blob_chopt|Blob_chopb|Blob_chopl|Blob_chopr)) {
237: if(id&Blob_chopl) strcat(s,"L");
238: if(id&Blob_chopr) strcat(s,"R");
239: if(id&Blob_chopt) strcat(s,"T");
240: if(id&Blob_chopb) strcat(s,"B");
241: };
242: if(id&Blob_small) strcat(s,"s");
243: if(id&Blob_local) strcat(s,"o");
244: };
245: }
246: };
247: return(s);
248: }
249:
250: /* convert a conventional character-code to a record type */
251: Ident cto_ident(c)
252: char c;
253: { Ident type;
254: switch(c) {
255: case 'b':
256: type=IsBlob; break;
257: case 'B': case 'k':
258: type=IsBlock; break;
259: case 'c':
260: type=IsChar; break;
261: case 'i':
262: type=IsInterp; break;
263: case 'p': case 'P':
264: type=IsPage; break;
265: case 'r':
266: type=IsRun; break;
267: case 't': case 'l':
268: type=IsTxtln; break;
269: case 'w':
270: type=IsWord; break;
271: case 'y':
272: type=IsBdy; break;
273: };
274: return(type);
275: }
276:
277: Ident cto_flag(c,type)
278: char c;
279: Ident type;
280: { Ident flag;
281: flag = IsNONE;
282: if(type&IsPage) {
283: switch(c) {
284: case 'l': flag |= Page_label; break;
285: };
286: }
287: else if(type&IsBlock) {
288: switch(c) {
289: case 'w': flag |= Block_wst; break;
290: case 'l': flag |= Block_label; break;
291: };
292: }
293: else if(type&IsTxtln) {
294: switch(c) {
295: case 'b': flag |= Txtln_basl; break;
296: case 's': flag |= Txtln_size; break;
297: case 'l': flag |= Txtln_label; break;
298: };
299: }
300: else if(type&IsWord) {
301: switch(c) {
302: case 's': flag |= Word_spelled; break;
303: case 'n': flag |= Word_numeric; break;
304: case 'i': flag |= Word_initcap; break;
305: case 'a': flag |= Word_allcaps; break;
306: case '-': flag |= Word_hyphens; break;
307: case '/': flag |= Word_slashes; break;
308: case 'h': flag |= Word_termhyp; break;
309: case '.': flag |= Word_endsent; break;
310: case 'l': flag |= Word_label; break;
311: };
312: }
313: else if(type&IsChar) {
314: switch(c) {
315: case 's': flag |= Char_spelled; break;
316: case 'c': flag |= Char_confused; break;
317: case 'h': flag |= Char_termhyp; break;
318: case 'o': flag |= Char_omit; break;
319: case 'l': flag |= Char_label; break;
320: case 'r': flag |= Char_ranparms; break;
321: case 'S': flag |= Char_split; break;
322: case 'M': flag |= Char_merged; break;
323: };
324: }
325: else if(type&IsBlob) {
326: switch(c) {
327: case 'B': flag |= Blob_chopb; break;
328: case 'L': flag |= Blob_chopl; break;
329: case 'R': flag |= Blob_chopr; break;
330: case 'T': flag |= Blob_chopt; break;
331: case 'b': flag |= Blob_bm; break;
332: case 'l': flag |= Blob_lm; break;
333: case 'o': flag |= Blob_local; break;
334: case 'r': flag |= Blob_rm; break;
335: case 's': flag |= Blob_small; break;
336: case 't': flag |= Blob_tm; break;
337: };
338: }
339: else if(type&IsInterp) {
340: switch(c) {
341: case 's': flag |= Interp_spelled; break;
342: };
343: };
344: return(flag);
345: }
346:
347: #if FRDI
348: /* read only the Ident of the next record; if EOF, return 0 */
349: Ident frdb_ident(fp)
350: FILE *fp;
351: { Ident ident;
352: ident = frdi_Ident(fp);
353: #if dbg_frdb_toa
354: err("frdb_ident: %s",ident_toa(ident));
355: #endif
356: if(feof(fp)) return(0);
357: else return(ident);
358: }
359: #else
360: /* read only the Ident of the next record; return 0 iff EOF */
361: Ident frdb_ident(fp)
362: FILE *fp;
363: { Ident ident;
364: int stat;
365: if((stat=fread(&ident,sizeof(Ident),1,fp))!=1) {
366: if(stat==0) return(0);
367: else abort("frdb_ident: can't fread, status %d",stat);
368: };
369: if( Readvax ) ident = swapintin(ident);
370: #if dbg_frdb_toa
371: err("frdb_ident: %s",ident_toa(ident));
372: #endif
373: if(feof(fp)) return(0);
374: else return(ident);
375: }
376: #endif
377:
378: #if FRDI
379: /* read label into malloc space */
380: char *frdb_label(f)
381: FILE *f;
382: { register char *res;
383: res=frdi_str(f);
384: #if dbg_frdb_toa
385: err("frdb_label: \"%s\"",res);
386: #endif
387: return(res);
388: }
389: #else
390: /* read label into malloc space */
391: char *frdb_label(fp)
392: FILE *fp;
393: { static char s[MAX_LABEL_LEN];
394: char *c,*ce,*l;
395: int ch;
396: ce=(c=s)+MAX_LABEL_LEN-1;
397: while((c<ce)&&((ch=getc(fp))!=EOF)&&(ch!='\0')) *(c++) = ch;
398: *c='\0';
399: if(c==ce) {
400: /* label is truncated; find end of it */
401: while(((ch=getc(fp))!=EOF)&&(ch!='\0')) ;
402: };
403: if((l=strdup(s))==NULL)
404: abort("frdb_label: can't dup char *s[%d]",strlen(s));
405: #if dbg_frdb_toa
406: err("frdb_label: \"%s\"",l);
407: #endif
408: return(l);
409: }
410: #endif
411:
412: /* skip label */
413: fskb_label(fp)
414: FILE *fp;
415: { int ch;
416: while(((ch=getc(fp))!=EOF)&&(ch!='\0')&&(ch!='\n')) ;
417: if(ch==EOF) return(0); else return(1);
418: }
419:
420: /* Skip the REST of this record (the Ident is assumed to have been read),
421: and return the Ident of the next record in the file;
422: else return:
423: 0 EOF
424: -1 I/O error
425: -2 not one of: Page, Block, Txtln, Char, Interp
426: */
427: char *pp_toa(ppp)
428: Pp *ppp;
429: { static char s[30];
430: sprintf(s,"(%0.2f,%0.2f)",ppp->x,ppp->y);
431: return(s);
432: }
433:
434: /* return integer string in the range 00-99 */
435: char *merit_toa(m)
436: Merit m;
437: { static char s[3];
438: int im;
439: im = (int)(m * 100);
440: if(im>99) im=99; else if(im<0) im=0;
441: if(im<10) {
442: s[0] = '0';
443: sprintf(s+1,"%d",im);
444: }
445: else sprintf(s,"%2d",im);
446: s[3] = '\0';
447: return(s);
448: }
449:
450: char *pts_toa(p)
451: Pts p;
452: { static char s[10];
453: sprintf(s,"%g",((int)((p*10.0)+0.5))/10.0);
454: return(s);
455: }
456:
457: Bdy *alloc_bdy()
458: { Bdy *p;
459: if((p=(Bdy *)malloc(sizeof(Bdy)))==NULL)
460: abort("alloc_bdy: can't malloc");
461: else { *p = empty_Bdy;
462: return(p);
463: };
464: }
465:
466: Bdys *alloc_bdys()
467: { Bdys *p;
468: if((p=(Bdys *)malloc(sizeof(Bdys)))==NULL)
469: abort("alloc_bdys: can't malloc");
470: else { *p = empty_Bdys;
471: return(p);
472: };
473: }
474:
475: char *bdyedge_toa(bep)
476: BdyEdge *bep;
477: { static char s[80];
478: char aps[20];
479: strcpy(aps,sp_toa(bep->ap));
480: sprintf(s,"%s,%s p%d c%s a%0.2f",
481: aps, sp_toa(bep->bp),
482: bep->per,
483: pp_toa(&(bep->ctr)),
484: (bep->ang/PI)*180.0);
485: return(s);
486: }
487:
488: free_bdyedges(besp)
489: BdyEdges *besp;
490: { register BdyEdge *bep,**bepp;
491: if(besp->pa!=NULL) {
492: if(besp->mny>0) {
493: for(bep= *(bepp=besp->pa); bep!=NULL; bep= *(++bepp))
494: free(bep);
495: };
496: free(besp->pa);
497: };
498: *besp = empty_BdyEdges;
499: }
500:
501: /* Skip past the "TYPE=document-image\n\n" (or "TYPE=dim\n\n") ASCII header from
502: file *fp, read and check the Doc record, and, if all's well, return 1.
503: If an immediate EOF, return 0. If not EOF, and no "TYPE=" header,
504: leave fp as it was, and return -1. If a malformed "TYPE=" header, leave fp
505: as it was, and return -2. */
506: int skip_type(fp)
507: FILE *fp;
508: { int ich,stat;
509: long seek;
510: #define MAX_TYPE_HDR_LEN (100)
511: char type_eq[MAX_TYPE_HDR_LEN+1];
512: register char *pcp,*ccp,*ecp;
513: int version;
514:
515: seek = ftell(fp);
516: /* test for EOF */
517: if(feof(fp) || (ich=getc(fp))==EOF)
518: /* premature EOF*/ return(0);
519: if((type_eq[0]=ich)!='T') {
520: /* no "TYPE=" header */
521: ungetc(ich,fp); /* fast, guaranteed push-back */
522: return(-1);
523: };
524: /* try to read the rest of "TYPE=" */
525: for(ecp=(ccp=type_eq+1)+4; ccp<ecp; ccp++) {
526: if(feof(fp) || (ich=getc(fp))==EOF) {
527: /* no "TYPE=" header */
528: fseek(fp,seek,0);
529: return(-1);
530: }
531: else *ccp=ich;
532: }
533: *ccp='\0';
534: /* check for "TYPE=" so far */
535: if(strcmp(type_eq,"TYPE=")==0) {
536: /* read rest of ASCII header */
537: ccp=(pcp=type_eq+3)+1; ecp=type_eq+MAX_TYPE_HDR_LEN;
538: do { ccp++; pcp++;
539: if((ich=getc(fp))==EOF) {
540: /* malformed "TYPE=" header */
541: fseek(fp,seek,0);
542: return(-2);
543: }
544: else *ccp=ich;
545: }
546: while(ccp<ecp && (*ccp!='\n'||*pcp!='\n'));
547: if(ccp==ecp) {
548: /* malformed "TYPE=" header */
549: fseek(fp,seek,0);
550: return(-2);
551: };
552: *pcp='\0';
553: /* check that it is "TYPE=document-image\n\n" or "TYPE=dim\n\n" */
554: if(strcmp(type_eq,"TYPE=document-image")!=0
555: && strcmp(type_eq,"TYPE=dim")!=0) {
556: /* malformed "TYPE=" header */
557: fseek(fp,seek,0);
558: return(-2);
559: };
560: #if dbg_frdb_toa
561: err("skip_type: \"%s\\n\\n\"",type_eq);
562: #endif
563: return(1); /* normal and successful TYPE= header */
564: }
565: else { /* no "TYPE=" header */
566: fseek(fp,seek,0);
567: return(-1);
568: };
569: }
570:
571: Doc *alloc_doc()
572: { Doc *p;
573: if((p=(Doc *)malloc(sizeof(Doc)))==NULL)
574: abort("alloc_doc: can't malloc");
575: else { *p = empty_Doc;
576: return(p);
577: };
578: }
579:
580: char *doc_toa(p)
581: Doc *p;
582: { static char s[80];
583: sprintf(s,"Doc v%d p%d l%s",
584: p->version,
585: p->ps.mny,
586: (p->l!=NULL)? p->l: "");
587: return(s);
588: }
589:
590: #if FWRI
591: /* write the given doc (record only) */
592: fwrb_doc(f,p)
593: FILE *f;
594: Doc *p;
595: { int stat;
596: fwri_uint1(f,p->version);
597: fwri_uint2(f,p->ps.mny);
598: #if dbg_fwrb_toa
599: err("fwrb_doc: %s",doc_toa(p));
600: #endif
601: if(p->l!=NULL) {
602: fwri_ch(f,'l');
603: fwrb_label(f,p->l);
604: }
605: else fwri_ch(f,'\0');
606: }
607: #else
608: fwrb_doc(f,p)
609: FILE *f;
610: Doc *p;
611: {}
612: #endif
613:
614: #if FRDI
615: /* read a Doc record (only) - it must be next in the file;
616: don't immediately read its parts; return 0 iff immediate EOF.
617: Check for correct version no: if fails, abort. */
618: int frdb_doc(f,p)
619: FILE *f;
620: Doc *p;
621: { char qlabel;
622: *p = empty_Doc;
623: if(feof(f))
624: return(0);
625: p->version=frdi_uint1(f);
626: p->ps.mny=frdi_uint2(f);
627: if((qlabel=frdi_ch(f))=='l')
628: p->l=frdb_label(f);
629: #if dbg_frdb_toa
630: err("frdb_doc: %s",doc_toa(p));
631: #endif
632: if(ferror(f)) return(-errno); else return(1);
633: }
634: #else
635: int frdb_doc(f,p)
636: FILE *f;
637: Doc *p;
638: { return(1);
639: }
640: #endif
641:
642: #if FWRI
643: /* Write the initial Doc record */
644: put_doc(f)
645: FILE *f;
646: { Doc doc;
647: doc = empty_Doc;
648: doc.version = DIM_VERSION;
649: doc.ps.mny = 1;
650: fwrb_doc(f,&doc);
651: }
652: #else
653: put_doc(f)
654: FILE *f;
655: {}
656: #endif
657:
658: #if FRDI
659: /* read, check, discard, and skip past the Doc record */
660: int skip_doc(f)
661: FILE *f;
662: { Doc doc;
663: frdb_doc(f,&doc);
664: if(doc.version!=DIM_VERSION)
665: abort("skip_doc: version %d != DIM_VERSION %d",
666: doc.version,DIM_VERSION);
667: if(doc.l!=NULL) free(doc.l);
668: return(1);
669: }
670: #else
671: int skip_doc(f)
672: FILE *f;
673: { Doc doc;
674: return(1);
675: }
676: #endif
677:
678: Page *alloc_page()
679: { Page *p;
680: if((p=(Page *)malloc(sizeof(Page)))==NULL)
681: abort("alloc_page: can't malloc");
682: alloc_census(Page,1);
683: *p = empty_Page;
684: return(p);
685: }
686:
687: char *page_toa(p)
688: Page *p;
689: { static char s[80];
690: sprintf(s,"%s bx%s res%d,%d sk%0.2f,sh%0.2f bk%d l%d c%d b%d",
691: ident_toa(p->ident),
692: bbx_toa(&(p->bx)),
693: p->res_x,p->res_y,
694: (p->skew/PI)*180.0,
695: (p->shear/PI)*180.0,
696: p->bks.mny,p->ls.mny,p->cs.mny,p->bs.mny,
697: (p->l!=NULL)? p->l: "");
698: return(s);
699: }
700:
701: #if FWRI
702: /* write the given page (record only) */
703: fwrb_page(f,p)
704: FILE *f;
705: Page *p;
706: { int stat;
707: #if dbg_fwrb
708: if(f==stdout||f==stderr||ftell(f)<=0L) {
709: fprintf(f,"TYPE=dim\n\n");
710: #if dbg_fwrb_toa
711: err("fwrb_page: \"TYPE=dim\\n\\n\"");
712: #endif
713: put_doc(f);
714: };
715: if((!(p->ident&IsPage))||(p->ident&(IsALL&(~IsPage))))
716: err("fwrb_page: %s",page_toa(p));
717: if(p->ident&Page_label && p->l==NULL) {
718: err("fwrb_page: Page_label set but .l==NULL");
719: p->ident &= ~Page_label;
720: };
721: #endif
722: fwri_Ident(f,p->ident);
723: fwri_Bbx(f,&(p->bx));
724: fwri_int2(f,p->res_x);
725: fwri_int2(f,p->res_y);
726: fwri_Radians(f,p->skew);
727: fwri_Radians(f,p->shear);
728: fwri_uint2(f,p->bks.mny);
729: fwri_uint2(f,p->ls.mny);
730: fwri_uint2(f,p->ws.mny);
731: fwri_uint2(f,p->cs.mny);
732: fwri_uint3(f,p->bs.mny);
733: #if dbg_fwrb_toa
734: err("fwrb_page: %s",page_toa(p));
735: #endif
736: if(p->ident&Page_label) fwrb_label(f,p->l);
737: }
738: #else
739: /* write the given page (record only) */
740: fwrb_page(fp,pp)
741: FILE *fp;
742: Page *pp;
743: { PageF pf;
744: int stat;
745: #if dbg_fwrb
746: if((!(pp->ident&IsPage))||(pp->ident&(IsALL&(~IsPage))))
747: err("fwrb_page: %s",page_toa(pp));
748: #endif
749: memset(&pf,'\0',sizeof(pf));
750: pf.ident = pp->ident;
751: pf.res_x=pp->res_x;
752: pf.res_y=pp->res_y;
753: pf.bx=pp->bx;
754: pf.skew=pp->skew;
755: pf.shear=pp->shear;
756: pf.bkmny=pp->bks.mny;
757: pf.lmny=pp->ls.mny;
758: pf.wmny=pp->ws.mny;
759: pf.cmny=pp->cs.mny;
760: pf.bmny=pp->bs.mny;
761: if(fp==stdout||fp==stderr||ftell(fp)<=0L) {
762: fprintf(fp,"TYPE=document-image\n\n");
763: #if dbg_fwrb_toa
764: err("fwrb_page: \"TYPE=document-image\\n\\n\"");
765: #endif
766: };
767: if((stat=fwrite(&pf,sizeof(PageF),1,fp))!=1)
768: abort("fwrb_page: can't fwrite - status %d",stat);
769: #if dbg_fwrb_toa
770: err("fwrb_page: %s",page_toa(pp));
771: #endif
772: if(pf.ident&Page_label) fwrb_label(fp,pp->l);
773: }
774: #endif
775:
776: /* write a page and its specified parts */
777: fwrb_page_etc(fp,pp,etc)
778: FILE *fp;
779: Page *pp;
780: Ident etc;
781: { static Ident parts = (IsBlock|IsTxtln|IsWord|IsChar|IsBlob);
782: Page pg;
783: if((etc&parts)!=parts) /* write selected parts */ {
784: pg = *pp;
785: if(!(etc&IsBlock)) pg.bks.mny=0;
786: if(!(etc&IsTxtln)) pg.ls.mny=0;
787: if(!(etc&IsWord)) pg.ws.mny=0;
788: if(!(etc&IsChar)) pg.cs.mny=0;
789: if(!(etc&IsBlob)) pg.bs.mny=0;
790: pp = &pg; /* write modified record */
791: };
792: fwrb_page(fp,pp);
793: fwrb_blocks_etc(fp,pp->bks,etc);
794: fwrb_txtlns_etc(fp,pp->ls,etc);
795: fwrb_words_etc(fp,pp->ws,etc);
796: fwrb_chars_etc(fp,pp->cs,etc);
797: fwrb_blobs_etc(fp,pp->bs,etc);
798: }
799:
800: /* write a page and its specified parts, ASCII (INCOMPLETE) */
801: fwra_page_etc(fp,pp,etc)
802: FILE *fp;
803: Page *pp;
804: Ident etc;
805: { static Ident parts = (IsBlock|IsTxtln|IsWord|IsChar|IsBlob);
806: Page pg;
807: if((etc&parts)!=parts) /* write selected parts */ {
808: pg = *pp;
809: if(!(etc&IsBlock)) pg.bks.mny=0;
810: if(!(etc&IsTxtln)) pg.ls.mny=0;
811: if(!(etc&IsWord)) pg.ws.mny=0;
812: if(!(etc&IsChar)) pg.cs.mny=0;
813: if(!(etc&IsBlob)) pg.bs.mny=0;
814: pp = &pg; /* write modified record */
815: };
816: if(etc&IsPage) fwrb_page(fp,pp);
817: fwrb_blocks_etc(fp,pp->bks,etc);
818: fwrb_txtlns_etc(fp,pp->ls,etc);
819: fwrb_words_etc(fp,pp->ws,etc);
820: fwrb_chars_etc(fp,pp->cs,etc);
821: fwrb_blobs_etc(fp,pp->bs,etc);
822: }
823:
824: #if FRDI
825: /* read a Page record (only) - it must be next in the file;
826: don't immediately read its parts; return 0 iff immediate EOF */
827: int frdb_page(f,p)
828: FILE *f;
829: Page *p;
830: { char *pfc; /* for debugging */
831: int stat;
832: switch(skip_type(f)) {
833: case 1: /* "TYPE=" header */
834: skip_doc(f);
835: break;
836: case 0: /* immediate EOF */
837: return(0);
838: break;
839: case -1: /* no "TYPE=" header */
840: break;
841: case -2: /* garbled "TYPE=" header */
842: abort("frdb_page: garbled \"TYPE=\" header");
843: break;
844: };
845: *p = empty_Page;
846: if(feof(f))
847: return(0);
848: p->ident=frdi_Ident(f);
849: frdi_Bbx(f,&(p->bx));
850: p->res_x=frdi_int2(f);
851: p->res_y=frdi_int2(f);
852: p->skew=frdi_Radians(f);
853: p->shear=frdi_Radians(f);
854: p->bks.mny=frdi_uint2(f);
855: p->ls.mny=frdi_uint2(f);
856: p->ws.mny=frdi_uint2(f);
857: p->cs.mny=frdi_uint2(f);
858: p->bs.mny=frdi_uint3(f);
859: #if dbg_frdb
860: if((!(p->ident&IsPage))||(p->ident&(IsALL&(~IsPage))))
861: err("frdb_page: %s",page_toa(p));
862: #endif
863: #if dbg_frdb_toa
864: err("frdb_page: %s",page_toa(p));
865: #endif
866: if(p->ident&Page_label) p->l = frdb_label(f);
867: if(ferror(f)) return(-errno); else return(1);
868: }
869: #else
870: /* read a Page record (only) - it must be next in the file;
871: don't immediately read its parts; return T iff not early EOF */
872: int frdb_page(fp,pp)
873: FILE *fp;
874: Page *pp;
875: { PageF pf;
876: char *pfc; /* for debugging */
877: int stat;
878: if((stat=skip_type(fp))!=1 /* "TYPE=" header */
879: && stat!=-1 /* no "TYPE=" header */ ) {
880: /* premature EOF or error */ return(stat);
881: };
882: if((stat=fread(&pf,sizeof(PageF),1,fp))!=1)
883: /* premature EOF*/ return(stat);
884: pfc = (char *)&pf;
885: *pp = empty_Page;
886: pp->ident=pf.ident;
887: pp->res_x=pf.res_x;
888: pp->res_y=pf.res_y;
889: pp->bx=pf.bx;
890: pp->skew=pf.skew;
891: pp->shear=pf.shear;
892: pp->bks.mny = pf.bkmny; pp->bks.bpa=NULL;
893: pp->ls.mny = pf.lmny; pp->ls.lpa=NULL;
894: pp->ws.mny = pf.wmny; pp->ws.wpa=NULL;
895: pp->cs.mny = pf.cmny; pp->cs.cpa=NULL;
896: pp->bs.mny = pf.bmny; pp->bs.bpa=NULL;
897: #if dbg_frdb_toa
898: err("frdb_page: %s",page_toa(pp));
899: #endif
900: if(pp->ident&Page_label) pp->l = frdb_label(fp);
901: #if dbg_frdb
902: if((!(pp->ident&IsPage))||(pp->ident&(IsALL&(~IsPage))))
903: err("frdb_page: %s",page_toa(pp));
904: #endif
905: return(stat);
906: }
907: #endif
908:
909: /* Read a page and selected parts */
910: int frdb_page_etc(fp,pp,etc)
911: FILE *fp;
912: Page *pp;
913: Ident etc;
914: { int stat;
915: if((etc&IsALL)==IsALL) {
916: long here;
917: /* In order to minimize malloc time to read an often huge file,
918: malloc and then free storage roughly equal to what's needed */
919: if( /* DEFEATED */ F && (here=ftell(fp))>=0 && fseek(fp,0,2)>=0 ) {
920: /* *fp is connected to a file, not a pipe */
921: free(malloc(ftell(fp)));
922: fseek(fp,here,0);
923: };
924: };
925: if((stat=frdb_page(fp,pp))!=1) return(stat);
926: if(etc&IsBlock && pp->bks.mny>0)
927: frdb_blocks_etc(fp,&(pp->bks),etc);
928: else pp->bks = empty_Blocks;
929: if(etc&IsTxtln && pp->ls.mny>0)
930: frdb_txtlns_etc(fp,&(pp->ls),etc);
931: else pp->ls = empty_Txtlns;
932: if(etc&IsWord && pp->ws.mny>0)
933: frdb_words_etc(fp,&(pp->ws),etc);
934: else pp->ws = empty_Words;
935: if(etc&IsChar && pp->cs.mny>0)
936: frdb_chars_etc(fp,&(pp->cs),etc);
937: else pp->cs = empty_Chars;
938: if(etc&IsBlob && pp->bs.mny>0)
939: frdb_blobs_etc(fp,&(pp->bs),etc);
940: else pp->bs = empty_Blobs;
941: return(1/*normal return*/);
942: }
943:
944: free_page_etc(p,etc)
945: Page *p;
946: Ident etc;
947: { free_blocks_etc(&(p->bks),etc);
948: free_txtlns_etc(&(p->ls),etc);
949: free_words_etc(&(p->ws),etc);
950: free_chars_etc(&(p->cs),etc);
951: free_blobs_etc(&(p->bs),etc);
952: if(p->ident&Page_label && p->l!=NULL) {
953: free(p->l); p->l=NULL; p->ident &= ~Page_label;
954: };
955: if(etc&IsPage) {
956: free(p);
957: free_census(Page,1);
958: };
959: }
960:
961: /* return a pointer to a distinct and duplicate copy of record Page *p,
962: created out of malloc space */
963: Page *dup_page(p)
964: Page *p;
965: { Page *dup;
966: dup=alloc_page(); *dup = *p; return(dup);
967: }
968:
969: /* Return a pointer to a distinct and duplicate copy of Page *p, and its parts
970: as specified by `etc', created out of malloc space. */
971: Page *dup_page_etc(p,etc)
972: Page *p;
973: Ident etc;
974: { Page *dup;
975: dup = dup_page(p);
976: if(etc&IsBlob&&dup->bs.mny>0) dup->bs = *dup_blobs_etc(&(p->bs),etc);
977: else dup->bs = empty_Blobs;
978: if(etc&IsChar&&dup->cs.mny>0) dup->cs = *dup_chars_etc(&(p->cs),etc);
979: else dup->cs = empty_Chars;
980: if(etc&IsWord&&dup->ws.mny>0) dup->ws = *dup_words_etc(&(p->ws),etc);
981: else dup->ws = empty_Words;
982: if(etc&IsTxtln&&dup->ls.mny>0) dup->ls = *dup_txtlns_etc(&(p->ls),etc);
983: else dup->ls = empty_Txtlns;
984: if(etc&IsBlock&&dup->bks.mny>0) dup->bks = *dup_blocks_etc(&(p->bks),etc);
985: else dup->bks = empty_Blocks;
986: return(dup);
987: }
988:
989: Block *alloc_block()
990: { Block *p;
991: if((p=(Block *)malloc(sizeof(Block)))==NULL)
992: abort("alloc_block: can't malloc");
993: alloc_census(Block,1);
994: *p = empty_Block;
995: return(p);
996: }
997:
998: char *block_toa(p)
999: Block *p;
1000: { static char s[80];
1001: sprintf(s,"%s bx%s sk%0.2f,sh%0.2f wst%0.2f m%s bk%d l%d w%d c%d b%d",
1002: ident_toa(p->ident),
1003: bbx_toa(&(p->bx)),
1004: p->skew/DtoR,
1005: p->shear/DtoR,
1006: p->wst,
1007: merit_toa(p->m),
1008: p->bks.mny,p->ls.mny,p->ws.mny,p->cs.mny,p->bs.mny,
1009: (p->l!=NULL)? p->l: "");
1010: return(s);
1011: }
1012:
1013: #if FWRI
1014: fwrb_block(f,p)
1015: FILE *f;
1016: Block *p;
1017: { int stat;
1018: #if dbg_fwrb
1019: if((!(p->ident&IsBlock))||(p->ident&(IsALL&(~IsBlock))))
1020: err("fwrb_block: %s",block_toa(p));
1021: if(p->ident&Block_label && p->l==NULL) {
1022: err("fwrb_page: Block_label set but .l==NULL");
1023: p->ident &= ~Block_label;
1024: };
1025: #endif
1026: fwri_Ident(f,p->ident);
1027: fwri_Bbx(f,&(p->bx));
1028: fwri_Radians(f,p->skew);
1029: fwri_Radians(f,p->shear);
1030: fwri_Ems(f,p->wst);
1031: fwri_Merit(f,p->m);
1032: fwri_uint2(f,p->bks.mny);
1033: fwri_uint2(f,p->ls.mny);
1034: fwri_uint2(f,p->ws.mny);
1035: fwri_uint2(f,p->cs.mny);
1036: fwri_uint3(f,p->bs.mny);
1037: #if dbg_fwrb_toa
1038: err("fwrb_block: %s",block_toa(p));
1039: #endif
1040: if(p->ident&Block_label) fwrb_label(f,p->l);
1041: }
1042: #else
1043: fwrb_block(fp,bkp)
1044: FILE *fp;
1045: Block *bkp;
1046: { BlockF bf;
1047: int stat;
1048: #if dbg_fwrb
1049: if((!(bkp->ident&IsBlock))||(bkp->ident&(IsALL&(~IsBlock))))
1050: err("fwrb_block: %s",block_toa(bkp));
1051: #endif
1052: memset(&bf,'\0',sizeof(bf));
1053: bf.ident = bkp->ident;
1054: bf.bx = bkp->bx;
1055: bf.wst = bkp->wst;
1056: bf.skew = bkp->skew;
1057: bf.shear = bkp->shear;
1058: bf.lmny = bkp->ls.mny;
1059: bf.wmny = bkp->ws.mny;
1060: bf.cmny = bkp->cs.mny;
1061: bf.bmny = bkp->bs.mny;
1062: #if dbg_fwrb_toa
1063: err("fwrb_block: %s",block_toa(bkp));
1064: #endif
1065: if((stat=fwrite(&bf,sizeof(BlockF),1,fp))!=1)
1066: abort("fwrb_block: can't fwrite - status %d",stat);
1067: }
1068: #endif
1069:
1070: fwrb_blocks_etc(fp,bks,etc)
1071: FILE *fp;
1072: Blocks bks;
1073: Ident etc;
1074: { register Block *bkp,**bkpp;
1075: if(bks.mny>0) for(bkp= *(bkpp=bks.bpa); bkp!=NULL; bkp= *(++bkpp))
1076: fwrb_block_etc(fp,bkp,etc);
1077: }
1078:
1079: fwrb_block_etc(fp,bkp,etc)
1080: FILE *fp;
1081: Block *bkp;
1082: Ident etc;
1083: { static Ident parts = (IsTxtln|IsWord|IsChar|IsBlob);
1084: Block bk;
1085: if((etc&parts)!=parts) /* write selected parts */ {
1086: bk = *bkp;
1087: if(!(etc&IsTxtln)) bk.ls.mny=0;
1088: if(!(etc&IsWord)) bk.ws.mny=0;
1089: if(!(etc&IsChar)) bk.cs.mny=0;
1090: if(!(etc&IsBlob)) bk.bs.mny=0;
1091: bkp = &bk; /* write modified record */
1092: };
1093: fwrb_block(fp,bkp);
1094: fwrb_txtlns_etc(fp,bkp->ls,etc);
1095: fwrb_words_etc(fp,bkp->ws,etc);
1096: fwrb_chars_etc(fp,bkp->cs,etc);
1097: fwrb_blobs_etc(fp,bkp->bs,etc);
1098: }
1099:
1100: #if FRDI
1101: int frdb_block(f,p)
1102: FILE *f;
1103: Block *p;
1104: { *p = empty_Block;
1105: if(feof(f))
1106: return(0);
1107: p->ident=frdi_Ident(f);
1108: frdi_Bbx(f,&(p->bx));
1109: p->skew=frdi_Radians(f);
1110: p->shear=frdi_Radians(f);
1111: p->wst=frdi_Ems(f);
1112: p->m=frdi_Merit(f);
1113: p->bks.mny=frdi_uint2(f);
1114: p->ls.mny=frdi_uint2(f);
1115: p->ws.mny=frdi_uint2(f);
1116: p->cs.mny=frdi_uint2(f);
1117: p->bs.mny=frdi_uint3(f);
1118: #if dbg_frdb_toa
1119: err("frdb_block: %s",block_toa(p));
1120: #endif
1121: #if dbg_frdb
1122: if((!(p->ident&IsBlock))||(p->ident&(IsALL&(~IsBlock))))
1123: err("frdb_block: %s",block_toa(p));
1124: #endif
1125: if(p->ident&Block_label) p->l = frdb_label(f);
1126: if(ferror(f)) return(-errno); else return(1);
1127: }
1128: #else
1129: int frdb_block(fp,bkp)
1130: FILE *fp;
1131: Block *bkp;
1132: { BlockF bf;
1133: int stat;
1134: if((stat=fread(&bf,sizeof(BlockF),1,fp))!=1)
1135: abort("frdb_block: can't fread - status %d",stat);
1136: *bkp = empty_Block;
1137: bkp->ident = bf.ident;
1138: bkp->bx = bf.bx;
1139: bkp->skew = bf.skew;
1140: bkp->shear = bf.shear;
1141: bkp->wst = bf.wst;
1142: bkp->ls.mny = bf.lmny;
1143: bkp->ws.mny = bf.wmny;
1144: bkp->cs.mny = bf.cmny;
1145: bkp->bs.mny = bf.bmny;
1146: #if dbg_frdb
1147: if((!(bkp->ident&IsBlock))||(bkp->ident&(IsALL&(~IsBlock))))
1148: err("frdb_block: %s",block_toa(bkp));
1149: #endif
1150: #if dbg_frdb_toa
1151: err("frdb_block: %s",block_toa(bkp));
1152: #endif
1153: if(bkp->ident&Block_label) bkp->l = frdb_label(fp);
1154: if(ferror(fp)) return(-errno); else return(1);
1155: }
1156: #endif
1157:
1158: frdb_block_etc(fp,bkp,etc)
1159: FILE *fp;
1160: Block *bkp;
1161: Ident etc;
1162: { BlockF bf;
1163: int stat;
1164: frdb_block(fp,bkp);
1165: if(etc&IsTxtln && bkp->ls.mny>0)
1166: frdb_txtlns_etc(fp,&(bkp->ls),etc);
1167: else bkp->ls = empty_Txtlns;
1168: if(etc&IsWord && bkp->ws.mny>0)
1169: frdb_words_etc(fp,&(bkp->ws),etc);
1170: else bkp->ws = empty_Words;
1171: if(etc&IsChar && bkp->cs.mny>0)
1172: frdb_chars_etc(fp,&(bkp->cs),etc);
1173: else bkp->cs = empty_Chars;
1174: if(etc&IsBlob && bkp->bs.mny>0)
1175: frdb_blobs_etc(fp,&(bkp->bs),etc);
1176: else bkp->bs = empty_Blobs;
1177: if(ferror(fp)) return(-errno); else return(1);
1178: }
1179:
1180: /* read number of blocks, and their parts */
1181: frdb_blocks_etc(fp,bksp,etc)
1182: FILE *fp;
1183: Blocks *bksp;
1184: Ident etc;
1185: { int bi;
1186: register Block *bkp,**bkpp;
1187: if(bksp->mny<=0) {
1188: *bksp = empty_Blocks;
1189: return(1);
1190: };
1191:
1192: if((bkpp=bksp->bpa=(Block **)malloc((bksp->mny+1)*sizeof(Block *)))==NULL)
1193: abort("can't alloc Blocks.bpa array");
1194: for(bi=0; bi<bksp->mny; bi++) {
1195: *(bkpp++) = bkp = alloc_block();
1196: frdb_block_etc(fp,bkp,etc);
1197: };
1198: *bkpp = NULL;
1199: if(ferror(fp)) return(-errno); else return(1);
1200: }
1201:
1202: free_block_etc(p,etc)
1203: Block *p;
1204: Ident etc;
1205: { free_txtlns_etc(&(p->ls),etc);
1206: free_words_etc(&(p->ws),etc);
1207: free_chars_etc(&(p->cs),etc);
1208: free_blobs_etc(&(p->bs),etc);
1209: if(p->ident&Block_label && p->l!=NULL) {
1210: free(p->l); p->l=NULL; p->ident &= ~Block_label;
1211: };
1212: if(etc&IsBlock) {
1213: free(p);
1214: free_census(Block,1);
1215: };
1216: }
1217:
1218: /* Unconditionally free the malloc-space array of pointers, and empty the set.
1219: Don't free the records that it owned.
1220: */
1221: free_blocks(p)
1222: Blocks *p;
1223: { if(p->bpa!=NULL) { free(p->bpa); p->bpa = NULL; }
1224: p->mny = 0;
1225: }
1226:
1227: free_blocks_etc(p,etc)
1228: Blocks *p;
1229: Ident etc;
1230: { register Block *bkp,**bkpp;
1231: if(p->mny>0&&(etc&IsBlock))
1232: for(bkp= *(bkpp=p->bpa); bkp!=NULL; bkp= *(++bkpp))
1233: free_block_etc(bkp,etc);
1234: free_blocks(p);
1235: }
1236:
1237: /* return a pointer to a distinct and duplicate copy of *bkp,
1238: created out of malloc space */
1239: Block *dup_block(bkp)
1240: Block *bkp;
1241: { Block *dup;
1242: dup=alloc_block();
1243: *dup = *bkp;
1244: return(dup);
1245: }
1246:
1247: /* Return a pointer to a distinct and duplicate copy of *bkp, and its parts
1248: as specified by `etc', created out of malloc space. */
1249: Block *dup_block_etc(bkp,etc)
1250: Block *bkp;
1251: Ident etc;
1252: { Block *dup;
1253: dup = dup_block(bkp);
1254: if(etc&IsBlob&&dup->bs.mny>0) dup->bs = *dup_blobs_etc(&(bkp->bs),etc);
1255: else dup->bs = empty_Blobs;
1256: if(etc&IsChar&&dup->cs.mny>0) dup->cs = *dup_chars_etc(&(bkp->cs),etc);
1257: else dup->cs = empty_Chars;
1258: if(etc&IsWord&&dup->ws.mny>0) dup->ws = *dup_words_etc(&(bkp->ws),etc);
1259: else dup->ws = empty_Words;
1260: if(etc&IsTxtln&&dup->ls.mny>0) dup->ls = *dup_txtlns_etc(&(bkp->ls),etc);
1261: else dup->ls = empty_Txtlns;
1262: return(dup);
1263: }
1264:
1265: /* Return a pointer to a distinct local static duplicate of non-empty *bksp.
1266: Its bkpa array is created newly out of malloc space.
1267: If etc&IsBlock, all its Blocks are also duplicated,
1268: else the contents of bkpa point to the old unduplicated Blocks.
1269: */
1270: Blocks *dup_blocks_etc(bksp,etc)
1271: Blocks *bksp;
1272: Ident etc; /* parts to duplicate */
1273: { static Blocks dup;
1274: register Block **bkpp,**dpp;
1275: if((dup.mny = bksp->mny)<=0) dup = empty_Blocks;
1276: else { if((dup.bpa=(Block **)malloc((dup.mny+1)*sizeof(Block *)))==NULL)
1277: abort("can't dup bks.bpa");
1278: for(bkpp=bksp->bpa,dpp=dup.bpa; *bkpp!=NULL; bkpp++,dpp++) {
1279: if(etc&IsBlock) *dpp = dup_block_etc(*bkpp,etc);
1280: else *dpp = *bkpp;
1281: };
1282: *dpp = NULL;
1283: };
1284: return(&dup);
1285: }
1286:
1287: /* Append a block to the end of a blocks set.
1288: Return appended Block *. */
1289: Block *append_block(bkp,bksp)
1290: Block *bkp;
1291: Blocks *bksp;
1292: { register Block *rp,**rpp,**npp;
1293: if(bksp->mny==0) {
1294: if((bksp->bpa=(Block **)malloc(2*sizeof(Block *)))==NULL)
1295: abort("append_block: can't malloc bksp->bpa");
1296: }
1297: else { if((bksp->bpa=(Block **)realloc(
1298: bksp->bpa,
1299: (bksp->mny+2)*sizeof(Block *))
1300: )==NULL)
1301: abort("append_block: can't realloc bksp->bpa");
1302: };
1303: bksp->bpa[bksp->mny] = bkp;
1304: bksp->bpa[++bksp->mny] = NULL;
1305: return(bkp);
1306: }
1307:
1308: /* remove a block from a blocks set */
1309: remove_block(bkp,bksp)
1310: Block *bkp;
1311: Blocks *bksp;
1312: { register Block *rp,**rpp,**npp;
1313: if(bksp->mny==0) err("can't remove Block - Blocks empty");
1314: else { for(rp= *(rpp=bksp->bpa); rp!=NULL; rp= *(++rpp)) if(rp==bkp) break;
1315: if(rp==NULL) err("can't remove Block - not found");
1316: else { /* move later entries up */
1317: npp=rpp+1;
1318: do *(rpp++)= *(npp++); while ((*rpp)!=NULL);
1319: if((--(bksp->mny))==0) {free(bksp->bpa); bksp->bpa=NULL;};
1320: /* don't bother to realloc downwards */
1321: };
1322: };
1323: }
1324:
1325: ConstPitch *alloc_constpitch()
1326: { ConstPitch *p;
1327: if((p=(ConstPitch *)malloc(sizeof(ConstPitch)))==NULL)
1328: abort("can't alloc ConstPitch");
1329: else { *p = empty_ConstPitch;
1330: return(p);
1331: };
1332: }
1333:
1334: char *constpitch_toa(p)
1335: ConstPitch *p;
1336: { static char s[80];
1337: sprintf(s,"{w%.3f,o%d,r%.1f}",
1338: p->w,p->o,p->r);
1339: return(s);
1340: }
1341:
1342: free_constpitch(p)
1343: ConstPitch *p;
1344: { free(p);
1345: }
1346:
1347: Txtln *alloc_txtln()
1348: { Txtln *p;
1349: if((p=(Txtln *)malloc(sizeof(Txtln)))==NULL)
1350: abort("can't alloc Txtln");
1351: alloc_census(Txtln,1);
1352: *p = empty_Txtln;
1353: return(p);
1354: }
1355:
1356: char *txtln_toa(p)
1357: Txtln *p;
1358: { static char s[80];
1359: sprintf(s,"%s bx%s sz%s ba%d cw%s m%s l%d w%d c%d b%d %s",
1360: ident_toa(p->ident),
1361: bbx_toa(&(p->bx)),
1362: pts_toa(p->size),
1363: p->basl,
1364: /** proj omitted **/
1365: ((p->cp!=NULL)? constpitch_toa(p->cp): "0"),
1366: merit_toa(p->m),
1367: p->ls.mny,p->ws.mny,p->cs.mny,p->bs.mny,
1368: (p->l!=NULL)? p->l: "");
1369: return(s);
1370: }
1371:
1372: #if FWRI
1373: fwrb_txtln(f,p)
1374: FILE *f;
1375: Txtln *p;
1376: {
1377: #if dbg_fwrb
1378: if((!(p->ident&IsTxtln))||(p->ident&(IsALL&(~IsTxtln))))
1379: err("fwrb_txtln: %s",txtln_toa(p));
1380: if(p->ident&Txtln_label && p->l==NULL) {
1381: err("fwrb_page: Txtln_label set but .l==NULL");
1382: p->ident &= ~Txtln_label;
1383: };
1384: #endif
1385: fwri_Ident(f,p->ident);
1386: fwri_Bbx(f,&(p->bx));
1387: fwri_Pts(f,p->size);
1388: fwri_Scoor(f,p->basl);
1389: /* fwri_?(f,p->proj); */
1390: /* fwri_ConstPitch(f,p->cp); */
1391: fwri_Merit(f,p->m);
1392: fwri_uint2(f,p->ls.mny);
1393: fwri_uint2(f,p->ws.mny);
1394: fwri_uint2(f,p->cs.mny);
1395: fwri_uint3(f,p->bs.mny);
1396: #if dbg_fwrb_toa
1397: err("fwrb_txtln: %s",txtln_toa(p));
1398: #endif
1399: if(p->ident&Txtln_label) fwrb_label(f,p->l);
1400: }
1401: #else
1402: fwrb_txtln(fp,lp)
1403: FILE *fp;
1404: Txtln *lp;
1405: { TxtlnF lf;
1406: int stat;
1407: #if dbg_fwrb
1408: if((!(lp->ident&IsTxtln))||(lp->ident&(IsALL&(~IsTxtln))))
1409: err("fwrb_txtln: %s",txtln_toa(lp));
1410: #endif
1411: memset(&lf,'\0',sizeof(lf));
1412: lf.ident = lp->ident;
1413: lf.bx = lp->bx;
1414: lf.basl = lp->basl;
1415: lf.size = lp->size;
1416: if(lp->proj!=NULL) lf.pmny = lp->bx.b.y - lp->bx.a.y + 1;
1417: else lf.pmny = 0;
1418: /* ignore lp->cp for now */
1419: lf.wmny = lp->ws.mny;
1420: lf.cmny = lp->cs.mny;
1421: lf.bmny = lp->bs.mny;
1422: if((stat=fwrite(&lf,sizeof(TxtlnF),1,fp))!=1)
1423: abort("can't write TxtlnF, status %d",stat);
1424: #if dbg_fwrb_toa
1425: err("fwrb_txtln: %s",txtln_toa(lp));
1426: #endif
1427: if(lf.ident&Txtln_label) fwrb_label(fp,lp->l);
1428: }
1429: #endif
1430:
1431: fwrb_txtlns_etc(fp,ls,etc)
1432: FILE *fp;
1433: Txtlns ls;
1434: Ident etc;
1435: { register Txtln *lp,**lpp;
1436: if(ls.mny>0) for(lp= *(lpp=ls.lpa); lp!=NULL; lp= *(++lpp))
1437: fwrb_txtln_etc(fp,lp,etc);
1438: }
1439:
1440: fwrb_txtln_etc(fp,lp,etc)
1441: FILE *fp;
1442: Txtln *lp;
1443: Ident etc;
1444: { static Ident parts = (IsWord|IsChar|IsBlob);
1445: Txtln tl;
1446: if((etc&parts)!=parts) /* write selected parts */ {
1447: tl = *lp;
1448: if(!(etc&IsWord)) tl.ws.mny=0;
1449: if(!(etc&IsChar)) tl.cs.mny=0;
1450: if(!(etc&IsBlob)) tl.bs.mny=0;
1451: lp = &tl; /* write modified record */
1452: };
1453: fwrb_txtln(fp,lp);
1454: if(lp->proj!=NULL) {/* write projection array someday */};
1455: fwrb_words_etc(fp,lp->ws,etc);
1456: fwrb_chars_etc(fp,lp->cs,etc);
1457: fwrb_blobs_etc(fp,lp->bs,etc);
1458: }
1459:
1460: #if FRDI
1461: int frdb_txtln(f,p)
1462: FILE *f;
1463: Txtln *p;
1464: { *p = empty_Txtln;
1465: if(feof(f))
1466: return(0);
1467: p->ident=frdi_Ident(f);
1468: frdi_Bbx(f,&(p->bx));
1469: p->size=frdi_Pts(f);
1470: p->basl=frdi_Scoor(f);
1471: /* p->proj=frdi_?(f); */
1472: /* p->cp=frdi_ConstPitch(f); */
1473: p->m=frdi_Merit(f);
1474: p->ls.mny=frdi_uint2(f);
1475: p->ws.mny=frdi_uint2(f);
1476: p->cs.mny=frdi_uint2(f);
1477: p->bs.mny=frdi_uint3(f);
1478: #if dbg_frdb
1479: if((!(p->ident&IsTxtln))||(p->ident&(IsALL&(~IsTxtln))))
1480: err("frdb_txtln: %s",txtln_toa(p));
1481: #endif
1482: #if dbg_frdb_toa
1483: err("frdb_txtln: %s",txtln_toa(p));
1484: #endif
1485: if(p->ident&Txtln_label) p->l = frdb_label(f);
1486: if(ferror(f)) return(-errno); else return(1);
1487: }
1488: #else
1489: int frdb_txtln(fp,lp)
1490: FILE *fp;
1491: Txtln *lp;
1492: { TxtlnF lf;
1493: int stat;
1494: if((stat=fread(&lf,sizeof(TxtlnF),1,fp))!=1)
1495: abort("can't read TxtlnF, status %d",stat);
1496: *lp = empty_Txtln;
1497: lp->ident = lf.ident;
1498: lp->bx = lf.bx;
1499: lp->basl = lf.basl;
1500: lp->size = lf.size;
1501: if(lf.pmny>0) lp->proj=(short *)malloc(lf.pmny);
1502: else lp->proj = NULL;
1503: lp->cp = NULL;
1504: lp->ws.mny = lf.wmny;
1505: lp->cs.mny = lf.cmny;
1506: lp->bs.mny = lf.bmny;
1507: #if dbg_frdb
1508: if((!(lp->ident&IsTxtln))||(lp->ident&(IsALL&(~IsTxtln))))
1509: err("frdb_txtln: %s",txtln_toa(lp));
1510: #endif
1511: #if dbg_frdb_toa
1512: err("frdb_txtln: %s",txtln_toa(lp));
1513: #endif
1514: if(lp->ident&Txtln_label) lp->l = frdb_label(fp);
1515: if(ferror(fp)) return(-errno); else return(1);
1516: }
1517: #endif
1518:
1519: frdb_txtln_etc(fp,lp,etc)
1520: FILE *fp;
1521: Txtln *lp;
1522: Ident etc;
1523: { TxtlnF lf;
1524: int stat;
1525: frdb_txtln(fp,lp);
1526: if(lp->proj!=NULL) {/* read projection array someday */};
1527: if(etc&IsWord && lp->ws.mny>0)
1528: frdb_words_etc(fp,&(lp->ws),etc);
1529: else lp->ws = empty_Words;
1530: if(etc&IsChar && lp->cs.mny>0)
1531: frdb_chars_etc(fp,&(lp->cs),etc);
1532: else lp->cs = empty_Chars;
1533: if(etc&IsBlob && lp->bs.mny>0)
1534: frdb_blobs_etc(fp,&(lp->bs),etc);
1535: else lp->bs = empty_Blobs;
1536: if(ferror(fp)) return(-errno); else return(1);
1537: }
1538:
1539: /* read number of txtlns, and parts */
1540: frdb_txtlns_etc(fp,lsp,etc)
1541: FILE *fp;
1542: Txtlns *lsp;
1543: Ident etc;
1544: { int li;
1545: register Txtln *lp,**lpp;
1546: if(lsp->mny<=0) {
1547: *lsp = empty_Txtlns;
1548: return(1);
1549: };
1550: if((lpp=lsp->lpa=(Txtln **)malloc((lsp->mny+1)*sizeof(Txtln *)))==NULL)
1551: abort("can't alloc Txtlns.lpa array");
1552: for(li=0; li<lsp->mny; li++) {
1553: *(lpp++) = lp = alloc_txtln();
1554: frdb_txtln_etc(fp,lp,etc);
1555: };
1556: *lpp = NULL;
1557: if(ferror(fp)) return(-errno); else return(1);
1558: }
1559:
1560: /* Append a txtln to the end of a txtlns set.
1561: Do NOT maintain Txtlns in order sorted ascending on Txtln.bx.a.y.
1562: Return appended Txtln *. */
1563: Txtln *append_txtln(lp,lsp)
1564: Txtln *lp;
1565: Txtlns *lsp;
1566: { register Txtln *rp,**rpp,**npp;
1567: if(lsp->mny==0) {
1568: if((lsp->lpa=(Txtln **)malloc(2*sizeof(Txtln *)))==NULL)
1569: abort("append_txtln: can't malloc lsp->lpa");
1570: }
1571: else { if((lsp->lpa=(Txtln **)realloc(
1572: lsp->lpa,
1573: (lsp->mny+2)*sizeof(Txtln *))
1574: )==NULL)
1575: abort("append_txtln: can't realloc lsp->lpa");
1576: };
1577: lsp->lpa[lsp->mny] = lp;
1578: lsp->lpa[++lsp->mny] = NULL;
1579: return(lp);
1580: }
1581:
1582: /* remove a txtln from a txtlns set */
1583: remove_txtln(lp,lsp)
1584: Txtln *lp;
1585: Txtlns *lsp;
1586: { register Txtln *rp,**rpp,**npp;
1587: if(lsp->mny==0) err("can't remove Txtln - Txtlns empty");
1588: else { for(rp= *(rpp=lsp->lpa); rp!=NULL; rp= *(++rpp)) if(rp==lp) break;
1589: if(rp==NULL) err("can't remove Txtln - not found");
1590: else { /* move later entries up */
1591: npp=rpp+1;
1592: do *(rpp++)= *(npp++); while ((*rpp)!=NULL);
1593: if((--(lsp->mny))==0) {free(lsp->lpa); lsp->lpa=NULL;};
1594: /* don't bother to realloc downwards */
1595: };
1596: };
1597: }
1598:
1599: free_txtln_etc(p,etc)
1600: Txtln *p;
1601: Ident etc;
1602: { free_words_etc(&(p->ws),etc);
1603: free_chars_etc(&(p->cs),etc);
1604: free_blobs_etc(&(p->bs),etc);
1605: if(p->ident&Txtln_label && p->l!=NULL) {
1606: free(p->l); p->l=NULL; p->ident &= ~Txtln_label;
1607: };
1608: if(etc&IsTxtln) {
1609: if(p->l!=NULL) free(p->l);
1610: free(p);
1611: free_census(Txtln,1);
1612: };
1613: }
1614:
1615: /* Unconditionally free the malloc-space array of pointers, and empty the set.
1616: Don't free the records that it owned.
1617: */
1618: free_txtlns(lsp)
1619: Txtlns *lsp;
1620: { if(lsp->lpa!=NULL) { free(lsp->lpa); lsp->lpa = NULL; }
1621: lsp->mny = 0;
1622: }
1623:
1624: free_txtlns_etc(lsp,etc)
1625: Txtlns *lsp;
1626: Ident etc;
1627: { register Txtln *lp,**lpp;
1628: if(lsp->mny>0&&(etc&IsTxtln))
1629: for(lp= *(lpp=lsp->lpa); lp!=NULL; lp= *(++lpp))
1630: free_txtln_etc(lp,etc);
1631: free_txtlns(lsp);
1632: }
1633:
1634: /* return a pointer to a distinct and duplicate copy of *lp,
1635: created out of malloc space */
1636: Txtln *dup_txtln(lp)
1637: Txtln *lp;
1638: { Txtln *dup;
1639: if((dup=(Txtln *)malloc(sizeof(Txtln)))==NULL)
1640: abort("can't dup Txtln");
1641: alloc_census(Txtln,1);
1642: *dup = *lp;
1643: return(dup);
1644: }
1645:
1646: /* Return a pointer to a distinct and duplicate copy of *lp, and its parts
1647: as specified by `etc', created out of malloc space. */
1648: Txtln *dup_txtln_etc(lp,etc)
1649: Txtln *lp;
1650: Ident etc;
1651: { Txtln *dup;
1652: dup = dup_txtln(lp);
1653: if(etc&IsBlob&&dup->bs.mny>0) dup->bs = *dup_blobs_etc(&(lp->bs),etc);
1654: else dup->bs = empty_Blobs;
1655: if(etc&IsChar&&dup->cs.mny>0) dup->cs = *dup_chars_etc(&(lp->cs),etc);
1656: else dup->cs = empty_Chars;
1657: if(etc&IsWord&&dup->ws.mny>0) dup->ws = *dup_words_etc(&(lp->ws),etc);
1658: else dup->ws = empty_Words;
1659: return(dup);
1660: }
1661:
1662: /* Return a pointer to a distinct local static duplicate of non-empty *lsp.
1663: Its lpa array is created newly out of malloc space.
1664: If etc&IsTxtln, all its Txtlns are also duplicated,
1665: else the contents of lpa point to the old unduplicated Txtlns.
1666: */
1667: Txtlns *dup_txtlns_etc(lsp,etc)
1668: Txtlns *lsp;
1669: Ident etc; /* parts to duplicate */
1670: { static Txtlns dup;
1671: register Txtln **lpp,**dpp;
1672: if((dup.mny = lsp->mny)<=0) dup = empty_Txtlns;
1673: else { if((dup.lpa=(Txtln **)malloc((dup.mny+1)*sizeof(Txtln *)))==NULL)
1674: abort("can't dup ls.lpa");
1675: for(lpp=lsp->lpa,dpp=dup.lpa; *lpp!=NULL; lpp++,dpp++) {
1676: if(etc&IsTxtln) *dpp = dup_txtln_etc(*lpp,etc);
1677: else *dpp = *lpp;
1678: };
1679: *dpp = NULL;
1680: };
1681: return(&dup);
1682: }
1683:
1684: Word *alloc_word()
1685: { Word *p;
1686: if((p=(Word *)malloc(sizeof(Word)))==NULL)
1687: abort("can't alloc Word");
1688: alloc_census(Word,1);
1689: *p = empty_Word;
1690: return(p);
1691: }
1692:
1693: char *word_toa(p)
1694: Word *p;
1695: { static char s[80];
1696: sprintf(s,"%s bx%s ws%0.2f c%d b%d m%s w%d",
1697: ident_toa(p->ident),
1698: bbx_toa(&(p->bx)),
1699: p->wsp,
1700: p->cs.mny,p->bs.mny,merit_toa(p->m),p->ws.mny);
1701: return(s);
1702: }
1703:
1704: /* Are two Words identical? A not quite exhaustively-detailed test. */
1705: boolean eq_word(w1,w2)
1706: Word *w1,*w2;
1707: { register Char **c1,**c2;
1708: if(w1->cs.mny!=w2->cs.mny) return(F);
1709: for(c1=w1->cs.cpa,c2=w2->cs.cpa; *c1!=NULL; c1++,c2++) {
1710: if((*c1)->area!=(*c2)->area) return(F);
1711: if(!bbx_eq(&((*c1)->bx),&((*c2)->bx))) return(F);
1712: if((*c1)->bmny!=(*c2)->bmny) return(F);
1713: };
1714: /* don't bother to compare Blob lists in detail (they aren't
1715: in any particular order). */
1716: return(T);
1717: }
1718:
1719: /* Compute a hash key for this Word that is likely to indicate whether or
1720: not it is geometrically identical to another Word. */
1721: int hash_word(w)
1722: Word *w;
1723: { register int k;
1724: register Char **c;
1725: if(w->cs.mny==0) return(0);
1726: k = w->bx.a.x * w->bx.a.y * w->bx.b.x * w->bx.b.y;
1727: for(c=w->cs.cpa; (*c)!=NULL; c++) {
1728: k += (*c)->bx.a.x * (*c)->bx.a.y * (*c)->bx.b.x
1729: * (*c)->bx.b.y * (*c)->bmny * (*c)->area;
1730: };
1731: return(k);
1732: }
1733:
1734: #if FWRI
1735: fwrb_word(f,p)
1736: FILE *f;
1737: Word *p;
1738: {
1739: #if dbg_fwrb
1740: if((!(p->ident&IsWord))||(p->ident&(IsALL&(~IsWord))))
1741: err("fwrb_word: %s",word_toa(p));
1742: if(p->ident&Word_label && p->l==NULL) {
1743: err("fwrb_page: Word_label set but .l==NULL");
1744: p->ident &= ~Word_label;
1745: };
1746: #endif
1747: fwri_Ident(f,p->ident);
1748: fwri_Bbx(f,&(p->bx));
1749: fwri_int2(f,p->wsp*UCHAR_MAX);
1750: fwri_Merit(f,p->m);
1751: fwri_Prob(f,p->p);
1752: fwri_uint2(f,p->ws.mny);
1753: fwri_uint2(f,p->cs.mny);
1754: fwri_uint3(f,p->bs.mny);
1755: /* fwri_int4(f,p->hash); */
1756: #if dbg_fwrb_toa
1757: err("fwrb_word: %s",word_toa(p));
1758: #endif
1759: if(p->ident&Word_label) fwrb_label(f,p->l);
1760: }
1761: #else
1762: fwrb_word(fp,wp)
1763: FILE *fp;
1764: Word *wp;
1765: { WordF wf;
1766: int stat;
1767: #if dbg_fwrb
1768: if((!(wp->ident&IsWord))||(wp->ident&(IsALL&(~IsWord))))
1769: err("fwrb_word: %s",word_toa(wp));
1770: #endif
1771: memset(&wf,'\0',sizeof(wf));
1772: wf.ident = wp->ident;
1773: wf.bx = wp->bx;
1774: wf.wsp = wp->wsp;
1775: wf.m = wp->m;
1776: wf.wmny = wp->ws.mny;
1777: wf.cmny = wp->cs.mny;
1778: wf.bmny = wp->bs.mny;
1779: if((stat=fwrite(&wf,sizeof(WordF),1,fp))!=1)
1780: abort("can't write WordF, status %d",stat);
1781: #if dbg_fwrb_toa
1782: err("fwrb_word: %s",word_toa(wp));
1783: #endif
1784: if(wf.ident&Word_label) fwrb_label(fp,wp->l);
1785: }
1786: #endif
1787:
1788: fwrb_words_etc(fp,ws,etc)
1789: FILE *fp;
1790: Words ws;
1791: Ident etc;
1792: { register Word *wp,**wpp;
1793: if(ws.mny>0) for(wp= *(wpp=ws.wpa); wp!=NULL; wp= *(++wpp))
1794: fwrb_word_etc(fp,wp,etc);
1795: }
1796:
1797: fwrb_word_etc(fp,wp,etc)
1798: FILE *fp;
1799: Word *wp;
1800: Ident etc;
1801: { static Ident parts = (IsWord|IsChar|IsBlob);
1802: Word wd;
1803: if((etc&parts)!=parts) /* write selected parts */ {
1804: wd = *wp;
1805: if(!(etc&IsWord)) wd.ws.mny=0;
1806: if(!(etc&IsChar)) wd.cs.mny=0;
1807: if(!(etc&IsBlob)) wd.bs.mny=0;
1808: wp = &wd; /* write modified record */
1809: };
1810: fwrb_word(fp,wp);
1811: if(etc&IsWord) fwrb_words_etc(fp,wp->ws,IsALL);
1812: fwrb_chars_etc(fp,wp->cs,etc);
1813: fwrb_blobs_etc(fp,wp->bs,etc);
1814: }
1815:
1816: #if FRDI
1817: int frdb_word(f,p)
1818: FILE *f;
1819: Word *p;
1820: { *p = empty_Word;
1821: if(feof(f))
1822: return(0);
1823: p->ident=frdi_Ident(f);
1824: frdi_Bbx(f,&(p->bx));
1825: p->wsp=frdi_int2(f)/(float)UCHAR_MAX;
1826: p->m=frdi_Merit(f);
1827: p->p=frdi_Prob(f);
1828: p->ws.mny=frdi_uint2(f);
1829: p->cs.mny=frdi_uint2(f);
1830: p->bs.mny=frdi_uint3(f);
1831: /* p->hash=frdi_int4(f); */
1832: #if dbg_frdb
1833: if((!(p->ident&IsWord))||(p->ident&(IsALL&(~IsWord))))
1834: err("frdb_word: %s",word_toa(p));
1835: #endif
1836: #if dbg_frdb_toa
1837: err("frdb_word: %s",word_toa(p));
1838: #endif
1839: if(p->ident&Word_label) p->l = frdb_label(f);
1840: if(ferror(f)) return(-errno); else return(1);
1841: }
1842: #else
1843: int frdb_word(fp,wp)
1844: FILE *fp;
1845: Word *wp;
1846: { WordF wf;
1847: int stat;
1848: if((stat=fread(&wf,sizeof(WordF),1,fp))!=1)
1849: abort("can't read WordF, status %d",stat);
1850: *wp = empty_Word;
1851: wp->ident = wf.ident;
1852: wp->bx = wf.bx;
1853: wp->wsp = wf.wsp;
1854: wp->m = wf.m;
1855: wp->ws.mny = wf.wmny;
1856: wp->cs.mny = wf.cmny;
1857: wp->bs.mny = wf.bmny;
1858: #if dbg_frdb
1859: if((!(wp->ident&IsWord))||(wp->ident&(IsALL&(~IsWord))))
1860: err("frdb_word: %s",word_toa(wp));
1861: #endif
1862: #if dbg_frdb_toa
1863: err("frdb_word: %s",word_toa(wp));
1864: #endif
1865: if(wp->ident&Word_label) wp->l = frdb_label(fp);
1866: if(ferror(fp)) return(-errno); else return(1);
1867: }
1868: #endif
1869:
1870: frdb_word_etc(fp,wp,etc)
1871: FILE *fp;
1872: Word *wp;
1873: Ident etc;
1874: { WordF cf;
1875: int stat;
1876: frdb_word(fp,wp);
1877: frdb_words_etc(fp,&(wp->ws),IsALL); /* rd alternatives entirely, if any */
1878: if(etc&IsChar && wp->cs.mny>0)
1879: frdb_chars_etc(fp,&(wp->cs),etc);
1880: else wp->cs = empty_Chars;
1881: if(etc&IsBlob && wp->bs.mny>0)
1882: frdb_blobs_etc(fp,&(wp->bs),etc);
1883: else wp->bs = empty_Blobs;
1884: if(ferror(fp)) return(-errno); else return(1);
1885: }
1886:
1887: /* read words, and their parts */
1888: frdb_words_etc(fp,wsp,etc)
1889: FILE *fp;
1890: Words *wsp;
1891: Ident etc;
1892: { int wi;
1893: register Word *wp,**wpp;
1894: if(wsp->mny<=0) {
1895: *wsp = empty_Words;
1896: return(1);
1897: };
1898: if((wpp=wsp->wpa=(Word **)malloc((wsp->mny+1)*sizeof(Word *)))==NULL)
1899: abort("can't alloc Words.wpa array");
1900: for(wi=0; wi<wsp->mny; wi++) {
1901: *(wpp++) = wp = alloc_word();
1902: frdb_word_etc(fp,wp,etc);
1903: };
1904: *wpp = NULL;
1905: if(ferror(fp)) return(-errno); else return(1);
1906: }
1907:
1908: /* remove a word from a words set */
1909: remove_word(wp,wsp)
1910: Word *wp;
1911: Words *wsp;
1912: { register Word *rp,**rpp,**npp;
1913: if(wsp->mny==0) err("can't remove Word - Words empty");
1914: else { for(rp= *(rpp=wsp->wpa); rp!=NULL; rp= *(++rpp)) if(rp==wp) break;
1915: if(rp==NULL) err("can't remove Word - not found");
1916: else { /* move later entries up */
1917: npp=rpp+1;
1918: do *(rpp++)= *(npp++); while ((*rpp)!=NULL);
1919: if((--(wsp->mny))==0) {free(wsp->wpa); wsp->wpa=NULL;};
1920: /* don't bother to realloc downwards */
1921: };
1922: };
1923: }
1924:
1925: /* Remove a Word from a Txtln's Words set.
1926: Shrink the Txtln's Bbx if the Word abuts it on the left or right.
1927: Ensure that the first Word in the line has wsp==0.0
1928: BUG: doesn't update wsp of trailing Word */
1929: remove_word_txtln(wp,lp)
1930: Word *wp;
1931: Txtln *lp;
1932: { register Word *cwp,**wpp;
1933: remove_word(wp,&(lp->ws));
1934: if(lp->ws.mny>0) {
1935: if(wp->bx.a.x==lp->bx.a.x || wp->bx.b.x==lp->bx.b.x) {
1936: /* recompute possibly shrunken bx */
1937: lp->bx=empty_Bbx;
1938: for(cwp= *(wpp=lp->ws.wpa); cwp!=NULL; cwp= *(++wpp))
1939: merge_bbx(&(cwp->bx),&(lp->bx));
1940: };
1941: (lp->ws.wpa[0])->wsp=0.0;
1942: };
1943: }
1944:
1945: /* Append a word to the end of a words set.
1946: Do NOT maintain set in order ascending on Word.bx.a.x.
1947: Return the appended Word. */
1948: Word *append_word(wp,wsp)
1949: Word *wp;
1950: Words *wsp;
1951: { if(wsp->mny==0) {
1952: if((wsp->wpa=(Word **)malloc(2*sizeof(Word *)))==NULL)
1953: abort("append_word: can't malloc wsp->wpa");
1954: }
1955: else { if((wsp->wpa=(Word **)realloc(
1956: wsp->wpa,
1957: (wsp->mny+2)*sizeof(Word *))
1958: )==NULL)
1959: abort("append_word: can't realloc wsp->wpa");
1960: };
1961: wsp->wpa[wsp->mny++] = wp;
1962: wsp->wpa[wsp->mny] = NULL;
1963: return(wp);
1964: }
1965:
1966: /* Insert a Word into a Words set. Words is assumed to be sorted ascending
1967: on Word.bx.a.x, and this order is maintained.
1968: Words with equal Word.bx.a.x are stored in the order that they were
1969: inserted: so that the first one inserted remains the first among equals
1970: (this feature is important for certain WordSet applications).
1971: Return inserted (Word *) */
1972: Word *insert_word(wp,wsp)
1973: Word *wp;
1974: Words *wsp;
1975: { register Word **wpp,*nwp,*pwp;
1976: if(wsp->mny==0) {
1977: if((wsp->wpa=(Word **)malloc(2*sizeof(Word *)))==NULL)
1978: abort("insert_word: can't malloc wsp->wpa");
1979: wsp->wpa[wsp->mny] = wp;
1980: }
1981: else { if((wpp=wsp->wpa=(Word **)realloc(
1982: wsp->wpa,
1983: (wsp->mny+2)*sizeof(Word *))
1984: )==NULL)
1985: abort("insert_word: can't realloc wsp->wpa");
1986: while(((*wpp)!=NULL)&&(*wpp)->bx.a.x<=wp->bx.a.x) wpp++;
1987: /* **wpp is now 1st entry > *wp in sorted order; insert
1988: new word just before it */
1989: pwp=wp;
1990: do { nwp= *wpp;
1991: *(wpp++)=pwp;
1992: pwp=nwp;
1993: }
1994: while(pwp!=NULL);
1995: };
1996: wsp->wpa[++wsp->mny] = NULL;
1997: return(wp);
1998: }
1999:
2000: /* Insert a Word into the Words owned by a given Txtln,
2001: maintaining the Txtln's Bbx and sorted order in the Words set.
2002: Return the inserted Word * */
2003: Word *insert_word_txtln(wp,lp)
2004: Word *wp;
2005: Txtln *lp;
2006: { merge_bbx(&(wp->bx),&(lp->bx));
2007: return(insert_word(wp,&(lp->ws)));
2008: }
2009:
2010: /* Free wordinterp and its parts as specified in etc.
2011: Always free its strings (if any).
2012: If etc&IsWordInterp, free the record itself also.
2013: */
2014: free_wordinterp_etc(p,etc)
2015: WordInterp *p;
2016: Ident etc;
2017: { if(p->s!=NULL) { free(p->s); p->s=NULL; };
2018: if(p->pp!=NULL) { free(p->pp); p->pp=NULL; };
2019: if(p->by!=NULL) { free(p->by); p->by=NULL; };
2020: if(p->po!=NULL) { free(p->po); p->po=NULL; };
2021: if(p->ps!=NULL) { free(p->ps); p->ps=NULL; };
2022: if(etc&IsWordInterp) free(p);
2023: }
2024:
2025: /* Duplicate (return ptr to local static copy of) a WordInterp.
2026: Always free its strings (if any).
2027: 'etc' is ignored.
2028: */
2029: WordInterp *dup_wordinterp_etc(p,etc)
2030: WordInterp *p;
2031: Ident etc;
2032: { static WordInterp d;
2033: d = *p;
2034: if(p->s!=NULL) d.s = strdup(p->s);
2035: if(p->pp!=NULL) d.pp = strdup(p->pp);
2036: if(p->by!=NULL) d.by = strdup(p->by);
2037: if(p->po!=NULL) d.po = strdup(p->po);
2038: if(p->ps!=NULL) d.ps = strdup(p->ps);
2039: return(&d);
2040: }
2041:
2042: /* Unconditionally free the malloc-space array of pointers, and empty the set.
2043: Don't free the records that it owned.
2044: */
2045: free_words(wsp)
2046: Words *wsp;
2047: { if(wsp->wpa!=NULL) { free(wsp->wpa); wsp->wpa = NULL; }
2048: wsp->mny = 0;
2049: }
2050:
2051: free_words_etc(wsp,etc)
2052: Words *wsp;
2053: Ident etc;
2054: { register Word *wp,**wpp;
2055: int wi;
2056: if(wsp->mny>0&&(etc&IsWord))
2057: for(wp= *(wpp=wsp->wpa); wp!=NULL; wp= *(++wpp))
2058: free_word_etc(wp,etc);
2059: free_words(wsp);
2060: }
2061:
2062: /* return a pointer to a distinct and duplicate copy of *wp,
2063: created out of malloc space */
2064: Word *dup_word(wp)
2065: Word *wp;
2066: { Word *dup;
2067: if((dup=(Word *)malloc(sizeof(Word)))==NULL)
2068: abort("can't dup Word");
2069: alloc_census(Word,1);
2070: *dup = *wp;
2071: return(dup);
2072: }
2073:
2074: /* Return a pointer to a distinct and duplicate copy of *wp, and ALL it owns,
2075: created out of malloc space. (HOW they are duplicated is controlled by flags
2076: in etc.) */
2077: Word *dup_word_etc(wp,etc)
2078: Word *wp;
2079: Ident etc;
2080: { Word *dup;
2081: dup = dup_word(wp);
2082: if(dup->ws.mny>0) dup->ws = *dup_words_etc(&(wp->ws),etc);
2083: else dup->ws = empty_Words;
2084: if(dup->cs.mny>0) dup->cs = *dup_chars_etc(&(wp->cs),etc);
2085: else dup->cs = empty_Chars;
2086: if(dup->bs.mny>0) dup->bs = *dup_blobs_etc(&(wp->bs),etc);
2087: else dup->bs = empty_Blobs;
2088: return(dup);
2089: }
2090:
2091: /* Return a pointer to a distinct local static duplicate of non-empty *wsp.
2092: Its wpa array is created newly out of malloc space.
2093: If etc&IsWord, all its Words are also duplicated,
2094: else the contents of wpa point to the old unduplicated Words.
2095: */
2096: Words *dup_words_etc(wsp,etc)
2097: Words *wsp;
2098: Ident etc; /* parts to duplicate */
2099: { static Words dup;
2100: register Word **wpp,**dpp;
2101: if((dup.mny=wsp->mny)<=0) dup = empty_Words;
2102: else { if((dup.wpa=(Word **)malloc((dup.mny+1)*sizeof(Word *)))==NULL)
2103: abort("can't dup ws.wpa");
2104: for(wpp=wsp->wpa,dpp=dup.wpa; *wpp!=NULL; wpp++,dpp++) {
2105: if(etc&IsWord) *dpp = dup_word_etc(*wpp,etc);
2106: else *dpp = *wpp;
2107: };
2108: *dpp = NULL;
2109: };
2110: return(&dup);
2111: }
2112:
2113: WordInterp *alloc_wordinterp()
2114: { WordInterp *p;
2115: if((p=(WordInterp *)malloc(sizeof(WordInterp)))==NULL)
2116: abort("can't alloc WordInterp");
2117: else { *p = empty_WordInterp;
2118: return(p);
2119: };
2120: }
2121:
2122: char *wordinterp_toa(p)
2123: WordInterp *p;
2124: { static char s[80];
2125: sprintf(s,"%s %s %s|%s|%s|%s",
2126: ident_toa(p->ident),
2127: ((p->s!=NULL)? p->s: ""),
2128: ((p->pp!=NULL)? p->pp: ""),
2129: ((p->by!=NULL)? p->by: ""),
2130: ((p->po!=NULL)? p->po: ""),
2131: ((p->ps!=NULL)? p->ps: "")
2132: );
2133: return(s);
2134: }
2135:
2136: /* Free Word and its parts, as specified by etc.
2137: Always free the pointer-arrays of ws, cs & bs.
2138: If etc&IsWord, free all Words in ws also.
2139: If etc&IsChar, free all Chars in cs also.
2140: If etc&IsBlob, free all Blobs in bs also.
2141: */
2142: free_word_etc(p,etc)
2143: Word *p;
2144: Ident etc;
2145: #define dbg_fwe (F)
2146: { if(dbg_fwe) {
2147: err("free_word_etc: %s",word_toa(p));
2148: err("free_word_etc: %s",ident_toa(etc));
2149: err_census_all;
2150: };
2151: free_words_etc(&(p->ws),IsALL);
2152: free_chars_etc(&(p->cs),etc);
2153: free_blobs_etc(&(p->bs),etc);
2154: if(p->ident&Word_label && p->l!=NULL) {
2155: free(p->l); p->l=NULL; p->ident &= ~Word_label;
2156: };
2157: if(etc&IsWord) free_word(p);
2158: if(dbg_fwe) err_census_all;
2159: }
2160:
2161: free_word(wp)
2162: Word *wp;
2163: { free(wp);
2164: free_census(Word,1);
2165: }
2166:
2167: fwrb_sfeats(fp,sfv)
2168: FILE *fp;
2169: SFv sfv;
2170: { register Pval *vp,*vq;
2171: for(vq=(vp=sfv)+SF_MNY; vp<vq; vp++)
2172: fwri_int3(fp,USHRT_MAX*(*vp)+0.5);
2173: #if dbg_fwrb_toa
2174: /** err("fwrb_sfeats: %s",sfeats_toa(sfv)); **/
2175: #endif
2176: }
2177:
2178: int frdb_sfeats(fp,sfv)
2179: FILE *fp;
2180: SFv sfv;
2181: { register Pval *vp,*vq;
2182: for(vq=(vp=sfv)+SF_MNY; vp<vq; vp++)
2183: *vp = frdi_int3(fp)/((Pval)USHRT_MAX);
2184: #if dbg_frdb_toa
2185: /** err("frdb_sfeats: %s",sfeats_toa(sfv)); **/
2186: #endif
2187: }
2188:
2189: /* return ptr to local static copy of Shapes of given size */
2190: Shapes *alloc_shapes(mny)
2191: int mny;
2192: { static Shapes shs;
2193: shs.mny = shs.alloc = mny;
2194: if((shs.sa=(Nb_s *)malloc(shs.alloc*sizeof(Nb_s)))==NULL)
2195: abort("can't alloc Shapes.sa[%d]",shs.alloc);
2196: return(&shs);
2197: }
2198:
2199: fwrb_shapes(fp,p)
2200: FILE *fp;
2201: Shapes *p; /* on entry, p->mny has already been written */
2202: { int dim;
2203: register Nb_s *sp,*sq;
2204: register Pval *vp;
2205: if(p->mny>0&&p->sa!=NULL) {
2206: for(sq=(sp=p->sa)+p->mny; sp<sq; sp++) {
2207: dim=Sh_dim[sp->t&(~Sh_tiny)];
2208: fwri_uint1(fp,(sp->t&0x7F)|((sp->t&Sh_tiny)?0x80:0x00));
2209: fwri_int2(fp,(*(vp=sp->p))*SHRT_MAX);
2210: if(dim>1) { fwri_int2(fp,(*(++vp))*SHRT_MAX);
2211: if(dim>2) { fwri_int2(fp,(*(++vp))*SHRT_MAX);
2212: if(dim>3) { fwri_int2(fp,(*(++vp))*SHRT_MAX);
2213: } } };
2214: };
2215: };
2216: #if dbg_fwrb_toa
2217: /** err("fwrb_shapes: %s",shapes_toa(p)); **/
2218: #endif
2219: }
2220:
2221: int frdb_shapes(fp,p)
2222: FILE *fp;
2223: Shapes *p; /* on entry, p->mny has already been read */
2224: { register Nb_s *sp,*sq;
2225: register Pval *vp;
2226: uint1 ui1;
2227: int dim;
2228:
2229: if(p->mny>0) {
2230: *p = *alloc_shapes(p->mny);
2231: for(sq=(sp=p->sa)+p->mny; sp<sq; sp++) {
2232: ui1 = frdi_uint1(fp);
2233: sp->t = ui1&0x7F|((ui1&0x80)?Sh_tiny:0);
2234: dim=Sh_dim[sp->t&(~Sh_tiny)];
2235: *(vp=sp->p) = ((float)frdi_int2(fp))/SHRT_MAX;
2236: if(dim>1) { *(++vp) = ((float)frdi_int2(fp))/SHRT_MAX;
2237: if(dim>2) { *(++vp) = ((float)frdi_int2(fp))/SHRT_MAX;
2238: if(dim>3) { *(++vp) = ((float)frdi_int2(fp))/SHRT_MAX;
2239: } } };
2240: };
2241: }
2242: else { p->alloc = 0;
2243: if(p->sa!=NULL) free(p->sa);
2244: p->sa = NULL;
2245: };
2246: #if dbg_frdb_toa
2247: /** err("frdb_shapes: %s",shapes_toa(p)); **/
2248: #endif
2249: }
2250:
2251: fwra_shapes_etc(fp,p,t)
2252: FILE *fp;
2253: Shapes *p;
2254: char *t; /* string of shape types (empty => all) */
2255: { Nb_s *s;
2256: int i,j;
2257: char a[80],f[10];
2258: for(i=0,s=p->sa; i<p->mny; i++,s++) {
2259: if(t[0]=='\0'||strchr(t,Sh_nam[s->t&(~Sh_tiny)])!=NULL) {
2260: sprintf(a,"%c%c ",
2261: Sh_nam[s->t&(~Sh_tiny)],
2262: (s->t&Sh_tiny)?'\'':' '
2263: );
2264: for(j=0;j<Sh_dim[s->t&(~Sh_tiny)];j++) {
2265: sprintf(f," %0.3f",s->p[j]);
2266: strcat(a,f);
2267: };
2268: fprintf(fp,"%s\n",a);
2269: };
2270: };
2271: }
2272:
2273: err_shapes(shp)
2274: Shapes *shp;
2275: { int si,di;
2276: Nb_s *sp;
2277: fprintf(stderr,"shapes %d:\n",shp->mny);
2278: for(si=0,sp=shp->sa; si<shp->mny; si++,sp++) {
2279: fprintf(stderr," %c",Sh_nam[sp->t]);
2280: for(di=0; di<Sh_dim[sp->t]; di++)
2281: fprintf(stderr," %6.3f",sp->p[di]);
2282: fprintf(stderr,"\n");
2283: };
2284: }
2285:
2286: /* Unconditionally free the malloc-space array of pointers, and empty the set.
2287: Don't free the records that it owned.
2288: */
2289: free_shapes(shp)
2290: Shapes *shp;
2291: { if(shp->sa!=NULL) {
2292: if(shp->alloc<=0) abort("can't free unalloc'ed shapes");
2293: else { free(shp->sa); shp->sa=NULL; };
2294: };
2295: shp->mny = shp->alloc = 0;
2296: }
2297:
2298: /* functions for RanParms */
2299:
2300: RanParms *alloc_ranparms()
2301: { RanParms *rp;
2302: if((rp=(RanParms *)malloc(sizeof(RanParms)))==NULL)
2303: abort("alloc_ranparms: can't alloc");
2304: *rp = empty_RanParms;
2305: return(rp);
2306: }
2307:
2308: free_ranparms(ran)
2309: RanParms *ran;
2310: { free(ran);
2311: }
2312:
2313: RanParms *dup_ranparms(p)
2314: RanParms *p;
2315: { RanParms *dup;
2316: dup = alloc_ranparms();
2317: *dup = *p;
2318: return(dup);
2319: }
2320:
2321: char *ranparms_toa(ran,select)
2322: RanParms *ran;
2323: char *select; /* a string, subset of: "*rpabejkstxy" if "*" or "" ALL */
2324: { static char s[200];
2325: char p[20];
2326: char *cp;
2327: static char select_all[] = "abejkprstxy";
2328: s[0]='\0';
2329: if(select[0]=='*'||select[0]=='\0') select=select_all;
2330: for(cp=select; *cp!='\0'; cp++) {
2331: switch(*cp) {
2332: case 'a': sprintf(p,"a%0.3f ",ran->skew/DtoR); strcat(s,p); break;
2333: case 'b': sprintf(p,"b%0.3f ",ran->bhgt); strcat(s,p); break;
2334: case 'e': sprintf(p,"e%0.3f ",ran->blur); strcat(s,p); break;
2335: case 'j': sprintf(p,"j%0.3f ",ran->jitter); strcat(s,p); break;
2336: case 'k': sprintf(p,"k%0.3f ",ran->kern); strcat(s,p); break;
2337: case 'p': sprintf(p,"p%g ",ran->size); strcat(s,p); break;
2338: case 'r': sprintf(p,"r%d,%d ",ran->res_x,ran->res_y); strcat(s,p); break;
2339: case 's': sprintf(p,"s%0.4f ",ran->speckle); strcat(s,p); break;
2340: case 't': sprintf(p,"t%0.3f ",ran->thresh); strcat(s,p); break;
2341: case 'x': sprintf(p,"x%0.3f ",ran->xscale); strcat(s,p); break;
2342: case 'y': sprintf(p,"y%0.3f ",ran->yscale); strcat(s,p); break;
2343: };
2344: };
2345: return(s);
2346: }
2347:
2348: RanParms *ato_ranparms(s)
2349: char *s;
2350: { static RanParms ran;
2351: char *f,n,*v;
2352: #define TOKEN_SEP "=, \n"
2353: f=strtok(s,TOKEN_SEP);
2354: while(f!=NULL&&strlen(f)>0) {
2355: n=f[0]; v=f+1;
2356: switch(n) {
2357: case 'r': /* res */
2358: ran.res_x = atoi(v);
2359: v=strtok((char *)0,TOKEN_SEP);
2360: ran.res_y = atoi(v);
2361: break;
2362: case 'p': ran.size = atof(v); break;
2363: case 'a': ran.skew = atof(v)*DtoR; break;
2364: case 'b': ran.bhgt = atof(v); break;
2365: case 'e': ran.blur = atof(v); break;
2366: case 'j': ran.jitter = atof(v); break;
2367: case 'k': ran.kern = atof(v); break;
2368: case 's': ran.speckle = atof(v); break;
2369: case 't': ran.thresh = atof(v); break;
2370: case 'x': ran.xscale = atof(v); break;
2371: case 'y': ran.yscale = atof(v); break;
2372: };
2373: f=strtok((char *)0,TOKEN_SEP);
2374: };
2375: return(&ran);
2376: }
2377:
2378: #if FWRI
2379: fwrb_ranparms(f,p)
2380: FILE *f;
2381: RanParms *p;
2382: { fwri_int2(f,p->res_x);
2383: fwri_int2(f,p->res_y);
2384: fwri_Pts(f,p->size);
2385: fwri_Radians(f,p->skew);
2386: fwri_Ems(f,p->bhgt);
2387: fwri_int3(f,p->blur*10000.0);
2388: fwri_int3(f,p->jitter*10000.0);
2389: fwri_int3(f,p->kern*10000.0);
2390: fwri_int3(f,p->speckle*10000.0);
2391: fwri_int3(f,p->thresh*10000.0);
2392: fwri_int3(f,p->xscale*10000.0);
2393: fwri_int3(f,p->yscale*10000.0);
2394: #if dbg_fwrb_toa
2395: err("fwrb_ranparms: %s",ranparms_toa(p));
2396: #endif
2397: }
2398: #else
2399: fwrb_ranparms(f,p)
2400: FILE *f;
2401: RanParms *p;
2402: { if((fwrite(p,sizeof(RanParms),1,f))!=1) return(0);
2403: #if dbg_fwrb_toa
2404: err("fwrb_ranparms: %s",ranparms_toa(p));
2405: #endif
2406: }
2407: #endif
2408:
2409: #if FRDI
2410: int frdb_ranparms(f,p)
2411: FILE *f;
2412: RanParms *p;
2413: { *p = empty_RanParms;
2414: if(feof(f))
2415: return(0);
2416: p->res_x=frdi_int2(f);
2417: p->res_y=frdi_int2(f);
2418: p->size=frdi_Pts(f);
2419: p->skew=frdi_Radians(f);
2420: p->bhgt=frdi_Ems(f);
2421: p->blur=frdi_int3(f)/10000.0;
2422: p->jitter=frdi_int3(f)/10000.0;
2423: p->kern=frdi_int3(f)/10000.0;
2424: p->speckle=frdi_int3(f)/10000.0;
2425: p->thresh=frdi_int3(f)/10000.0;
2426: p->xscale=frdi_int3(f)/10000.0;
2427: p->yscale=frdi_int3(f)/10000.0;
2428: #if dbg_frdb_toa
2429: err("frdb_ranparms: %s",ranparms_toa(p));
2430: #endif
2431: if(ferror(f)) return(-errno); else return(1);
2432: }
2433: #else
2434: int frdb_ranparms(fp,ran)
2435: FILE *fp;
2436: RanParms *ran;
2437: { if((fread(ran,sizeof(RanParms),1,fp))<1) return(0);
2438: #if dbg_frdb_toa
2439: err("frdb_ranparms: %s",ranparms_toa(ran));
2440: #endif
2441: }
2442: #endif
2443:
2444: Char *alloc_char()
2445: { Char *p;
2446: if((p=(Char *)malloc(sizeof(Char)))==NULL)
2447: abort("can't alloc Char");
2448: alloc_census(Char,1);
2449: *p = empty_Char;
2450: return(p);
2451: }
2452:
2453: char *char_toa(cp)
2454: Char *cp;
2455: { static char s[100],bfs[24];
2456: if(cp->bfsp==NULL) strcpy(bfs,"0");
2457: else if(cp->bfsp->bm.n==0) strcpy(bfs,"0");
2458: else if(cp->bfsp->bm.mny==0) sprintf(bfs,"%d",cp->bfsp->bm.n);
2459: else sprintf(bfs,"%d,%d",cp->bfsp->bm.n,cp->bfsp->bm.mny);
2460: sprintf(s,"%s bx%s w%d,h%d cs%d bl%d ar%d pe%d sf%d sh%d bf%s i%d",
2461: ident_toa(cp->ident),
2462: bbx_toa(&(cp->bx)),
2463: bbx_wid(&cp->bx),bbx_hgt(&cp->bx),
2464: cp->csp,
2465: cp->bmny,
2466: cp->area,cp->per,
2467: (cp->sfv==NULL)? 0: 1,
2468: cp->sh.mny,
2469: bfs,
2470: cp->il.mny
2471: );
2472: return(s);
2473: }
2474:
2475: /* compute the centroid of the Char (offset from bx.a) */
2476: Pp *char_centroid(cp)
2477: Char *cp;
2478: { static Pp c;
2479: Pp *bc; /* blob centroid */
2480: Blob *bp;
2481: int bi;
2482: c.x = c.y = 0.0;
2483: for(bi=0, bp=cp->fi; bi<cp->bmny; bi++, bp=bp->n) {
2484: bc = blob_centroid(bp);
2485: c.x += bp->area * (bc->x + (cp->bx.a.x - cp->bx.a.x));
2486: c.y += bp->area * (bc->y + (cp->bx.a.y - cp->bx.a.y));
2487: };
2488: c.x /= cp->area;
2489: c.y /= cp->area;
2490: return(&c);
2491: }
2492:
2493: #if FWRI
2494: fwrb_char(f,p)
2495: FILE *f;
2496: Char *p;
2497: {
2498: #if dbg_fwrb
2499: if((!(p->ident&IsChar))||(p->ident&(IsALL&(~IsChar))))
2500: err("fwrb_char: %s",char_toa(p));
2501: if(p->ident&Char_label && p->l==NULL) {
2502: err("fwrb_page: Char_label set but .l==NULL");
2503: p->ident &= ~Char_label;
2504: };
2505: if(p->ident&Char_ranparms && p->rp==NULL) {
2506: err("fwrb_page: Char_ranparms set but .rp==NULL");
2507: p->ident &= ~Char_ranparms;
2508: };
2509: #endif
2510: fwri_Ident(f,p->ident);
2511: fwri_Bbx(f,&(p->bx));
2512: fwri_Scoor(f,p->csp);
2513: fwri_uint4(f,p->area);
2514: fwri_uint4(f,p->per);
2515: fwri_Scoor(f,p->basl);
2516: fwri_uint3(f,p->bmny);
2517: fwri_uint2(f,p->il.mny);
2518: fwri_uint1(f,(p->sfv!=NULL)?SF_MNY:0);
2519: fwri_uint2(f,p->sh.mny);
2520: fwri_uint2(f,(p->bfsp!=NULL)?p->bfsp->bm.n:0);
2521: #if dbg_fwrb_toa
2522: err("fwrb_char: %s",char_toa(p));
2523: #endif
2524: if(p->ident&Char_label) fwrb_label(f,p->l);
2525: if(p->ident&Char_ranparms) fwrb_ranparms(f,p->rp);
2526: }
2527: #else
2528: fwrb_char(fp,cp)
2529: FILE *fp;
2530: Char *cp;
2531: { CharF cf;
2532: int stat;
2533: #if dbg_fwrb
2534: if((!(cp->ident&IsChar))||(cp->ident&(IsALL&(~IsChar))))
2535: err("fwrb_char: %s",char_toa(cp));
2536: #endif
2537: memset(&cf,'\0',sizeof(cf));
2538: if(cp->ident&Char_ranparms && cp->rp==NULL)
2539: cp->ident &= ~Char_ranparms;
2540: cf.ident = cp->ident | IsChar;
2541: cf.bx = cp->bx;
2542: cf.csp = cp->csp;
2543: cf.area = cp->area;
2544: cf.per = cp->per;
2545: /* basl omitted */
2546: cf.bmny = cp->bmny;
2547: cf.imny = cp->il.mny;
2548: cf.sfmny = (cp->sfv!=NULL)?SF_MNY:0;
2549: cf.shmny = cp->sh.mny;
2550: if(cp->bfsp!=NULL) cf.bfmny = cp->bfsp->bm.n; else cf.bfmny=0;
2551: if((stat=fwrite(&cf,sizeof(CharF),1,fp))!=1)
2552: abort("can't write CharF, status %d",stat);
2553: #if dbg_fwrb_toa
2554: err("fwrb_char: %s",char_toa(cp));
2555: #endif
2556: if(cf.ident&Char_ranparms) fwrb_ranparms(fp,cp->rp);
2557: if(cf.ident&Char_label) fwrb_label(fp,cp->l);
2558: }
2559: #endif
2560:
2561: fwrb_chars_etc(fp,cs,etc)
2562: FILE *fp;
2563: Chars cs;
2564: Ident etc;
2565: { register Char *cp,**cpp;
2566: if(cs.mny>0) for(cp= *(cpp=cs.cpa); cp!=NULL; cp= *(++cpp))
2567: fwrb_char_etc(fp,cp,etc);
2568: }
2569:
2570: fwrb_char_etc(fp,cp,etc)
2571: FILE *fp;
2572: Char *cp;
2573: Ident etc;
2574: { static Ident parts = (IsInterp|IsBlob|IsShapes|IsBfeats|IsSfeats);
2575: Char ch;
2576: if((etc&parts)!=parts) /* write selected parts */ {
2577: ch = *cp;
2578: if(!(etc&IsInterp)) ch.il.mny=0;
2579: if(!(etc&IsBlob)) ch.bmny=0;
2580: if(!(etc&IsSfeats)) ch.sfv = NULL;
2581: if(!(etc&IsShapes)) ch.sh = empty_Shapes;
2582: if(!(etc&IsBfeats)) ch.bfsp = NULL;
2583: cp = &ch; /* write modified record */
2584: };
2585: fwrb_char(fp,cp);
2586: if(cp->sfv!=NULL) fwrb_sfeats(fp,cp->sfv);
2587: if(cp->sh.mny>0) fwrb_shapes(fp,&(cp->sh));
2588: #if CPU!=CRAY
2589: if(cp->bfsp!=NULL) fwrb_bfeats(fp,cp->bfsp);
2590: #endif
2591: fwrb_interpl_etc(fp,cp->il,etc);
2592: if(cp->bmny>0) fwrb_blobl_etc(fp,cp->bmny,cp->fi,etc);
2593: }
2594:
2595: #if FRDI
2596: int frdb_char(f,p)
2597: FILE *f;
2598: Char *p;
2599: { int sf_mny,bf_mny;
2600: *p = empty_Char;
2601: if(feof(f))
2602: return(0);
2603: p->ident=frdi_Ident(f);
2604: frdi_Bbx(f,&(p->bx));
2605: p->csp=frdi_Scoor(f);
2606: p->area=frdi_uint4(f);
2607: p->per=frdi_uint4(f);
2608: p->basl=frdi_Scoor(f);
2609: p->bmny=frdi_uint3(f);
2610: p->il.mny=frdi_uint2(f);
2611: if((sf_mny=frdi_uint1(f))>0) {
2612: if((p->sfv=(Pval *)malloc(sf_mny*sizeof(Pval)))==NULL)
2613: abort("frdb_char: can't alloc p->sfv[%d]",sf_mny);
2614: memset(p->sfv,'\0',sf_mny*sizeof(Pval));
2615: };
2616: p->sh.mny=frdi_uint2(f);
2617: if((bf_mny=frdi_uint2(f))>0) {
2618: p->bfsp = alloc_bfeats(bf_mny,0);
2619: };
2620: #if dbg_frdb
2621: if((!(p->ident&IsChar))||(p->ident&(IsALL&(~IsChar))))
2622: err("frdb_char: %s",char_toa(p));
2623: #endif
2624: #if dbg_frdb_toa
2625: err("frdb_char: %s",char_toa(p));
2626: #endif
2627: if(p->ident&Char_label) p->l = frdb_label(f);
2628: if(p->ident&Char_ranparms) {
2629: p->rp = alloc_ranparms();
2630: frdb_ranparms(f,p->rp);
2631: };
2632: if(ferror(f)) return(-errno); else return(1);
2633: }
2634: #else
2635: int frdb_char(fp,cp)
2636: FILE *fp;
2637: Char *cp;
2638: { CharF cf;
2639: int stat;
2640: if((stat=fread(&cf,sizeof(CharF),1,fp))!=1)
2641: abort("frdb_char: can't read CharF, status %d",stat);
2642: *cp = empty_Char;
2643: cp->ident = cf.ident;
2644: cp->bx = cf.bx;
2645: cp->csp = cf.csp;
2646: cp->area = cf.area;
2647: cp->per = cf.per;
2648: cp->basl = 0;
2649: cp->bmny = cf.bmny;
2650: cp->il.mny = cf.imny;
2651: if(cf.sfmny>0) {
2652: if((cp->sfv=(Pval *)malloc(SF_MNY*sizeof(Pval)))==NULL)
2653: abort("frdb_char: can't alloc cp->sfv[%d]",SF_MNY);
2654: memset(cp->sfv,'\0',SF_MNY*sizeof(Pval));
2655: }
2656: else cp->sfv = NULL;
2657: cp->sh.mny = cf.shmny;
2658: #if CPU!=CRAY
2659: #if dbg_frdb
2660: if((!(cp->ident&IsChar))||(cp->ident&(IsALL&(~IsChar))))
2661: err("frdb_char: %s",char_toa(cp));
2662: #endif
2663: #endif
2664: #if dbg_frdb_toa
2665: err("frdb_char: %s",char_toa(cp));
2666: #endif
2667: if(cp->ident&Char_ranparms) {
2668: cp->rp = alloc_ranparms();
2669: frdb_ranparms(fp,cp->rp);
2670: };
2671: if(cp->ident&Char_label) cp->l = frdb_label(fp);
2672: #if CPU!=CRAY
2673: if(cf.bfmny>0) cp->bfsp = alloc_bfeats(cf.bfmny,0);
2674: else
2675: #endif
2676: cp->bfsp = NULL;
2677: if(ferror(fp)) return(-errno); else return(1);
2678: }
2679: #endif
2680:
2681: frdb_char_etc(fp,cp,etc)
2682: FILE *fp;
2683: Char *cp;
2684: Ident etc;
2685: { frdb_char(fp,cp);
2686: if(cp->sfv!=NULL) frdb_sfeats(fp,cp->sfv);
2687: if(cp->sh.mny>0) frdb_shapes(fp,&(cp->sh));
2688: #if CPU!=CRAY
2689: if(cp->bfsp!=NULL) {
2690: frdb_bfeats(fp,cp->bfsp);
2691: };
2692: #endif
2693: if(cp->il.mny>0) {
2694: frdb_interpl_etc(fp,&(cp->il),etc);
2695: /**if(!(etc&IsInterp)) free_interpl_etc(&(cp->il),IsALL);**/
2696: };
2697: if(etc&IsBlob && cp->bmny>0)
2698: frdb_blobl_etc(fp,cp->bmny,&(cp->fi),etc);
2699: else { cp->bmny = 0; cp->fi = NULL; };
2700: if(ferror(fp)) return(-errno); else return(1);
2701: }
2702:
2703: /* read a set of chars, and parts */
2704: frdb_chars_etc(fp,csp,etc)
2705: FILE *fp;
2706: Chars *csp;
2707: Ident etc;
2708: { int ci;
2709: register Char *cp,**cpp;
2710: if(csp->mny<=0) {
2711: *csp = empty_Chars;
2712: return(1);
2713: };
2714: if((cpp=csp->cpa=(Char **)malloc((csp->mny+1)*sizeof(Char *)))==NULL)
2715: abort("frdb_chars_etc: can't alloc Chars.cpa array");
2716: for(ci=0; ci<csp->mny; ci++) {
2717: *(cpp++) = cp = alloc_char();
2718: frdb_char_etc(fp,cp,etc);
2719: };
2720: *cpp = NULL;
2721: if(ferror(fp)) return(-errno); else return(1);
2722: }
2723:
2724: /* return a pointer to a distinct and duplicate copy of *cp;
2725: it is created out of malloc space.
2726: RanParms & label are treated as an integral part of the Char. */
2727: Char *dup_char(cp)
2728: Char *cp;
2729: { Char *dup;
2730: if((dup=(Char *)malloc(sizeof(Char)))==NULL)
2731: abort("can't dup Char");
2732: alloc_census(Char,1);
2733: *dup = *cp;
2734: if(dup->ident&Char_label && dup->l!=NULL)
2735: dup->l = strdup(cp->l);
2736: else {dup->ident &= ~Char_label; dup->l = NULL;};
2737: if(dup->ident&Char_ranparms && dup->rp!=NULL)
2738: dup->rp = dup_ranparms(cp->rp);
2739: else {dup->ident &= ~Char_ranparms; dup->rp = NULL;};
2740: return(dup);
2741: }
2742:
2743: /* return a pointer to a distinct and duplicate copy of *cp and those of
2744: its lists as specified by etc. (Does not conform to practice for dup_word_etc.)
2745: */
2746: Char *dup_char_etc(cp,etc)
2747: Char *cp;
2748: Ident etc;
2749: { Char *dup;
2750: dup = dup_char(cp);
2751: if(dup->bmny>0&&etc&IsBlob) dup->fi = dup_blobl_etc(cp->fi,etc);
2752: else {dup->bmny=0; dup->fi=NULL;};
2753: if(dup->il.mny>0&&etc&IsInterp) dup->il = *dup_interpl_etc(&(cp->il),etc);
2754: else dup->il = empty_Interpl;
2755: /**
2756: if(dup->sfv!=NULL>0&&etc&IsSfeats) dup->sfv = dup_sfeats(cp->sfv);
2757: else dup->sfv = NULL;
2758: if(dup->sh.mny>0&&etc&IsShapes) dup->sh = *dup_shapes(&cp->sh);
2759: else dup->sh = empty_Shapes;
2760: **/
2761: #if CPU!=CRAY
2762: if(dup->bfsp!=NULL>0&&etc&IsBfeats) dup->bfsp = dup_bfeats(cp->bfsp);
2763: else
2764: #endif
2765: dup->bfsp = NULL;
2766: return(dup);
2767: }
2768:
2769: /* Return a pointer to a local static duplicate of non-empty *csp.
2770: Its cpa array is new, created out of malloc space.
2771: If etc&IsChar, all its Characters are also duplicated,
2772: else the contents of cpa point to the old unduplicated Chars.
2773: */
2774: Chars *dup_chars_etc(csp,etc)
2775: Chars *csp;
2776: Ident etc; /* parts to duplicate */
2777: { static Chars dup;
2778: register Char **cpp,**dpp;
2779: if((dup.mny=csp->mny)<=0) dup = empty_Chars;
2780: else { if((dup.cpa=(Char **)malloc((dup.mny+1)*sizeof(Char *)))==NULL)
2781: abort("can't dup cs.cpa");
2782: for(cpp=csp->cpa,dpp=dup.cpa; (*cpp)!=NULL; cpp++,dpp++) {
2783: if(etc&IsChar) *dpp = dup_char_etc(*cpp,etc);
2784: else *dpp = *cpp;
2785: };
2786: *dpp = NULL;
2787: };
2788: return(&dup);
2789: }
2790:
2791: err_chars(p)
2792: Chars *p;
2793: { register Char **cpp;
2794: fprintf(stderr,"Chars %d: ",p->mny);
2795: if(p->mny>0) for(cpp=p->cpa; (*cpp)!=NULL; cpp++)
2796: fprintf(stderr,"%X ",*cpp);
2797: fprintf(stderr,"\n");
2798: }
2799:
2800: /* Make a Char out of a single Blob. Return a freshly-allocated Char
2801: that owns the given Blob as is (not duplicated, copied or freed).
2802: The Blob's next pointer is set to NULL. */
2803: Char *char_of_blob(b)
2804: Blob *b;
2805: { Char *c;
2806: c=alloc_char();
2807: c->bx = b->bx;
2808: c->area = b->area;
2809: c->per = b->per;
2810: c->bmny = 1;
2811: c->fi = b;
2812: b->n = NULL;
2813: return(c);
2814: }
2815:
2816: Interp *alloc_interp()
2817: { Interp *new;
2818: if((new=(Interp *)malloc(sizeof(Interp)))==NULL)
2819: abort("alloc_interp: can't malloc");
2820: alloc_census(Interp,1);
2821: *new = empty_Interp;
2822: return(new);
2823: }
2824:
2825: Interp *dup_interp(ip)
2826: Interp *ip;
2827: { Interp *dup;
2828: if((dup=(Interp *)malloc(sizeof(Interp)))==NULL)
2829: abort("dup_interp: can't malloc");
2830: alloc_census(Interp,1);
2831: *dup = *ip;
2832: return(dup);
2833: }
2834:
2835: /* Print the interpl */
2836: fwra_interpl(fp,ilp)
2837: FILE *fp;
2838: Interpl *ilp;
2839: { register Interp *cp;
2840: fprintf(fp,"Interpl[%d] ",ilp->mny);
2841: for(cp=ilp->fi; cp!=NULL; cp=cp->n) {
2842: fprintf(fp," %s --",interp_toa(cp));
2843: };
2844: fprintf(fp,"\n");
2845: }
2846:
2847: /* Print the interpl very briefly */
2848: fwra_interpl_brief(fp,ilp)
2849: FILE *fp;
2850: Interpl *ilp;
2851: { register Interp *ip;
2852: for(ip=ilp->fi; ip!=NULL; ip=ip->n) {
2853: fprintf(fp,"%s %s ",ip->ci.c,merit_toa(ip->m));
2854: };
2855: fprintf(fp,"\n");
2856: }
2857:
2858: err_interpl(ilp)
2859: Interpl *ilp;
2860: { fwra_interpl(stderr,ilp);
2861: }
2862:
2863: /* return the address of a local static copy of the given Interpl,
2864: for which each Interp is a duplicate of those in the given list */
2865: Interpl *dup_interpl_etc(ilp,etc)
2866: Interpl *ilp;
2867: Ident etc;
2868: { static Interpl lis;
2869: register Interp *cp,*pp,*dp;
2870: lis = *ilp;
2871: if(ilp->fi==NULL) return(NULL);
2872: for(pp=NULL,cp=ilp->fi; cp!=NULL; pp=dp,cp=cp->n) {
2873: dp=dup_interp(cp);
2874: if(pp==NULL) lis.fi = dp;
2875: else pp->n = dp;
2876: };
2877: pp->n=NULL;
2878: return(&lis);
2879: }
2880:
2881: /* Return a pointer to a local static duplicate of *isp.
2882: Its pa array is new, created out of malloc space.
2883: If etc&IsInterp, all its Interps are also duplicated,
2884: else the contents of pa point to the old unduplicated Interps.
2885: */
2886: Interps *dup_interps_etc(isp,etc)
2887: Interps *isp;
2888: Ident etc; /* parts to duplicate */
2889: { static Interps dup;
2890: register Interp **ipp,**dpp;
2891: dup = *isp;
2892: if(dup.mny<=0) dup = empty_Interps;
2893: else { if((dup.pa=(Interp **)malloc((dup.mny+1)*sizeof(Interp *)))==NULL)
2894: abort("can't dup (Interp *)is.pa[%d]",(dup.mny+1));
2895: for(ipp=isp->pa,dpp=dup.pa; *ipp!=NULL; ipp++,dpp++) {
2896: if(etc&IsInterp) *dpp = dup_interp(*ipp);
2897: else *dpp = *ipp;
2898: };
2899: *dpp = NULL;
2900: };
2901: return(&dup);
2902: }
2903:
2904: free_interps_etc(isp,etc)
2905: Interps *isp;
2906: Ident etc; /* parts to free */
2907: { register Interp **ipp,**dpp;
2908: if(etc&IsInterp) {
2909: /* free contents */
2910: for(ipp=isp->pa; *ipp!=NULL; ipp++) free_interp(*ipp);
2911: };
2912: if(isp->pa!=NULL) { free(isp->pa); isp->pa = NULL; };
2913: isp->mny = 0;
2914: }
2915:
2916: /* remove a char from a chars set */
2917: remove_char(cp,csp)
2918: Char *cp;
2919: Chars *csp;
2920: { register Char *rp,**rpp,**npp;
2921: if(csp->mny==0) err("remove_char: can't - Chars empty");
2922: else { for(rp= *(rpp=csp->cpa); rp!=NULL; rp= *(++rpp)) if(rp==cp) break;
2923: if(rp==NULL) err("remove_char: can't - not found");
2924: else { /* move later entries up */
2925: npp=rpp+1;
2926: do *(rpp++)= *(npp++); while ((*rpp)!=NULL);
2927: if((--(csp->mny))==0) {free(csp->cpa); csp->cpa=NULL;};
2928: /* don't bother to realloc downwards */
2929: };
2930: };
2931: }
2932:
2933: /* Append a char to the end of a chars set.
2934: Do NOT attempt to maintain Chars in order sorted ascending on Char.bx.a.x.
2935: Return appended Char *. */
2936: Char *append_char(cp,csp)
2937: Char *cp;
2938: Chars *csp;
2939: { register Char *rp,**rpp,**npp;
2940: if(csp->mny==0) {
2941: if((csp->cpa=(Char **)malloc(2*sizeof(Char *)))==NULL)
2942: abort("append_char: can't malloc csp->cpa[%d]",2);
2943: }
2944: else { if((csp->cpa=(Char **)realloc(
2945: csp->cpa,
2946: (csp->mny+2)*sizeof(Char *))
2947: )==NULL)
2948: abort("append_char: can't realloc csp->cpa[%d]",
2949: (csp->mny+2));
2950: };
2951: csp->cpa[csp->mny] = cp;
2952: csp->cpa[++csp->mny] = NULL;
2953: return(cp);
2954: }
2955:
2956: /* Insert a Char into a Chars set. Chars is assumed to be sorted ascending
2957: on on Char.bx.a.x, and this order is maintained.
2958: Return inserted Char * */
2959: Char *insert_char(cp,csp)
2960: Char *cp;
2961: Chars *csp;
2962: { register Char **cpp,*ncp,*pcp;
2963: if(csp->mny==0) {
2964: if((csp->cpa=(Char **)malloc(2*sizeof(Char *)))==NULL)
2965: abort("insert_char: can't malloc csp->cpa[%d]",2);
2966: csp->cpa[csp->mny] = cp;
2967: }
2968: else { if((cpp=csp->cpa=(Char **)realloc(
2969: csp->cpa,
2970: (csp->mny+2)*sizeof(Char *))
2971: )==NULL)
2972: abort("insert_char: can't realloc csp->cpa[%d]",csp->mny+2);
2973: while(((*cpp)!=NULL)&&(*cpp)->bx.a.x<cp->bx.a.x) cpp++;
2974: /* **cpp is now 1st entry >= *cp in sorted order */
2975: pcp=cp;
2976: do { ncp= *cpp;
2977: *(cpp++)=pcp;
2978: pcp=ncp;
2979: }
2980: while(pcp!=NULL);
2981: };
2982: csp->cpa[++csp->mny] = NULL;
2983: return(cp);
2984: }
2985:
2986: /* Append the contents of a "source" chars set to a "destination" chars set.
2987: Merely copy (Char *) pointers: don't duplicate Chars.
2988: Do NOT attempt to maintain Chars in order sorted ascending on Char.bx.a.x.
2989: Return destination (Chars *). */
2990: Chars *append_chars(s,d)
2991: Chars *s; /* source */
2992: Chars *d; /* destination */
2993: { register Char *rp,**rpp,**npp;
2994: if(s->mny==0) return(d);
2995: if(d->mny==0) {
2996: if((d->cpa=(Char **)malloc((s->mny+1)*sizeof(Char *)))==NULL)
2997: abort("append_chars: can't malloc d->cpa[%d]",2);
2998: }
2999: else { if((d->cpa=(Char **)realloc(
3000: d->cpa,
3001: (d->mny+s->mny+1)*sizeof(Char *))
3002: )==NULL)
3003: abort("append_chars: can't realloc d->cpa[%d]",
3004: (d->mny+s->mny+1));
3005: };
3006: memcpy(d->cpa+d->mny,s->cpa,(s->mny+1)*sizeof(Char *));
3007: d->mny += s->mny;
3008: return(d);
3009: }
3010:
3011: /* Insert a Char into the Chars owned by a given Word,
3012: maintaining order in set, and updating the Word's bx */
3013: Char *insert_char_word(cp,wp)
3014: Char *cp;
3015: Word *wp;
3016: { merge_bbx(&(cp->bx),&(wp->bx));
3017: return(insert_char(cp,&(wp->cs)));
3018: }
3019:
3020: free_char_etc(p,etc)
3021: Char *p; /* !=NULL */
3022: Ident etc;
3023: { if(etc&IsBlob) free_blobl_etc(&(p->bmny),&(p->fi),etc);
3024: if(etc&IsInterp) free_interpl(&(p->il));
3025: if(etc&IsSfeats && p->sfv!=NULL) { free(p->sfv); p->sfv=NULL; };
3026: if(etc&IsShapes) free_shapes(&(p->sh));
3027: #if CPU!=CRAY
3028: if(etc&IsBfeats && p->bfsp!=NULL) { free_bfeats(p->bfsp); p->bfsp=NULL; };
3029: #endif
3030: if(etc&IsChar) {
3031: if(p->ident&Char_label && p->l!=NULL) {
3032: free(p->l); p->l=NULL;
3033: p->ident &= ~Char_label;
3034: };
3035: if(p->ident&Char_ranparms && p->rp!=NULL) {
3036: free_ranparms(p->rp); p->rp=NULL;
3037: p->ident &= ~Char_ranparms;
3038: };
3039: free(p);
3040: free_census(Char,1);
3041: };
3042: }
3043:
3044: /* Unconditionally free the malloc-space array of pointers, and empty the set.
3045: Don't free the records that it owned.
3046: */
3047: free_chars(csp)
3048: Chars *csp;
3049: { if(csp->cpa!=NULL) { free(csp->cpa); csp->cpa = NULL; }
3050: csp->mny = 0;
3051: }
3052:
3053: free_chars_etc(csp,etc)
3054: Chars *csp;
3055: Ident etc;
3056: { register Char *cp,**cpp;
3057: if(csp->mny>0&&(etc&IsChar))
3058: for(cp= *(cpp=csp->cpa); cp!=NULL; cp= *(++cpp))
3059: free_char_etc(cp,etc);
3060: free_chars(csp);
3061: }
3062:
3063: /** Blob handling:
3064: alloc_blob_pool(sz,debug) - create pool of free blob records
3065: free_blob_pool() - free the pool
3066: Blob *alloc_blob() - allocate a new blob (in pool)
3067: free_blob(bp) - free a specified blob
3068: free_blob_runs(bp) - free a blob & the runs in its blob set
3069: free_blobl_etc(int *,Blob **,etc) - free blobs etc in char's blob list
3070: out_blob(bp) - print (ascii) to stdout
3071: fwrb_blob(fp,bp) - write binary Blob (only) to fp
3072: fwrb_blob_etc(fp,bp,etc) - write binary Blob & specified parts to fp
3073: frdb_blob_etc(fp,bp,etc) - read binary Blob & parts in specified form
3074: frdb_runfs(fp,bp,max) - read *bp's (binary) RunF's from fp
3075: err_blob(s,bp) - print (ascii) to stderr
3076: err_blob_runs(s,bp) - print Blob & its Runs (ascii) to stderr
3077: err_blob_runfs(s,bp) - print Blob & its RunFs (ascii) to stderr
3078: err_blob_briefly(s,bp) - print (ascii) to stderr
3079: err_blobf(s,bp) - print file-format blob (ascii) to stderr
3080: err_blob_stats() - report blob statistics
3081: blob_small(bp) - test whether its runs' data can be compressed to chars
3082: BUGS
3083: most fread/fwrite/fseek should be read/write/lseek, for speed
3084: -- but how to choose?
3085: **/
3086:
3087: /* make (empty) pool of `size' Blobs (return F if can't allocate) */
3088: boolean alloc_blob_pool(size,dbg)
3089: int size;
3090: boolean dbg;
3091: { register Blob *cbp, *cbq, *pbp;
3092: blob_max=size;
3093: if((blob_pool=(Blob *)malloc(blob_max*sizeof(Blob)))==NULL) return(F);
3094: blob_debug = dbg;
3095: pbp= &blob_fr;
3096: /* link up all blobs into free list using only first-ptrs */
3097: for(cbq=(cbp=blob_pool)+blob_max; cbp<cbq; cbp++) {
3098: pbp->n = cbp;
3099: pbp = cbp;
3100: };
3101: pbp->n = NULL; /* marks end of free list */
3102: blob_fr_mny = blob_max; blob_hi=0; blob_chopped = 0;
3103: hi_blob_no = 0;
3104: return(T);
3105: }
3106:
3107: free_blob_pool()
3108: { free(blob_pool);
3109: }
3110:
3111: Blob *alloc_blob()
3112: { Blob *p;
3113: if((p=(Blob *)malloc(sizeof(Blob)))==NULL)
3114: abort("alloc_blob: can't");
3115: alloc_census(Blob,1);
3116: *p = empty_Blob;
3117: return(p);
3118: }
3119:
3120: /* Unconditionally free this Blob record. */
3121: free_blob(bp)
3122: Blob *bp;
3123: { free(bp);
3124: free_census(Blob,1);
3125: }
3126:
3127: /* Allocate new Blob record and assign to it the next blob no */
3128: Blob *alloc_pool_blob()
3129: { register Blob *bp;
3130: if((bp = blob_fr.n)==NULL) {
3131: err("too many alloc_blob() calls - aborting:");
3132: #ifdef STATS
3133: err_blob_stats();
3134: #endif
3135: exit(1);
3136: };
3137: blob_fr.n = bp->n;
3138: #ifdef STATS
3139: blob_fr_mny--;
3140: if(blob_hi<(blob_max-blob_fr_mny)) blob_hi = blob_max-blob_fr_mny;
3141: #endif
3142: bp->no = hi_blob_no++;
3143: return(bp);
3144: }
3145:
3146: free_pool_blob(bp)
3147: Blob *bp;
3148: {
3149: if(blob_debug&&bp==NULL) abort("free_pool_blob: can't free a NULL Blob");
3150: #ifdef STATS
3151: blob_fr_mny++;
3152: if(blob_debug&&(blob_fr_mny>blob_max)) {
3153: err("free_pool_blob: too many free_blob() calls - aborting:");
3154: #ifdef STATS
3155: err_blob_stats();
3156: #endif
3157: exit(1);
3158: };
3159: #endif
3160: bp->n = blob_fr.n;
3161: blob_fr.n = bp;
3162: }
3163:
3164: /* free the runs belonging to this blob */
3165: free_runs(bp)
3166: Blob *bp;
3167: { register Run *crp,*nrp;
3168: if(bp->ident&Runs_ff) {
3169: if(bp->r.ff!=NULL) free(bp->r.ff);
3170: bp->r.ff=NULL;
3171: }
3172: else if(bp->ident&Runs_f) {
3173: for(crp=bp->r.f; crp!=NULL; crp=nrp) {
3174: nrp=crp->n;
3175: free_run(crp);
3176: };
3177: }
3178: else if(bp->ident&Runs_seek) /* none to free */ ;
3179: }
3180:
3181: /* free blob *bp and those parts (runs) specified */
3182: free_blob_etc(bp,etc)
3183: Blob *bp;
3184: Ident etc;
3185: { if(etc&IsRun) free_runs(bp);
3186: if(etc&IsBlob) free_blob(bp);
3187: }
3188:
3189: /* return a pointer to a distinct and duplicate copy of *bp;
3190: it is created out of malloc space */
3191: Blob *dup_blob(bp)
3192: Blob *bp;
3193: { Blob *dup;
3194: if((dup=(Blob *)malloc(sizeof(Blob)))==NULL)
3195: abort("dup_blob: can't malloc");
3196: alloc_census(Blob,1);
3197: *dup = *bp;
3198: return(dup);
3199: }
3200:
3201: /* return a pointer to a distinct and duplicate copy of *bp and what it owns,
3202: as described by etc; created out of malloc space */
3203: Blob *dup_blob_etc(bp,etc)
3204: Blob *bp;
3205: Ident etc;
3206: { Blob *dup;
3207: dup = dup_blob(bp);
3208: if(bp->runs>0) {
3209: if(bp->ident&Runs_ff) {
3210: int ri;
3211: RunF *rp,*drp;
3212: if((dup->r.ff=
3213: (RunF *)malloc(bp->runs*sizeof(RunF)))==NULL)
3214: abort("dup_blob_etc: can't malloc RunF[%d]",
3215: bp->runs);
3216: for(ri=0,rp=bp->r.ff,drp=dup->r.ff; ri<bp->runs; ri++)
3217: *(drp++) = *(rp++);
3218: }
3219: else abort("dup_blob_etc: only Runs_ff implemented");
3220: };
3221: return(dup);
3222: }
3223:
3224: /* Return a pointer to a local static duplicate of non-empty *bsp.
3225: Its bpa array is created newly out of malloc space.
3226: If etc&IsBlob, all its Blobs are also fresh duplicates,
3227: else the contents of bpa point to the old unduplicated Blobs.
3228: */
3229: Blobs *dup_blobs_etc(bsp,etc)
3230: Blobs *bsp;
3231: Ident etc; /* parts to duplicate */
3232: { static Blobs dup;
3233: register Blob **bpp,**dpp;
3234: if((dup.mny = bsp->mny)<=0) dup = empty_Blobs;
3235: else { if((dup.bpa=(Blob **)malloc((dup.mny+1)*sizeof(Blob *)))==NULL)
3236: abort("dup_blobs_etc: can't malloc bs.bpa[%d]",dup.mny+1);
3237: for(bpp=bsp->bpa,dpp=dup.bpa; *bpp!=NULL; bpp++,dpp++) {
3238: if(etc&IsBlob) *dpp = dup_blob_etc(*bpp,etc);
3239: else *dpp = *bpp;
3240: };
3241: *dpp = NULL;
3242: };
3243: return(&dup);
3244: }
3245:
3246: /* Split the given Blobs into two, *b0 & *b1, according to the value 0 or !0
3247: respectively returned by the function s(b,a) applied to each Blob *b and
3248: blind argument *a.
3249: s() will be evaluated exactly once for each Blob, and the Blob's will be
3250: assigned in the order found in the original Blobs. Only pointers to Blob's
3251: are created; the Blob's themselves are not duplicated. The original Blobs
3252: record is unchanged.
3253: */
3254: split_blobs(b,s,a,b0,b1)
3255: Blobs *b;
3256: int (*s)();
3257: VOID *a; /* passed transparently to s() */
3258: Blobs *b0,*b1;
3259: { char *sel,*sp;
3260: register Blob *bp,**bpp;
3261: Blob **b0pp;
3262: Blob **b1pp;
3263: *b0 = *b1 = empty_Blobs;
3264: if(b->mny<=0) return;
3265: if((sel=(char *)malloc(b->mny))==NULL)
3266: abort("split_blobs: can't malloc sel[%d]",b->mny);
3267: for(bp= *(bpp=b->bpa),sp=sel; bp!=NULL; bp= *(++bpp),sp++)
3268: if(*sp = s(bp,a)) b1->mny++; else b0->mny++;
3269: if(b0->mny>0)
3270: if((b0->bpa=(Blob **)malloc((b0->mny+1)*sizeof(Blob *)))==NULL)
3271: abort("split_blobs: can't malloc b0->bpa[%d]",b0->mny+1);
3272: if(b1->mny>0)
3273: if((b1->bpa=(Blob **)malloc((b1->mny+1)*sizeof(Blob *)))==NULL)
3274: abort("split_blobs: can't malloc b1->bpa[%d]",b1->mny+1);
3275: b0pp=b0->bpa;
3276: b1pp=b1->bpa;
3277: for(bp= *(bpp=b->bpa),sp=sel; bp!=NULL; bp= *(++bpp),sp++)
3278: if(*sp) *(b1pp++)=bp; else *(b0pp++)=bp;
3279: if(b0->mny>0) *b0pp=NULL;
3280: if(b1->mny>0) *b1pp=NULL;
3281: free(sel);
3282: }
3283:
3284: /* Return the address of the first in a list of Blobs, duplicated from
3285: the given list. */
3286: Blob *dup_blobl_etc(bp,etc)
3287: Blob *bp;
3288: Ident etc;
3289: { Blob *fi,*cp,*pp,*dp;
3290: if(bp==NULL) return(NULL);
3291: for(pp=NULL,cp=bp; cp!=NULL; pp=dp,cp=cp->n) {
3292: dp=dup_blob_etc(cp,etc);
3293: if(pp==NULL) fi = dp;
3294: else pp->n = dp;
3295: };
3296: pp->n=NULL;
3297: return(fi);
3298: }
3299:
3300: /* Prepend this blob to the given Char's bloblist; update Char's bx, area, & per.
3301: Inverse of `remove_blobl()'. */
3302: Blob *insert_blobl(bp,cp)
3303: Blob *bp;
3304: Char *cp;
3305: { register Blob *pbp,*nbp;
3306: if(cp->bmny>0) bp->n = cp->fi;
3307: else bp->n = NULL;
3308: cp->fi = bp;
3309: cp->bmny++;
3310: merge_bbx(&(bp->bx),&(cp->bx));
3311: cp->area += bp->area;
3312: cp->per += bp->per;
3313: return(bp);
3314: }
3315:
3316: /* Remove this blob from a char's bloblist; update Char's bx, area, per.
3317: Inverse of `insert_blobl()'. */
3318: remove_blobl(bp,cp)
3319: Blob *bp;
3320: Char *cp;
3321: { Blob *rp,*pp;
3322: Bbx bx; /* Char's new Bbx */
3323: if(cp->bmny==1) { /* frequent case */
3324: cp->fi=NULL; cp->bmny=0;
3325: }
3326: else if(cp->bmny>1){
3327: bx=empty_Bbx;
3328: pp=NULL;
3329: for(rp=cp->fi; rp!=NULL; pp=rp,rp=rp->n) {
3330: if(rp==bp) break;
3331: else { if(bx.a.x > rp->bx.a.x) bx.a.x = rp->bx.a.x;
3332: if(bx.a.y > rp->bx.a.y) bx.a.y = rp->bx.a.y;
3333: if(bx.b.x < rp->bx.b.x) bx.b.x = rp->bx.b.x;
3334: if(bx.b.y < rp->bx.b.y) bx.b.y = rp->bx.b.y;
3335: };
3336: };
3337: if(rp!=NULL) { /* remove from list */
3338: if(pp==NULL) cp->fi=bp->n;
3339: else pp->n=bp->n;
3340: cp->bmny--;
3341: for(rp=bp->n; rp!=NULL; rp=rp->n) {
3342: if(bx.a.x > rp->bx.a.x) bx.a.x = rp->bx.a.x;
3343: if(bx.a.y > rp->bx.a.y) bx.a.y = rp->bx.a.y;
3344: if(bx.b.x < rp->bx.b.x) bx.b.x = rp->bx.b.x;
3345: if(bx.b.y < rp->bx.b.y) bx.b.y = rp->bx.b.y;
3346: };
3347: cp->bx = bx;
3348: }
3349: else err("remove_blobl: can't - not found");
3350: }
3351: else err("remove_blobl: can't - Blobl empty");
3352: cp->area -= bp->area;
3353: cp->per -= bp->per;
3354: }
3355:
3356: /* prepend this blob to the given Blob list */
3357: Blob *prepend_blobl(bp,blp)
3358: Blob *bp;
3359: Blobl *blp;
3360: { register Blob *pbp,*nbp;
3361: if(blp->mny>0) bp->n = blp->fi;
3362: else { bp->n = NULL;
3363: blp->la = bp;
3364: };
3365: blp->fi = bp;
3366: blp->mny++;
3367: return(bp);
3368: }
3369:
3370: /* append this blob to the given Blob list */
3371: Blob *append_blobl(bp,blp)
3372: Blob *bp;
3373: Blobl *blp;
3374: { register Blob *pbp,*nbp;
3375: if(blp->mny==0) blp->fi = bp;
3376: else blp->la->n = bp;
3377: blp->la = bp;
3378: bp->n = NULL;
3379: blp->mny++;
3380: return(bp);
3381: }
3382:
3383: /* remove a blob from a blobs set */
3384: remove_blob(bp,bsp)
3385: Blob *bp;
3386: Blobs *bsp;
3387: { register Blob *rp,**rpp,**npp;
3388: if(bsp->mny==0) err("remove_blob: can't - Blobs empty");
3389: else { for(rp= *(rpp=bsp->bpa); rp!=NULL; rp= *(++rpp)) if(rp==bp) break;
3390: if(rp==NULL) err("remove_blob: can't - not found");
3391: else { /* move later entries up */
3392: npp=rpp+1;
3393: do *(rpp++)= *(npp++); while ((*rpp)!=NULL);
3394: if((--(bsp->mny))==0) {free(bsp->bpa); bsp->bpa=NULL;};
3395: /* don't bother to realloc downwards */
3396: };
3397: };
3398: }
3399:
3400: /* Append a blob to the end of a blobs set.
3401: Return appended Blob *. */
3402: Blob *append_blob(p,sp)
3403: Blob *p;
3404: Blobs *sp;
3405: { register Blob *rp,**rpp,**npp;
3406: if(sp->mny==0) {
3407: if((sp->bpa=(Blob **)malloc(2*sizeof(Blob *)))==NULL)
3408: abort("append_blob: can't malloc sp->bpa[2]");
3409: }
3410: else { if((sp->bpa=(Blob **)realloc(
3411: sp->bpa,
3412: (sp->mny+2)*sizeof(Blob *))
3413: )==NULL)
3414: abort("append_blob: can't realloc sp->bpa[%d]",sp->mny+2);
3415: };
3416: sp->bpa[sp->mny] = p;
3417: sp->bpa[++sp->mny] = NULL;
3418: return(p);
3419: }
3420:
3421: /* Append Blobs *p1 to Blobs *p2. On return, *p1 is unchanged, *p2 is in general
3422: longer, and all the Blob's owned by *p1 are now also owned by *p2. */
3423: append_blobs_blobs(p1,p2)
3424: Blobs *p1,*p2;
3425: { int mny;
3426: register Blob **pp1,**pp2;
3427: if(p1->mny==0) return;
3428: if(p2->mny==0) { *p2 = *dup_blobs_etc(p1,IsNONE); return; };
3429: mny = p2->mny + p1->mny;
3430: if((p2->bpa=(Blob **)realloc(p2->bpa,(mny+1)*sizeof(Blob *)))==NULL)
3431: abort("append_blobs_blobs: can't realloc p2->bpa[%d]",mny+1);
3432: pp1=p1->bpa; pp2=p2->bpa+p2->mny; while(*pp1!=NULL) *(pp2++) = *(pp1++);
3433: *pp2 = NULL;
3434: p2->mny = mny;
3435: }
3436:
3437: free_blobl_etc(mnyp,fip,etc)
3438: int *mnyp;
3439: Blob **fip;
3440: Ident etc;
3441: { register Blob *bp,*nbp;
3442: if(*mnyp>0) {
3443: for(bp= *fip; bp != NULL; bp=nbp)
3444: { nbp=bp->n; free_blob_etc(bp,etc); };
3445: };
3446: *mnyp=0;
3447: *fip=NULL;
3448: }
3449:
3450: /* Unconditionally free the malloc-space array of pointers, and empty the set.
3451: Don't free the records that it owned.
3452: */
3453: free_blobs(bsp)
3454: Blobs *bsp;
3455: { if(bsp->bpa!=NULL) { free(bsp->bpa); bsp->bpa=NULL; };
3456: bsp->mny = 0;
3457: }
3458:
3459: free_blobs_etc(bsp,etc)
3460: Blobs *bsp;
3461: Ident etc;
3462: { register Blob *bp, **bpp;
3463: if(bsp->mny>0&&(etc&IsBlob)) for(bp= *(bpp=bsp->bpa); bp!=NULL; bp= *(++bpp))
3464: free_blob_etc(bp,etc);
3465: free_blobs(bsp);
3466: }
3467:
3468: Blobs *blobl_to_blobs(blp)
3469: Blobl *blp;
3470: { static Blobs bs;
3471: register Blob *bp,**bpp;
3472: bs = empty_Blobs;
3473: bs.mny = blp->mny;
3474: if(bs.mny>0) {
3475: if((bs.bpa=(Blob **)malloc((bs.mny+1)*sizeof(Blob *)))==NULL)
3476: abort("blobl_to_blobs: can't malloc Blobs.bpa[%d]",bs.mny+1);
3477: for(bp=blp->fi,bpp=bs.bpa; bp!=NULL; bp=bp->n,bpp++)
3478: *bpp = bp;
3479: *bpp = NULL;
3480: };
3481: return(&bs);
3482: }
3483:
3484: int bp_tod(bp)
3485: Blob *bp;
3486: { if(bp==NULL) return(-2);
3487: else return(bp-blob_pool);
3488: }
3489:
3490: /* test whether for this Blob, each runs's data fields could all be compressed
3491: from a short to a char */
3492: boolean blob_small(bp)
3493: Blob *bp;
3494: { if(bp->runs>255) return(F);
3495: if(bbx_wid(&bp->bx)>255) return(F);
3496: if(bbx_hgt(&bp->bx)>255) return(F);
3497: return(T);
3498: }
3499:
3500: char *blob_toa(bp)
3501: Blob *bp;
3502: { char s1[80];
3503: static char s[80];
3504: Scoor hgt,wid;
3505: if(bp==NULL) strcpy(s,"NULL");
3506: else { hgt = bp->bx.b.y - bp->bx.a.y + 1;
3507: wid = bp->bx.b.x - bp->bx.a.x + 1;
3508: sprintf(s1,"%s bx%s w%d,h%d ar%d pe%d r.",
3509: ident_toa(bp->ident),
3510: bbx_toa(&(bp->bx)),
3511: wid,
3512: hgt,
3513: bp->area,
3514: bp->per
3515: );
3516: if(bp->ident&Runs_f) strcat(s1,"f");
3517: else if(bp->ident&Runs_ff) strcat(s1,"ff");
3518: else if(bp->ident&Runs_seek) strcat(s1,"sk");
3519: else if(bp->ident&Runs_g4) strcat(s1,"g");
3520: else strcat(s1,"?");
3521: sprintf(s,"%s%d",s1,bp->runs);
3522: };
3523: return(s);
3524: }
3525:
3526: /* compute the centroid of the Blob, w.r.t bx.a */
3527: Pp *blob_centroid(bp)
3528: Blob *bp;
3529: { static Pp c;
3530: RunF *rfp;
3531: int ri,area;
3532: c.x = c.y = 0.0;
3533: if(bp->ident&Runs_ff) {
3534: for(ri=0, rfp=bp->r.ff; ri<bp->runs; ri++, rfp++) {
3535: c.x += (area=(rfp->xe-rfp->xs+1)) * (rfp->xe+rfp->xs);
3536: c.y += area * rfp->y;
3537: };
3538: c.x /= 2.0*bp->area;
3539: c.y /= bp->area;
3540: }
3541: else abort("blob_centroid: only Runs_ff supported");
3542: return(&c);
3543: }
3544:
3545: /* write (printably) to stdout */
3546: out_blob(bp)
3547: Blob *bp;
3548: { Run *crp;
3549: static char pad[] = " ";
3550: short y;
3551: if(bp==NULL) fprintf(stderr,"Bb NULL.\n");
3552: else fprintf(stdout,"%s\n",blob_toa(bp));
3553: fprintf(stdout,"%sy%d:",pad,bp->bx.a.y);
3554: for(crp=bp->r.f,y=crp->y; crp!=NULL; crp=crp->n) {
3555: if(crp->y!=y) {
3556: fprintf(stdout,"\n%sy%d:",pad,crp->y);
3557: y=crp->y;
3558: };
3559: fprintf(stdout," [%d,%d]",crp->xs,crp->xe);
3560: };
3561: fprintf(stdout,"\n");
3562: }
3563:
3564: #if FWRI
3565: /* Write blob record (only) to FILE *f.
3566: Check whether Blob is ``small'' and label *p accordingly. */
3567: fwrb_blob(f,p)
3568: FILE *f;
3569: Blob *p;
3570: {
3571: #if dbg_fwrb
3572: if((!(p->ident&IsBlob))||(p->ident&(IsALL&(~IsBlob))))
3573: err("fwrb_blob: %s",blob_toa(p));
3574: #endif
3575: if(blob_small(p)) p->ident |= Blob_small; else p->ident &= ~Blob_small;
3576: fwri_Ident(f,p->ident);
3577: /* fwri_Seq(f,p->no); */
3578: fwri_Bbx(f,&(p->bx));
3579: fwri_uint4(f,p->area);
3580: fwri_uint4(f,p->per);
3581: /* don't write .n */
3582: fwri_Merit(f,p->m);
3583: fwri_uint3(f,p->runs);
3584: fwri_uint2(f,((p->bdsp==NULL)? 0: p->bdsp->mny));
3585: #if dbg_fwrb_toa
3586: err("fwrb_blob: %s",blob_toa(p));
3587: #endif
3588: }
3589: #else
3590: /* Write blob record (only) to FILE *fp.
3591: Check whether Blob is ``small'' and label *bp accordingly. */
3592: fwrb_blob(fp,bp)
3593: FILE *fp;
3594: Blob *bp;
3595: { BlobF bf;
3596: #if dbg_fwrb
3597: if((!(bp->ident&IsBlob))||(bp->ident&(IsALL&(~IsBlob))))
3598: err("fwrb_blob: %s",blob_toa(bp));
3599: #endif
3600: memset(&bf,'\0',sizeof(bf));
3601: if(blob_small(bp)) bp->ident |= Blob_small;
3602: else bp->ident &= ~Blob_small;
3603: bf.ident = bp->ident;
3604: bf.bx=bp->bx;
3605: bf.area=bp->area;
3606: bf.per=bp->per;
3607: bf.runs=bp->runs;
3608: if(bp->bdsp==NULL) bf.bdys=0;
3609: else bf.bdys=bp->bdsp->mny;
3610: if(blob_debug) err_blobf("",&bf);
3611: if(fwrite(&bf,sizeof(BlobF),1,fp)!=1)
3612: abort("fwrb_blob: can't fwrite");
3613: #if dbg_fwrb_toa
3614: err("fwrb_blob: %s",blob_toa(bp));
3615: #endif
3616: }
3617: #endif
3618:
3619: /* Write detailed description of Runs to stderr. */
3620: Blob *err_runs(name,bp)
3621: char *name;
3622: Blob *bp;
3623: { Run *rp;
3624: RunF *rfp,*rfe;
3625: int ri;
3626: if(bp->ident&Runs_f) {
3627: fprintf(stderr,"%s Runs_f[%d] in %s:\n",
3628: name,bp->runs,bbx_toa(&bp->bx));
3629: for(rp=bp->r.f,ri=0; rp!=NULL; rp=rp->n,ri++) {
3630: fprintf(stderr," %2d: %d[%d,%d]\n",
3631: ri,rp->y,rp->xs,rp->xe);
3632: };
3633: }
3634: else if(bp->ident&Runs_ff) {
3635: fprintf(stderr,"%s Runs_ff[%d] in %s: ",
3636: name,bp->runs,bbx_toa(&(bp->bx)));
3637: for(rfe=(rfp=bp->r.ff)+bp->runs,ri=0; rfp<rfe; rfp++,ri++) {
3638: fprintf(stderr," %d:%d[%d,%d]",
3639: ri,rfp->y,rfp->xs,rfp->xe);
3640: };
3641: fprintf(stderr,"\n");
3642: }
3643: else if(bp->ident&Runs_seek) {
3644: goto unsupported;
3645: }
3646: else { goto unsupported;
3647: };
3648: return;
3649: unsupported:
3650: abort("err_runs: %s unsupported",ident_toa(bp->ident));
3651: }
3652:
3653: /* Convert the type of Runs in *bp to the type specified by id.
3654: Supported: only bp->ident&Runs_f to id&Runs_ff.
3655: Return pointer to local static duplicate of *bp.
3656: */
3657: Blob *runs_to_runs(bp,id)
3658: Blob *bp;
3659: Ident id;
3660: { static Blob b;
3661: register Run *rp;
3662: RunF *rfp;
3663:
3664: b = *bp;
3665: if(bp->ident&Runs_f) {
3666: if(id&Runs_ff) {
3667: b.ident &= ~(Runs_f|Blob_small);
3668: b.ident |= Runs_ff;
3669: if(blob_small(bp)) b.ident |= Blob_small;
3670: if((b.r.ff=(RunF *)malloc(b.runs*sizeof(RunF)))==NULL)
3671: abort("runs_to_runs: can't malloc Blob.r.ff[%d]",
3672: b.runs); for(rp=bp->r.f,rfp=b.r.ff; rp!=NULL; rp=rp->n,rfp++) {
3673: /* y, xs, xe will be relative to Blob.bx.a */
3674: rfp->y = rp->y - bp->bx.a.y;
3675: rfp->xs = rp->xs - bp->bx.a.x;
3676: rfp->xe = rp->xe - bp->bx.a.x;
3677: /* above,below connecting indices are relative to
3678: the sequence no. of this run (ac>0 & bc>0) */
3679: if((rfp->ad = rp->ad)!=0)
3680: rfp->ac = rp->u.no - rp->ac->u.no;
3681: else rfp->ac = 0;
3682: if((rfp->bd = rp->bd)!=0)
3683: rfp->bc = rp->bc->u.no - rp->u.no;
3684: else rfp->bc = 0;
3685: if(0) err_runf(" ",rfp);
3686: };
3687: }
3688: else { goto unsupported;
3689: };
3690: }
3691: else if(bp->ident&Runs_ff) {
3692: if(bp->ident&Blob_small) {
3693: goto unsupported;
3694: }
3695: else { goto unsupported;
3696: };
3697: }
3698: else if(bp->ident&Runs_seek) {
3699: goto unsupported;
3700: }
3701: else { goto unsupported;
3702: };
3703: return(&b);
3704:
3705: unsupported:
3706: abort("runs_to_runs: %s --> %s unsupported",
3707: ident_toa(bp->ident),ident_toa(id));
3708: }
3709:
3710: #if CPU!=CRAY
3711: /* Write these RunFs to FILE *fp in CCITT Group 4 format.
3712: BUG: uses bitio to one end of a pipe, just to store the entire
3713: byte-stream so it can be counted; then, it is copied to *fp.
3714: This fails on large bitmaps since the space available for pipe
3715: buffering is limited by system constraints and can run out at any
3716: time (symptom: the user process hangs in I state). Also, since
3717: it relies so heavily on streams, it may not prove to be very portable.
3718: Should be rewritten with an expandable byte-buffer of some kind,
3719: which requires that the `putting' function in bitio be user-selectable.
3720: */
3721: fwrb_runfs_g4(fp,bxp,runs,ff)
3722: FILE *fp;
3723: Bbx *bxp;
3724: int runs;
3725: RunF *ff;
3726: #define dbg_fwrb_runfs_g4_detail F
3727: { RLE_Line l0,l1;
3728: RLE_Line *cl,*pl,*swap; /* current/prior/swap line */
3729: int wid,hgt; /* width,height of rectangular box of pixels */
3730: BITFILE *bf;
3731: int iri;
3732: RunF *irp;
3733: RLE_Run *crp;
3734: static int pipe_fd[2] = {-1,-1};
3735: static FILE *pipe_fp[2] = {NULL,NULL};
3736: unsigned long bytes,bi;
3737: int och;
3738: /* buffer g4 code in a pipe in order to count it */
3739: if(pipe_fd[0]==-1) {
3740: pipe(pipe_fd);
3741: if((pipe_fp[0] = fdopen(pipe_fd[0],"r"))==NULL)
3742: abort("fwrb_runfs_g4: can't open pipe \"r\", fd=%d",
3743: pipe_fd[0]);
3744: if((pipe_fp[1] = fdopen(pipe_fd[1],"w"))==NULL)
3745: abort("fwrb_runfs_g4: can't open pipe \"w\", fd=%d",
3746: pipe_fd[1]);
3747: /* leave this pipe open for the duration of the process */
3748: };
3749: /* treat pipe_fp[1] as a sequence of bits */
3750: if((bf=bopen(pipe_fp[1],"w"))==NULL)
3751: abort("fwrb_runfs_g4: can't open bitfile");
3752: wid = bbx_wid(bxp); hgt=bbx_hgt(bxp);
3753: BOF_to_g4(bf);
3754: cl= &l0; pl= &l1; cl->len = pl->len = wid; cl->y=0; pl->runs=0;
3755: iri=0; irp=ff;
3756: do { /* build current RLE_Line */
3757: crp=cl->r;
3758: while(iri<runs&&irp->y==cl->y) {
3759: crp->xs=irp->xs;
3760: crp->xe=irp->xe;
3761: if(dbg_fwrb_runfs_g4_detail)
3762: err("i%d: y%d x[%d,%d]",
3763: iri,cl->y,crp->xs,crp->xe);
3764: iri++; irp++; crp++;
3765: };
3766: cl->runs = crp-cl->r;
3767: /* write current RLE_line to file */
3768: rlel_to_g4(pl,cl,wid,bf);
3769: /* save current line as prior */
3770: swap=pl; pl=cl; cl=swap; cl->runs=0; cl->y=pl->y+1;
3771: }
3772: while(cl->y<hgt);
3773: /** By policy, don't append EOFB (i.e. omit EOF_to_g4(bf)) **/
3774: bytes = bclose(bf);
3775: if(dbg_fwrb_runs) err("fwrb_runfs_g4: %d bytes",bytes);
3776: #if FWRI
3777: fwri_uint4(fp,bytes);
3778: #else
3779: fwrite(&bytes,sizeof(bytes),1,fp);
3780: #endif
3781: /* copy contents in pipe to fp */
3782: fflush(pipe_fp[1]);
3783: for(bi=0;bi<bytes;bi++) {
3784: putc(och=getc(pipe_fp[0]),fp);
3785: #if dbg_fwrb_runs
3786: fprintf(stderr,"%02x",(unsigned char)och);
3787: #endif
3788: };
3789: if(dbg_fwrb_runs) fprintf(stderr,"\n");
3790: }
3791: #else
3792: fwrb_runfs_g4(fp,bxp,runs,ff)
3793: FILE *fp;
3794: Bbx *bxp;
3795: int runs;
3796: RunF *ff;
3797: { abort("fwrb_runfs_g4: unimplemented on Cray");
3798: }
3799: #endif
3800:
3801: #if CPU != CRAY
3802: /* Read a connected group of Runs in CCITT Group 4 format, into an array of RunFs.
3803: Return: 1 if normal & successful, 0 if EOF, and -1 if error.
3804: */
3805: int frdb_g4_runfs(fp,bxp,runs,ff)
3806: FILE *fp;
3807: Bbx *bxp; /* their bounding box, shrink-wrapped to fit exactly */
3808: int runs; /* expect exactly this number of runs */
3809: RunF *ff; /* space for `runs' RunFs */
3810: #define dbg_frdb_g4_runfs_detail F
3811: { RLE_Line *cl; /* current line */
3812: int wid,hgt; /* width,height of rectangular box of pixels */
3813: int y; /* height of current line */
3814: boolean bof;
3815: BITFILE *bf;
3816: static DST_table *tbl = NULL;
3817: int iri;
3818: RLE_Run *irp;
3819: int ori;
3820: RunF *orp;
3821: unsigned long bytes,g4_bytes;
3822: #if FRDI
3823: bytes=frdi_uint4(fp);
3824: #else
3825: fread(&bytes,sizeof(bytes),1,fp);
3826: #endif
3827: if(dbg_frdb_runs) err("frdb_g4_runfs: %d bytes",bytes);
3828: /* read FILE *fp as a sequence of bits */
3829: if((bf=bopen(fp,"r"))==NULL)
3830: abort("frdb_g4_runfs: can't open bitfile");
3831: if(tbl==NULL) {
3832: tbl=ccitt_table();
3833: if(dbg_frdb_g4_runfs_detail) ccitt_err_tbl(tbl);
3834: };
3835: wid=bbx_wid(bxp); hgt=bbx_hgt(bxp);
3836: y=0; bof=T; ori=0; orp=ff;
3837: while((y<hgt)&&(cl=g4_to_rlel(tbl,bf,bof,wid))!=NULL) {
3838: /* copy runs to RunF ff[] */
3839: for(iri=0,irp=cl->r; iri<cl->runs; iri++,irp++) {
3840: if(dbg_frdb_g4_runfs_detail)
3841: err("o%d i%d: y%d x[%d,%d]",
3842: ori,iri,y,irp->xs,irp->xe);
3843: if(ori<runs) {
3844: orp->y = y; orp->xs = irp->xs; orp->xe = irp->xe;
3845: orp++;
3846: }
3847: else err("frdb_g4_runfs: too many runs: ori%d >= runs%d",
3848: ori,runs);
3849: ori++;
3850: };
3851: y++; bof=F;
3852: };
3853: if(cl==NULL) {
3854: err("frdb_g4_runfs: unexpected EOF");
3855: return(0);
3856: };
3857: /* recover connectivity among runs, on the assumption that they
3858: are still in increasing lexicographic order on (y,xs) */
3859: fix_lag(orp-ff,(char *)ff,Runs_ff);
3860: if(ori!=runs) {
3861: err("frdb_g4_runfs: expected %d runs, but read %d",runs,ori);
3862: return(-1);
3863: };
3864: if((g4_bytes=bclose(bf))!=bytes) {
3865: err("frdb_g4_runfs: expected %d bytes, but read %d",
3866: bytes,g4_bytes);
3867: return(-1);
3868: };
3869: if(ferror(fp)) return(-errno); else return(1);
3870: }
3871: #else
3872: int frdb_g4_runfs(fp,bxp,runs,ff)
3873: FILE *fp;
3874: Bbx *bxp; /* exact bounding box, shrink-wrapped to fit */
3875: int runs; /* expect exactly this number of runs */
3876: RunF *ff; /* space for `runs' RunFs */
3877: { abort("frdb_g4_runfs: unimplemented on Cray");
3878: }
3879: #endif
3880:
3881: /* Write blob, etc to FILE *fp in binary format.
3882: If !(etc&IsBlob), then do nothing.
3883: else write Blob record and:
3884: If etc&IsRun, then also try to write Runs:
3885: If Blob.runs==0, write no runs.
3886: else
3887: if etc&Runs_g4, write in CCITT G4 format
3888: compact but needs large streams; may not port well;
3889: else write in Runs_ff format
3890: if blob is small enough, use compressed RunFS form on output.
3891:
3892: */
3893: fwrb_blob_etc(fp,bp,etc)
3894: FILE *fp;
3895: Blob *bp;
3896: Ident etc;
3897: { Ident sv_ident;
3898: int sv_runs;
3899: Run *rp;
3900: RunF rf;
3901: register RunF *rfp, *rfq;
3902: RunFS *rsp;
3903: #if FWRI
3904: RunFS rfs;
3905: #else
3906: static RunFS rfsa[256];
3907: #endif
3908: int ri;
3909: if(!(etc&IsBlob)) return;
3910:
3911: sv_ident = bp->ident;
3912: sv_runs = bp->runs;
3913: if(etc&IsRun) {
3914: /* decide which Runs_* bits should be set on output */
3915: bp->ident &= ~(Runs_f|Runs_ff|Runs_seek|Runs_g4);
3916: if(etc&Runs_g4) {
3917: bp->ident |= Runs_g4;
3918: }
3919: else { /* assume Runs_ff is wanted */
3920: bp->ident |= Runs_ff;
3921: };
3922: }
3923: else { bp->ident &= ~(IsRun|Runs_f|Runs_ff|Runs_seek|Runs_g4);
3924: bp->runs = 0;
3925: };
3926: fwrb_blob(fp,bp);
3927: bp->ident = sv_ident;
3928: bp->runs = sv_runs;
3929:
3930: if(bp->runs==0) return;
3931:
3932: if(etc&Runs_g4) {
3933: /* write CCITT Group 4 encoding for Runs */
3934: if(bp->ident&Runs_ff) {
3935: fwrb_runfs_g4(fp,&(bp->bx),bp->runs,bp->r.ff);
3936: }
3937: else abort("fwrb_blob_etc: etc&Runs_g4 but !(id&Runs_ff)");
3938: }
3939: else { /* Assume Runs_ff format is desired */
3940: if(bp->ident&Runs_f) {
3941: rp=bp->r.f;
3942: if(bp->ident&Blob_small) { /* use compressed Run records */
3943: if(blob_debug) err("small");
3944: /* can use small local static array */
3945: #if FWRI
3946: rsp= &rfs;
3947: #else
3948: rsp=rfsa;
3949: #endif
3950: while(rp!=NULL) {
3951: /* y, xs, xe will be relative to Blob.bx.a */
3952: rsp->y = rp->y - bp->bx.a.y;
3953: rsp->xs = rp->xs - bp->bx.a.x;
3954: rsp->xe = rp->xe - bp->bx.a.x;
3955: /* above,below connecting run indices are relative to
3956: the sequence no. of this run (ac>0 & bc>0) */
3957: if((rsp->ad = rp->ad)!=0)
3958: rsp->ac = rp->u.no - rp->ac->u.no;
3959: else rsp->ac = 0;
3960: if((rsp->bd = rp->bd)!=0)
3961: rsp->bc = rp->bc->u.no - rp->u.no;
3962: else rsp->bc = 0;
3963: if(blob_debug) err_runfs(" ",rsp);
3964: rp=rp->n;
3965: #if FWRI
3966: fwri_RunFS(fp,rsp);
3967: #else
3968: rsp++;
3969: #endif
3970: };
3971: #if !FWRI
3972: if(fwrite(rfsa,sizeof(RunFS),bp->runs,fp)!=bp->runs)
3973: abort("fwrb_blob_etc: can't fwrite RunFS[%d]",bp->runs);
3974: if(dbg_fwrb_runs)
3975: err("fwrb_blob_etc: %d bytes",bp->runs*sizeof(RunFS));
3976: #endif
3977: }
3978: else { if(blob_debug) err("large");
3979: while(rp!=NULL) {
3980: /* y, xs, xe will be relative to Blob.bx.a */
3981: rf.y = rp->y - bp->bx.a.y;
3982: rf.xs = rp->xs - bp->bx.a.x;
3983: rf.xe = rp->xe - bp->bx.a.x;
3984: /* above,below connecting run indices are relative to
3985: the sequence no. of this run (ac>0 & bc>0) */
3986: if((rf.ad = rp->ad)!=0)
3987: rf.ac = rp->u.no - rp->ac->u.no;
3988: else rf.ac = 0;
3989: if((rf.bd = rp->bd)!=0)
3990: rf.bc = rp->bc->u.no - rp->u.no;
3991: else rf.bc = 0;
3992: if(blob_debug) err_runf(" ",&rf);
3993:
3994: /* since there may be many, won't use a local array */
3995: #if FWRI
3996: fwri_RunF(fp,&rf);
3997: #else
3998: if(fwrite(&rf,sizeof(RunF),1,fp)!=1)
3999: abort("fwrb_blob_etc: can't fwrite RunF");
4000: #endif
4001: rp=rp->n;
4002: };
4003: if(dbg_fwrb_runs)
4004: err("fwrb_blob_etc: %d bytes",bp->runs*sizeof(RunF));
4005: };
4006: }
4007: else if(bp->ident&Runs_ff) {
4008: if(bp->ident&Blob_small) { /* use compressed Run records */
4009: if(blob_debug) err("small");
4010: /* can use small local static array */
4011: #if FWRI
4012: rsp= &rfs;
4013: #else
4014: rsp=rfsa;
4015: #endif
4016: for(rfp=bp->r.ff,ri=0; ri<bp->runs; rfp++,ri++) {
4017: rsp->y = rfp->y;
4018: rsp->xs = rfp->xs;
4019: rsp->xe = rfp->xe;
4020: rsp->ad = rfp->ad;
4021: rsp->bd = rfp->bd;
4022: rsp->ac = rfp->ac;
4023: rsp->bc = rfp->bc;
4024: #if FWRI
4025: fwri_RunFS(fp,rsp);
4026: #else
4027: rsp++;
4028: #endif
4029: };
4030: #if !FWRI
4031: if(fwrite(rfsa,sizeof(RunFS),bp->runs,fp)!=bp->runs)
4032: abort("fwrb_blob_etc: can't fwrite RunFS[%d]",bp->runs);
4033: if(dbg_fwrb_runs)
4034: err("fwrb_blob_etc: %d bytes",bp->runs*sizeof(RunFS));
4035: #endif
4036: }
4037: else { if(blob_debug) err("large");
4038: #if FWRI
4039: for(rfq=(rfp=bp->r.ff)+bp->runs; rfp<rfq; rfp++) {
4040: fwri_RunF(fp,rfp);
4041: };
4042:
4043: #else
4044: if(fwrite(bp->r.ff,sizeof(RunF),bp->runs,fp)!=bp->runs)
4045: abort("fwrb_blob_etc: can't fwrite RunF[%d]",bp->runs);
4046: if(dbg_fwrb_runs)
4047: err("fwrb_blob_etc: %d bytes",bp->runs*sizeof(RunF));
4048: #endif
4049: };
4050: };
4051: };
4052: }
4053:
4054: /* Read a given Blob's RunF's (binary) from FILE *fp; return F on EOF.
4055: If bp->runs<=max, read the RunF's into bp->r.ff, and set Runs_ff bit.
4056: otherwise ignore them all and set bp->r.ff==NULL. */
4057: int frdb_runfs(fp,bp,max)
4058: FILE *fp;
4059: Blob *bp; /* *bp's fields already set up */
4060: int max; /* maximum no. RunF records expected */
4061: { register RunFS *rsp,*rsq;
4062: static RunFS rfsa[256];
4063: register RunF *rfp,*rfq;
4064: if(bp->r.ff!=NULL && bp->runs <= max) {
4065: bp->ident |= Runs_ff; bp->ident &= ~(Runs_f|Runs_seek);
4066: if(bp->ident&Blob_small) {
4067: if(blob_debug) err("small");
4068: #if FRDI
4069: for(rsq=(rsp=rfsa)+bp->runs; rsp<rsq; rsp++) {
4070: frdi_RunFS(fp,rsp);
4071: };
4072: #else
4073: if(fread(rfsa,sizeof(RunFS),bp->runs,fp) < bp->runs)
4074: return(0);
4075: #endif
4076: /* copy compressed RunFS's into RunF's */
4077: for(rsq=(rsp=rfsa)+bp->runs,rfp=bp->r.ff;
4078: rsp<rsq;
4079: rsp++,rfp++) {
4080: /* beware sign extension from unsigned chars */
4081: if(blob_debug) err_runfs(" ",rsp);
4082: rfp->y = 0377&rsp->y;
4083: rfp->xs = 0377&rsp->xs;
4084: rfp->xe = 0377&rsp->xe;
4085: rfp->ad = 0377&rsp->ad;
4086: rfp->bd = 0377&rsp->bd;
4087: rfp->ac = 0377&rsp->ac;
4088: rfp->bc = 0377&rsp->bc;
4089: };
4090: }
4091: else { if(blob_debug) err("large");
4092: #if FRDI
4093: for(rfq=(rfp=bp->r.ff)+bp->runs; rfp<rfq; rfp++)
4094: frdi_RunF(fp,rfp);
4095: #else
4096: if(fread(bp->r.ff,sizeof(RunF),bp->runs,fp) != bp->runs)
4097: return(F);
4098: #endif
4099: };
4100: }
4101: else { bp->ident &= ~(Runs_ff|Runs_f);
4102: bp->ident |= Runs_seek;
4103: bp->r.seek=ftell(fp);
4104: /* skip past excessive no. of runs */
4105: /** What if FRDI?? **/
4106: if(bp->ident&Blob_small)
4107: fseek(fp,(long)((bp->runs)*sizeof(RunFS)),1);
4108: else
4109: fseek(fp,(long)((bp->runs)*sizeof(RunF)),1);
4110: };
4111: if(ferror(fp)) return(-errno); else return(1);
4112: }
4113:
4114: #if FRDI
4115: /* read a Blob record (only) into *p */
4116: int frdb_blob(f,p)
4117: FILE *f;
4118: Blob *p;
4119: { int bdy_mny;
4120: *p = empty_Blob;
4121: if(feof(f))
4122: return(0);
4123: p->ident=frdi_Ident(f);
4124: /* p->no=frdi_Seq(f); */
4125: frdi_Bbx(f,&(p->bx));
4126: p->area=frdi_uint4(f);
4127: p->per=frdi_uint4(f);
4128: /* don't read .n */
4129: p->m=frdi_Merit(f);
4130: p->runs=frdi_uint3(f);
4131: if((bdy_mny=frdi_uint2(f))>0) {
4132: p->bdsp = alloc_bdys();
4133: p->bdsp->mny = bdy_mny;
4134: };
4135: #if dbg_frdb
4136: if((!(p->ident&IsBlob))||(p->ident&(IsALL&(~IsBlob))))
4137: err("frdb_blob: %s",blob_toa(p));
4138: #endif
4139: #if dbg_frdb_toa
4140: err("frdb_blob: %s",blob_toa(p));
4141: #endif
4142: if(ferror(f))
4143: return(-errno);
4144: else return(1);
4145: }
4146: #else
4147: /* read a Blob record (only) into *bp; return F if EOF */
4148: int frdb_blob(fp,bp)
4149: FILE *fp;
4150: Blob *bp;
4151: { BlobF bf;
4152: if(fread(&bf,sizeof(BlobF),1,fp)!=1) return(0);
4153: if(blob_debug) err_blobf("bf",&bf);
4154: bp->ident=bf.ident;
4155: bp->no = 0;
4156: bp->bx=bf.bx;
4157: bp->area=bf.area;
4158: /*bp->per=bf.per;*/
4159: bp->runs=bf.runs;
4160: /*bp->bdys=bf.bdys;*/
4161: bp->n = NULL;
4162: bp->r.f = NULL;
4163: bp->bdsp = NULL;
4164: #if dbg_frdb
4165: if((!(bp->ident&IsBlob))||(bp->ident&(IsALL&(~IsBlob))))
4166: err("frdb_blob: %s",blob_toa(bp));
4167: #endif
4168: #if dbg_frdb_toa
4169: err("frdb_blob: %s",blob_toa(bp));
4170: #endif
4171: if(ferror(fp)) return(-errno); else return(1);
4172: }
4173: #endif
4174:
4175: err_blob(s,bp)
4176: char *s;
4177: Blob *bp;
4178: { fprintf(stderr,"%s ",s);
4179: if(bp==NULL) fprintf(stderr,"Blob NULL.\n");
4180: else fprintf(stderr,
4181: "Blob %d: x[%d,%d],y[%d,%d] ar%d ft%s r(#%d f%d)\n",
4182: bp->no,bp->bx.a.x,bp->bx.b.x,bp->bx.a.y,bp->bx.b.y,
4183: bp->area,ident_toa(bp->ident),bp->runs,rp_tod(bp->r.f));
4184: }
4185:
4186: err_blob_runs(s,bp)
4187: char *s;
4188: Blob *bp;
4189: { Run *crp;
4190: char cs[20];
4191: fprintf(stderr,"%s ",s);
4192: err_blob(s,bp);
4193: if(bp!=NULL&&bp->runs>0&&bp->r.f!=NULL) {
4194: sprintf(cs,"%*s",strlen(s)+2," ");
4195: for(crp=bp->r.f; crp!=NULL; crp=crp->n) err_run(cs,crp);
4196: };
4197: }
4198:
4199: err_blob_runfs(s,bp)
4200: char *s;
4201: Blob *bp;
4202: { RunF *crp;
4203: int ri;
4204: char cs[20];
4205: fprintf(stderr,"%s ",s);
4206: err_blob_briefly("",bp);
4207: if(bp!=NULL&&bp->runs>0&&bp->r.ff!=NULL) {
4208: sprintf(cs,"%*s",strlen(s)+2," ");
4209: for(crp=bp->r.ff,ri=0; ri<bp->runs; crp++,ri++) err_runf(cs,crp);
4210: };
4211: }
4212:
4213: err_blobf(s,bp)
4214: char *s;
4215: BlobF *bp;
4216: { Run *crp;
4217: char cs[20];
4218: fprintf(stderr,"%s ",s);
4219: if(bp==NULL) fprintf(stderr,"BlobF NULL.\n");
4220: else fprintf(stderr,
4221: "BlobF: x[%d,%d],y[%d,%d] ar%d ft%s #r%d\n",
4222: bp->bx.a.x,bp->bx.b.x,bp->bx.a.y,bp->bx.b.y,
4223: bp->area,ident_toa(bp->ident),bp->runs);
4224: }
4225:
4226: err_blob_briefly(s,bp)
4227: char s[];
4228: Blob *bp;
4229: { Run *crp;
4230: if(bp==NULL) err("%s Blob NULL.",s);
4231: else { fprintf(stderr,
4232: "%s Blob #%d: bx(%d,%d),(%d,%d) ar%d f%s runs%d ",
4233: s,
4234: bp->no,
4235: bp->bx.a.x,bp->bx.a.y,bp->bx.b.x,bp->bx.b.y,
4236: bp->area,
4237: ident_toa(bp->ident),
4238: bp->runs);
4239: fprintf(stderr,"\n");
4240: };
4241: }
4242:
4243: err_blob_stats()
4244: { err("Blob stats: %d now, %d total, %d hi-water\n",
4245: blob_max-blob_fr_mny,hi_blob_no+1,blob_hi);
4246: }
4247:
4248: /* write blob list starting at fi */
4249: fwrb_blobl_etc(fp,mny,fi,etc)
4250: FILE *fp;
4251: int mny;
4252: Blob *fi;
4253: Ident etc;
4254: { int bi;
4255: Blob *bp;
4256: if(mny>0) for(bi=0,bp=fi; bi<mny; bi++,bp=bp->n) {
4257: if(bp!=NULL) fwrb_blob_etc(fp,bp,etc);
4258: else { err("fwrb_blobl_etc: bmny==%d but %dth (Blob *) is NULL",
4259: mny,bi);
4260: break;
4261: };
4262: };
4263: }
4264:
4265: fwrb_blobs_etc(fp,bs,etc)
4266: FILE *fp;
4267: Blobs bs;
4268: Ident etc;
4269: { register Blob *bp,**bpp;
4270: if(bs.mny==0) return;
4271: for(bp= *(bpp=bs.bpa); bp!=NULL; bp= *(++bpp))
4272: fwrb_blob_etc(fp,bp,etc);
4273: }
4274:
4275: /* read a set of blobs, and their parts */
4276: frdb_blobs_etc(fp,bsp,etc)
4277: FILE *fp;
4278: Blobs *bsp;
4279: Ident etc; /* read only the parts indicated */
4280: { int bi;
4281: register Blob *bp,**bpp;
4282: if(bsp->mny<=0) {
4283: *bsp = empty_Blobs;
4284: return(1);
4285: };
4286:
4287: if((bpp=bsp->bpa=(Blob **)malloc((bsp->mny+1)*sizeof(Blob *)))==NULL)
4288: abort("frdb_blobs_etc: can't alloc Blobs.bpa[%d]",bsp->mny+1);
4289: for(bi=0; bi<bsp->mny; bi++) {
4290: *(bpp++) = bp = alloc_blob();
4291: if(!frdb_blob_etc(fp,bp,etc))
4292: abort("frdb_blobs_etc: unexpected EOF");
4293: };
4294: *bpp = NULL;
4295: if(ferror(fp)) return(-errno); else return(1);
4296: }
4297:
4298: /* Read a blob record into *bp, and then read its parts as specified by etc.
4299: If there aren't any runs, return normally.
4300: If etc&IsRun is false, then set Runs_seek and proceed as described below.
4301: If etc&Runs_ff, then the contents of r.ff is examined:
4302: if NULL, then space is allocated here for `runs' RunF's;
4303: if non-NULL, then on the assumption that it points to space for
4304: at least `runs' many, they are read into it.
4305: If etc&Runs_seek, then the ftell value is placed in r.seek,
4306: and the runs are simply skipped over.
4307: The Runs_f (list) option is unimplemented.
4308: The Blob is marked with the appropriate Runs_X bit.
4309: Return: 1 if normal & successful, 0 if EOF, and -1 if error.
4310: */
4311: int frdb_blob_etc(fp,bp,etc)
4312: FILE *fp;
4313: Blob *bp;
4314: Ident etc;
4315: { int stat;
4316: if((stat=frdb_blob(fp,bp))!=1)
4317: return(stat);
4318: if(bp->runs<=0) {
4319: bp->runs = 0;
4320: bp->r.ff = NULL;
4321: bp->ident &= ~(Runs_f|Runs_seek|Runs_g4);
4322: bp->ident |= Runs_ff;
4323: return(1);
4324: };
4325:
4326: if(!(etc&IsRun)) {
4327: etc |= IsRun|Runs_seek;
4328: etc &= ~(Runs_f|Runs_ff|Runs_g4);
4329: };
4330: if (!(etc&(Runs_f|Runs_ff|Runs_g4|Runs_seek)) || etc&Runs_ff) {
4331: /* Want to deliver Runs in Runf ff[] format */
4332: if(bp->r.ff==NULL) {
4333: if( (bp->r.ff=
4334: (RunF *)malloc(bp->runs*sizeof(RunF)))==NULL)
4335: abort("frdb_blob_etc: can't alloc r.ff[%d]",bp->runs);
4336: };
4337: if(bp->ident&Runs_g4) {
4338: /* Runs are in CCITT Group 4 format */
4339: stat=frdb_g4_runfs(fp,&(bp->bx),bp->runs,bp->r.ff);
4340: }
4341: else { /* Runs are in RunF or RunFS format */
4342: stat=frdb_runfs(fp,bp,bp->runs);
4343: };
4344: bp->ident |= Runs_ff; bp->ident &= ~(Runs_f|Runs_seek|Runs_g4);
4345: return(stat);
4346: }
4347: else if(etc&Runs_seek) {
4348: bp->ident |= Runs_seek; bp->ident &= ~(Runs_ff|Runs_f);
4349: bp->r.seek=ftell(fp); /* save seek addr */
4350: /* skip past runs */
4351: if(bp->ident&Blob_small)
4352: fseek(fp,(long)((bp->runs)*sizeof(RunFS)),1);
4353: else fseek(fp,(long)((bp->runs)*sizeof(RunF)),1);
4354: }
4355: else /* (etc&Runs_f) || (etc&Runs_g4) */ {
4356: abort("frdb_blob_etc: Runs_f & Runs_g4 etc option unimplemented");
4357: };
4358: if(ferror(fp)) return(-errno); else return(1);
4359: }
4360:
4361: /* read a number of blobs, and their parts, into linked-list (mny, *fi);
4362: return T iff not EOF */
4363: boolean frdb_blobl_etc(fp,bmny,fip,etc)
4364: FILE *fp;
4365: int bmny;
4366: Blob **fip;
4367: Ident etc;
4368: { int bi;
4369: register Blob *bp,**bpp;
4370: RunF *rp;
4371: int stat;
4372: if(bmny<=0) return(1);
4373: bi=0; bpp=fip;
4374: do { bp=alloc_blob();
4375: if((stat=frdb_blob_etc(fp,bp,etc))!=1) return(stat);
4376: *bpp=bp; bpp= &(bp->n);
4377: }
4378: while((++bi)<bmny);
4379: *bpp=NULL;
4380: if(ferror(fp)) return(-errno); else return(1);
4381: }
4382:
4383: char *interp_toa(ip)
4384: Interp *ip;
4385: { static char s[80];
4386: char ms[3],shs[3],szs[3],hts[3],prs[3];
4387: strcpy(ms,merit_toa(ip->m));
4388: strcpy(shs,merit_toa(ip->mshap));
4389: strcpy(szs,merit_toa(ip->msize));
4390: strcpy(hts,merit_toa(ip->mbhgt));
4391: strcpy(prs,merit_toa(ip->p));
4392: sprintf(s,"%s %s sz%s ba%d m%s (sh%s sz%s ht%s) p%s",
4393: ident_toa(ip->ident),
4394: #if CPU!=CRAY
4395: classid_toa(&(ip->ci)),
4396: #else
4397: ip->ci.c,
4398: #endif
4399: pts_toa(ip->size),
4400: ip->basl,
4401: ms,shs,szs,hts,prs);
4402: return(s);
4403: }
4404:
4405: frdb_interpl_etc(fp,ilp,etc)
4406: FILE *fp;
4407: Interpl *ilp;
4408: Ident etc;
4409: { int ii,stat;
4410: Interp *ip,*pp;
4411: if(ilp->mny<=0) {
4412: *ilp = empty_Interpl;
4413: return(1);
4414: };
4415:
4416: for(ii=0; ii<ilp->mny; ii++) {
4417: ip=alloc_interp();
4418: if(ii==0) ilp->fi = ip;
4419: else pp->n = ip;
4420: if((stat=frdb_interp(fp,ip))!=1) return(stat);
4421: pp=ip;
4422: };
4423: ip->n = NULL;
4424: if(ferror(fp)) return(-errno); else return(1);
4425: }
4426:
4427: #if FRDI
4428: int frdb_interp(f,p)
4429: FILE *f;
4430: Interp *p;
4431: { int stat;
4432: *p = empty_Interp;
4433: if(feof(f))
4434: return(0);
4435: p->ident=frdi_Ident(f);
4436: frdi_ClassId(f,&(p->ci));
4437: p->mshap=frdi_Merit(f);
4438: p->size=frdi_Pts(f);
4439: p->msize=frdi_Merit(f);
4440: p->basl=frdi_Scoor(f);
4441: p->mbhgt=frdi_Merit(f);
4442: p->m=frdi_Merit(f);
4443: p->p=frdi_Prob(f);
4444: #if dbg_frdb
4445: if((!(p->ident&IsInterp))||(p->ident&(IsALL&(~IsInterp))))
4446: err("frdb_interp: %s",interp_toa(p));
4447: #endif
4448: if(ferror(f)) return(-errno); else return(1);
4449: }
4450: #else
4451: int frdb_interp(fp,ip)
4452: FILE *fp;
4453: Interp *ip;
4454: { InterpF inf;
4455: int stat;
4456: if((stat=fread(&inf,sizeof(InterpF),1,fp))!=1) {
4457: err("can't fread InterpF, status %d",stat);
4458: return(stat);
4459: };
4460: *ip = empty_Interp;
4461: ip->ident = inf.ident;
4462: ip->ci = inf.ci;
4463: ip->clp = NULL;
4464: ip->clsp = NULL;
4465: ip->mshap = inf.mshap;
4466: ip->size = inf.size;
4467: ip->msize = inf.msize;
4468: ip->basl = inf.basl;
4469: ip->mbhgt = inf.mbhgt;
4470: ip->m = inf.m;
4471: #if dbg_frdb
4472: if((!(ip->ident&IsInterp))||(ip->ident&(IsALL&(~IsInterp))))
4473: err("frdb_interp: %s",interp_toa(ip));
4474: #endif
4475: if(ferror(fp)) return(-errno); else return(1);
4476: }
4477: #endif
4478:
4479: free_interpl(ilp)
4480: Interpl *ilp;
4481: { int ii;
4482: Interp *ip,*np;
4483: if(ilp->mny>0) {
4484: for(ip=ilp->fi; ip!=NULL; ip=np) { np=ip->n; free_interp(ip); }
4485: ilp->mny=0;
4486: };
4487: ilp->fi=NULL;
4488: };
4489:
4490: fwrb_interpl_etc(fp,is,etc)
4491: FILE *fp;
4492: Interpl is;
4493: Ident etc;
4494: { Interp *ip;
4495: int ii;
4496: if(is.mny>0) for(ii=0,ip=is.fi; ii<is.mny; ii++,ip=ip->n)
4497: fwrb_interp_etc(fp,ip,etc);
4498: }
4499:
4500: /* remove this Interp from the Interp-list */
4501: remove_interpl(ip,ilp)
4502: Interp *ip;
4503: Interpl *ilp;
4504: { Interp *rp,*pp;
4505: if(ilp->mny==1) { /* frequent case */
4506: ilp->fi=NULL; ilp->mny=0;
4507: }
4508: else if(ilp->mny>1){
4509: pp=NULL;
4510: for(rp=ilp->fi; rp!=ip&&rp!=NULL; pp=rp,rp=rp->n) ;
4511: if(rp!=NULL) { /* remove from list */
4512: if(pp==NULL) ilp->fi=ip->n;
4513: else pp->n=ip->n;
4514: ilp->mny--;
4515: }
4516: else err("remove_interpl: can't - not found");
4517: }
4518: else err("remove_interpl: can't - Interpl empty");
4519: }
4520:
4521: /* prepend this Interp to the Interp-list */
4522: prepend_interpl(ip,ilp)
4523: Interp *ip;
4524: Interpl *ilp;
4525: { Interp *rp,*pp;
4526: ip->n = ilp->fi;
4527: ilp->fi = ip;
4528: ilp->mny++;
4529: }
4530:
4531: fwrb_interp_etc(fp,ip,etc)
4532: FILE *fp;
4533: Interp *ip;
4534: Ident etc;
4535: { fwrb_interp(fp,ip);
4536: }
4537:
4538: #if FWRI
4539: fwrb_interp(f,p)
4540: FILE *f;
4541: Interp *p;
4542: { InterpF inf;
4543: int stat;
4544: #if dbg_fwrb
4545: if((!(p->ident&IsInterp))||(p->ident&(IsALL&(~IsInterp))))
4546: err("fwrb_interp: %s",interp_toa(p));
4547: #endif
4548: fwri_Ident(f,p->ident);
4549: fwri_ClassId(f,&(p->ci));
4550: fwri_Merit(f,p->mshap);
4551: fwri_Pts(f,p->size);
4552: fwri_Merit(f,p->msize);
4553: fwri_Scoor(f,p->basl);
4554: fwri_Merit(f,p->mbhgt);
4555: fwri_Merit(f,p->m);
4556: fwri_Prob(f,p->p);
4557: #if dbg_fwrb_toa
4558: err("fwrb_interp: %s",interp_toa(p));
4559: #endif
4560: }
4561: #else
4562: fwrb_interp(fp,ip)
4563: FILE *fp;
4564: Interp *ip;
4565: { InterpF inf;
4566: int stat;
4567: #if dbg_fwrb
4568: if((!(ip->ident&IsInterp))||(ip->ident&(IsALL&(~IsInterp))))
4569: err("fwrb_interp: %s",interp_toa(ip));
4570: #endif
4571: memset(&inf,'\0',sizeof(inf));
4572: inf.ident = ip->ident;
4573: inf.ci = ip->ci;
4574: inf.mshap = ip->mshap;
4575: inf.size = ip->size;
4576: inf.msize = ip->msize;
4577: inf.basl = ip->basl;
4578: inf.mbhgt = ip->mbhgt;
4579: inf.m = ip->m;
4580: if((stat=fwrite(&inf,sizeof(InterpF),1,fp))!=1)
4581: abort("fwrb_interp: can't fwrite, status %d",stat);
4582: #if dbg_fwrb_toa
4583: err("fwrb_interp: %s",interp_toa(ip));
4584: #endif
4585: }
4586: #endif
4587:
4588: /** Run handling:
4589: alloc_run_pool -create pool of free run records
4590: free_run_pool - free entire pool
4591: alloc_run - allocate a new run from pool
4592: free_run - free a specified run (into pool)
4593: err_run - print Run (ascii) to stderr
4594: err_runb - print Run (ascii) to stderr (after added to blob set)
4595: err_runf - print RunF (ascii) to stderr (after added to blob set)
4596: err_runfs - print RunFS (ascii) to stderr (after added to blob set)
4597: err_run_stats - report statistics to stderr
4598: **/
4599:
4600: /* RunPool functions: variable-size pool, speed-optimized alloc/free */
4601:
4602: /* Initialize pool of Runs with increment `incr' (return F if can't allocate) */
4603: boolean alloc_run_pool(incr,dbg)
4604: int incr;
4605: boolean dbg; /* trace actions on Runs */
4606: { register Run *crp, *prp;
4607: register int i;
4608: _RunPool.incr = incr;
4609: _RunPool.pools = 1;
4610: if((_RunPool.pool=(Run **)malloc(_RunPool.pools*sizeof(Run *)))==NULL)
4611: return(F);
4612: if((_RunPool.pool[_RunPool.pools-1] =
4613: (Run *)malloc(_RunPool.incr*sizeof(Run)))==NULL) {
4614: free(_RunPool.pool);
4615: return(F);
4616: };
4617: _RunPool.next = 0;
4618: _RunPool.free = NULL;
4619: #if STATS
4620: _RunPool.total = 0;
4621: #endif
4622: _RunPool.dbg = dbg;
4623: if(_RunPool.dbg) err("alloc_run_pool: incr%d",_RunPool.incr);
4624: return(T);
4625: }
4626:
4627: free_run_pool()
4628: { register int i;
4629: for(i=0; i<_RunPool.pools; i++) free(_RunPool.pool[i]);
4630: free(_RunPool.pool);
4631: }
4632:
4633: /* The ``hard'' case of allocating runs from RunPool: can't be inline */
4634: Run *hard_alloc_run()
4635: { _RunPool.pools++;
4636: if((_RunPool.pool=
4637: (Run **)realloc(_RunPool.pool,_RunPool.pools*sizeof(Run *)))==NULL)
4638: abort("alloc_Run: can't realloc");
4639: if((_RunPool.cur=_RunPool.pool[_RunPool.pools-1] =
4640: (Run *)malloc(_RunPool.incr*sizeof(Run)))==NULL)
4641: abort("alloc_Run: can't malloc");
4642: _RunPool.next=1;
4643: *(_RunPool.cur) = empty_Run;
4644: return(_RunPool.cur);
4645: }
4646:
4647: int rp_tod(rp)
4648: Run *rp;
4649: { return((int)rp);
4650: }
4651:
4652: char *runf_toa(rp)
4653: RunF *rp;
4654: { static char s[80];
4655: char s1[80];
4656: strcpy(s,"RunF ");
4657: if(rp==NULL) strcat(s,"NULL");
4658: else { sprintf(s1,
4659: "y%d,x[%d,%d] lag(ad%d,bd%d ac%d,bc%d)",
4660: rp->y,rp->xs,rp->xe,
4661: rp->ad,rp->bd, rp->ac,rp->bc );
4662: strcat(s,s1);
4663: };
4664: return(s);
4665: }
4666:
4667: char *runfs_toa(rp)
4668: RunFS *rp;
4669: { static char s[80];
4670: char s1[80];
4671: strcpy(s,"RunFS ");
4672: if(rp==NULL) strcat(s,"NULL");
4673: else { sprintf(s1,
4674: "y%d,x[%d,%d] lag(ad%d,bd%d ac%d,bc%d)",
4675: rp->y,rp->xs,rp->xe,
4676: rp->ad,rp->bd, rp->ac,rp->bc );
4677: strcat(s,s1);
4678: };
4679: return(s);
4680: }
4681:
4682: err_run(s,rp)
4683: char *s;
4684: Run *rp;
4685: { fprintf(stderr,"%s ",s);
4686: if(rp==NULL) fprintf(stderr,"Run NULL.\n");
4687: else fprintf(stderr,
4688: "Run %d: y%d,x[%d,%d] l(n%d) t(o%x ad%d,bd%d ac%d,bc%d)\n",
4689: rp_tod(rp), rp->y,rp->xs,rp->xe,
4690: rp_tod(rp->n),
4691: #if CPU!=CRAY
4692: (int)rp->u.o,
4693: #else
4694: 0,
4695: #endif
4696: rp->ad,rp->bd,
4697: rp_tod(rp->ac),
4698: rp_tod(rp->bc) );
4699: }
4700:
4701: /* print Run after it has been added to Blob set */
4702: err_runb(s,rp)
4703: char *s;
4704: Run *rp;
4705: { fprintf(stderr,"%s ",s);
4706: if(rp==NULL) fprintf(stderr,"Run NULL.\n");
4707: else fprintf(stderr,
4708: "Run %d: y%d,x[%d,%d] l(n%d) t(no%d ad%d,bd%d ac%d,bc%d)\n",
4709: rp_tod(rp), rp->y,rp->xs,rp->xe,
4710: rp_tod(rp->n),
4711: rp->u.no, rp->ad,rp->bd, rp_tod(rp->ac),rp_tod(rp->bc) );
4712: }
4713:
4714: err_runf(s,rp)
4715: char *s;
4716: RunF *rp;
4717: { fprintf(stderr,"%s ",s);
4718: if(rp==NULL) fprintf(stderr,"RunF NULL.\n");
4719: else fprintf(stderr,
4720: "RunF: y%d,x[%d,%d] t(ad%d,bd%d ac%d,bc%d)\n",
4721: rp->y,rp->xs,rp->xe,
4722: rp->ad,rp->bd, rp->ac,rp->bc );
4723: }
4724:
4725: err_runfs(s,rp)
4726: char *s;
4727: RunFS *rp;
4728: { RunF rf;
4729: rf.y = 0377&rp->y;
4730: rf.xs = 0377&rp->xs;
4731: rf.xe = 0377&rp->xe;
4732: rf.ad = 0377&rp->ad;
4733: rf.bd = 0377&rp->bd;
4734: rf.ac = 0377&rp->ac;
4735: rf.bc = 0377&rp->bc;
4736: err_runf(s,&rf);
4737: }
4738:
4739: int runs_of_blob(p,ra,max)
4740: Blob *p;
4741: RLE_Yrun *ra;
4742: int max;
4743: { int runs,ri;
4744: RunF *rfp;
4745: runs = p->runs;
4746: if(runs>max) {
4747: err("runs_of_blob: max exceeded - skip this blob");
4748: runs = 0;
4749: }
4750: else if(runs>0) {
4751: if(p->ident&Runs_ff) {
4752: for(ri=0,rfp=p->r.ff; ri<runs; ri++,rfp++) {
4753: ra->y = p->bx.a.y + rfp->y;
4754: ra->xs = p->bx.a.x + rfp->xs;
4755: ra->xe = p->bx.a.x + rfp->xe;
4756: ra++;
4757: };
4758: }
4759: else { err("runs_of_blob: handle only Runs_ff - skip this blob");
4760: runs = 0;
4761: };
4762: };
4763: return(runs);
4764: }
4765:
4766: int no_runs_of_blobl(p)
4767: Blobl *p;
4768: { int runs;
4769: Blob *pp;
4770: runs = 0;
4771: if(p->mny>0) for(pp=p->fi; pp!=NULL; pp=pp->n) runs += pp->runs;
4772: return(runs);
4773: }
4774:
4775: int runs_of_blobl(p,ra,max)
4776: Blobl *p;
4777: RLE_Yrun *ra;
4778: int max;
4779: { int runs;
4780: Blob *pp;
4781: runs = 0;
4782: if(p->mny>0) for(pp=p->fi; pp!=NULL; pp=pp->n)
4783: runs += runs_of_blob(pp,ra+runs,max-runs);
4784: return(runs);
4785: }
4786:
4787: int no_runs_of_char(p)
4788: Char *p;
4789: { int runs;
4790: Blobl bl;
4791: runs = 0;
4792: bl.mny = p->bmny; bl.fi = p->fi;
4793: runs += no_runs_of_blobl(&bl);
4794: return(runs);
4795: }
4796:
4797: int runs_of_char(p,ra,max)
4798: Char *p;
4799: RLE_Yrun *ra;
4800: int max;
4801: { int runs;
4802: Blobl bl;
4803: runs = 0;
4804: bl.mny = p->bmny; bl.fi = p->fi;
4805: runs += runs_of_blobl(&bl,ra,max);
4806: return(runs);
4807: }
4808:
4809: /* ascending lexicographic order on y,xs */
4810: int rn_asc(r1,r2)
4811: RLE_Yrun *r1,*r2;
4812: { if(r1->y < r2->y) return(-1);
4813: else if(r1->y==r2->y) {
4814: if(r1->xs < r2->xs) return(-1);
4815: else if (r1->xs == r2->xs) return(0);
4816: else return(1);
4817: }
4818: else return(1);
4819: }
4820:
4821: RLE_Lines *rlines_of_char(chp)
4822: Char *chp;
4823: { static RLE_Lines rls;
4824: int no_runs,cy,ri;
4825: RLE_Run *lr;
4826: RLE_Yrun *ra,*cr;
4827: RLE_Line *cl;
4828: /* count runs */
4829: no_runs = no_runs_of_char(chp);
4830: /* allocate runs array */
4831: if((ra=(RLE_Yrun *)malloc(no_runs*sizeof(RLE_Yrun)))==NULL)
4832: abort("rlines_of_char: can't malloc ra[%d]",no_runs);
4833: runs_of_char(chp,ra,no_runs);
4834: /* sort runs ascending on (y,xs) */
4835: qsort(ra,no_runs,sizeof(RLE_Yrun),rn_asc);
4836: /* count RLE_lines.mny */
4837: rls.mny = 0; cy=Scoor_MIN;
4838: for(ri=0,cr=ra; ri<no_runs; ri++,cr++)
4839: if(cr->y!=cy) {
4840: rls.mny++;
4841: cy = cr->y;
4842: };
4843: /* allocate RLE_lines */
4844: if((rls.rla=(RLE_Line *)malloc(rls.mny*sizeof(RLE_Line)))==NULL)
4845: abort("rlines_of_page: can't malloc rls.rla[%d]",rls.mny);
4846: /* fill in RLE_lines */
4847: cy=Scoor_MIN; cl=rls.rla-1;
4848: for(ri=0,cr=ra; ri<no_runs; ri++,cr++) {
4849: if(cr->y!=cy) {
4850: cl++;
4851: cl->y = cy = cr->y;
4852: cl->runs = 0;
4853: lr = cl->r;
4854: };
4855: lr->xs = cr->xs; lr->xe = cr->xe; lr++; cl->runs++;
4856: };
4857: free(ra);
4858: return(&rls);
4859: }
4860:
4861: int asc_merit(m1,m2)
4862: Merit *m1,*m2;
4863: { if(*m1 < *m2) return(-1);
4864: else if(*m1 > *m2) return(1);
4865: else return(0);
4866: }
4867:
4868: /* Word merit is computed as a function of the merit of its Chars.
4869: No Chars forces merit to 0.0.
4870: The result is dominated by the weakest merit in the Word, slightly
4871: improved by the others. */
4872: Merit wordmerit(w)
4873: Word *w;
4874: { register Char *cp,**cpp;
4875: static int m_alloc = 0;
4876: static Merit *ma; /* ma[m_alloc] */
4877: int mi;
4878: Merit m;
4879: double wgt,sumwgt;
4880:
4881: if(w->cs.mny<=0) return(0.0);
4882: if(w->cs.mny>m_alloc) {
4883: if(m_alloc==0) {
4884: m_alloc=w->cs.mny;
4885: if((ma=(Merit *)malloc(m_alloc*sizeof(Merit)))==NULL)
4886: abort("wordmerit: can't malloc ma[%d]",m_alloc);
4887: }
4888: else { m_alloc=w->cs.mny;
4889: if((ma=(Merit *)realloc(ma,m_alloc*sizeof(Merit)))==NULL)
4890: abort("wordmerit: can't realloc ma[%d]",m_alloc);
4891: };
4892: };
4893: for(cp= *(cpp=w->cs.cpa),mi=0; cp!=NULL; cp= *(++cpp),mi++) {
4894: if(cp->area==0 || cp->il.mny==0) ma[mi]=0.0;
4895: else ma[mi] = cp->il.fi->m;
4896: };
4897: qsort(ma,w->cs.mny,sizeof(Merit),asc_merit);
4898: #define DOM (5.0)
4899: /* The worst merit is DOM times more significant than second worst, which
4900: is DOM times more significant than the third worst, and so on.
4901: */
4902: m=ma[0]; sumwgt=wgt=1.0;
4903: for(mi=1; mi<w->cs.mny; mi++) {
4904: m += ma[mi]*(wgt /= DOM); sumwgt += wgt;
4905: };
4906: m /= sumwgt;
4907: return(m);
4908: }
4909:
4910: WordSet *alloc_wordset(top,cut,cap)
4911: double top; /* initial maximum merit (is never reduced) */
4912: double cut; /* cut ratio: don't keep merit < cut*top */
4913: int cap; /* capacity: maximum no. at a time (0 ==> no limit) */
4914: { WordSet *res;
4915: if((res=(WordSet *)malloc(sizeof(WordSet)))==NULL)
4916: abort("alloc_wordset: can't");
4917: *res = empty_WordSet;
4918: res->top = top;
4919: res->cut = cut;
4920: if((res->cap = cap)==0) res->cap=INT_MAX;
4921: return(res);
4922: }
4923:
4924: int free_wordset_etc(s,etc)
4925: WordSet *s;
4926: Ident etc;
4927: { int high;
4928: free_words_etc(&(s->ws),etc);
4929: high = s->high;
4930: free(s);
4931: return(high);
4932: }
4933:
4934: /* Find the maximum-merit word in the set; among ties, pick the first seen. */
4935: Word *find_max_wordset(s)
4936: WordSet *s;
4937: { register Word *max,**wpp;
4938: max=NULL;
4939: if(s->ws.mny>0) for(wpp=s->ws.wpa; *wpp!=NULL; wpp++) {
4940: if(max==NULL || max->m < (*wpp)->m) max=(*wpp);
4941: };
4942: return(max);
4943: }
4944:
4945: /* Find the maximum-merit word in the set; among ties, pick the last seen. */
4946: Word *find_min_wordset(s)
4947: WordSet *s;
4948: { register Word *min,**wpp;
4949: min=NULL;
4950: if(s->ws.mny>0) for(wpp=s->ws.wpa; *wpp!=NULL; wpp++) {
4951: if(min==NULL || min->m >= (*wpp)->m) min=(*wpp);
4952: };
4953: return(min);
4954: }
4955:
4956: /* Insert a Word (without duplicating it).
4957: Update top, min, max, & high.
4958: If the new word's merit is equal to the current maximum, it does not become
4959: become the new maximum.
4960: If the new word's merit is equal to the current minimum, it becomes
4961: the new minimum.
4962: */
4963: put_wordset(w,s)
4964: Word *w; /* must have w->m set up */
4965: WordSet *s;
4966: { insert_word(w,&(s->ws));
4967: if(max_wordset(s)==NULL || max_wordset(s)->m < w->m) {
4968: max_wordset(s) = w;
4969: if(s->top < max_wordmerit(s)) s->top = max_wordmerit(s);
4970: };
4971: if(min_wordset(s)==NULL || min_wordset(s)->m >= w->m)
4972: min_wordset(s) = w;
4973: if(s->high < s->ws.mny) s->high = s->ws.mny;
4974: }
4975:
4976: /* Remove a Word (without freeing it). Maintain min/max, but don't prune items.
4977: Also, don't lower top or high. */
4978: Word *get_wordset(w,s)
4979: Word *w;
4980: WordSet *s;
4981: { if(w==NULL || s->ws.mny==0) return(NULL);
4982: remove_word(w,&s->ws);
4983: if(s->ws.mny==0) {
4984: max_wordset(s) = NULL;
4985: min_wordset(s) = NULL;
4986: }
4987: else { if(w==max_wordset(s)) max_wordset(s) = find_max_wordset(s);
4988: if(w==min_wordset(s)) min_wordset(s) = find_min_wordset(s);
4989: };
4990: return(w);
4991: }
4992:
4993: /* Remove a Word (without freeing it). Maintain min/max. Don't lower top. */
4994: Word *remove_wordset(w,s,n)
4995: Word *w;
4996: WordSet *s;
4997: char *n;
4998: { register Word *gw;
4999: #if dbg_ws
5000: if(w!=NULL) err("remove_wordset: %X %s",w,word_toa(w));
5001: else err("remove_wordset: NULL");
5002: #endif
5003: gw=get_wordset(w,s);
5004: #if dbg_ws
5005: err_wordset(s,n);
5006: #endif
5007: return(gw);
5008: }
5009:
5010: /* Check whether a given Word is identical to any already in a given set.
5011: Word *w must have its hash key set up. */
5012: boolean member_wordset(w,s)
5013: Word *w;
5014: WordSet *s;
5015: { register Word **ww;
5016: if(s->ws.mny>0) {
5017: for(ww=s->ws.wpa; (*ww)!=NULL; ww++) {
5018: if(w->hash==(*ww)->hash && eq_word(w,(*ww)))
5019: return(T);
5020: };
5021: };
5022: return(F);
5023: }
5024:
5025: /* Insert a Word into a set, maintaining uniqueness, a ``range'' property, and
5026: a maximum capacity.
5027: Uniqueness is maintained by refusing to insert words that are identical
5028: (eq_word()) to a word already in the set (or in set `u').
5029: The range property is that every word in the set must have merit no less
5030: than `s->cut' times the lifetime maximum for the set `s->top'.
5031: Maximum capacity is maintained as follows: if insertion would mean more
5032: members than `cap', then either (a) the insertion is refused (if its
5033: merit is less than the current `min', or (b) the current `min' is deleted
5034: (and silently freed in its entirety), and the insertion occurs.
5035: The inserted Word is not duplicated. If, as a result of an insertion,
5036: some of its words no longer satisfy the range property, they are silently
5037: removed (and freed in their entirety).
5038: Return T iff the Word is actually inserted.
5039: */
5040: boolean insert_wordset(w,s,n,u)
5041: Word *w;
5042: WordSet *s;
5043: char *n; /* name of set `s' */
5044: WordSet *u; /* if !=NULL, also check uniqueness here */
5045: { Word *fr;
5046: #if dbg_ws
5047: err("insert_wordset: %X %s",w,word_toa(w));
5048: #endif
5049: if((w->m = wordmerit(w)) >= (s->cut * s->top)) {
5050: w->hash = hash_word(w);
5051: if(member_wordset(w,s) || (u!=NULL&&member_wordset(w,u)))
5052: /* don't insert */
5053: return(F);
5054: if(s->ws.mny==s->cap) /* at capacity */ {
5055: if(w->m <= min_wordmerit(s)) /* too poor */ return(F);
5056: else { fr = remove_wordset(min_wordset(s),s);
5057: free_word_etc(fr,IsALL);
5058: };
5059: };
5060: put_wordset( w, s );
5061: if(max_wordset(s)==w) /* this has become the new maximum */ {
5062: while(min_wordmerit(s) < (s->cut * s->top)) {
5063: fr = remove_wordset(min_wordset(s),s);
5064: free_word_etc(fr,IsALL);
5065: };
5066: };
5067: #if dbg_ws
5068: err_wordset(s,n);
5069: #endif
5070: return(T);
5071: }
5072: else {
5073: #if dbg_ws
5074: err_wordset(s,n);
5075: #endif
5076: return(F);
5077: };
5078: }
5079:
5080: err_wordset(s,n)
5081: WordSet *s;
5082: char *n; /* name of set */
5083: { char m1[10],m2[10];
5084: register Word *wp,**wpp;
5085: fprintf( stderr,"WordSet %s: t%g c%g [%s/%X,%s/%X] m%d h%d: ",
5086: n,
5087: s->top,s->cut,
5088: strcpy(m1,merit_toa(max_wordmerit(s))),max_wordset(s),
5089: strcpy(m2,merit_toa(min_wordmerit(s))),min_wordset(s),
5090: s->ws.mny,s->high );
5091: if(s->ws.mny>0) for(wp= *(wpp=s->ws.wpa); wp!=NULL; wp= *(++wpp))
5092: fprintf(stderr,"%X/%s/%d ",wp,merit_toa(wp->m),wp->cs.mny);
5093: fprintf(stderr,"\n");
5094: }
5095:
5096: translate_txtln(lp,off)
5097: Txtln *lp;
5098: Sp off;
5099: { lp->bx = *translate_bbx(&lp->bx,off);
5100: lp->basl += off.y;
5101: translate_chars(lp->cs,off);
5102: }
5103:
5104: translate_chars(csp,off)
5105: Chars *csp;
5106: Sp off;
5107: { register Char *cp,**cpp;
5108: for(cp= *(cpp=csp->cpa); cp!=NULL; cp= *(++cpp))
5109: translate_char(cp,off);
5110: }
5111:
5112: translate_char(cp,off)
5113: Char *cp;
5114: Sp off;
5115: { cp->bx = *translate_bbx(&cp->bx,off);
5116: translate_blobl(cp,off);
5117: }
5118:
5119: translate_blobs(b,off)
5120: Blobs *b;
5121: Sp off;
5122: { register Blob *bp,**bpp;
5123: if(b->mny>0) for ( bp= *(bpp=b->bpa); bp!=NULL; bp= *(++bpp) )
5124: translate_blob(bp,off);
5125: }
5126:
5127: translate_blobl(cp,off)
5128: Char *cp;
5129: Sp off;
5130: { int bi;
5131: register Blob *bp;
5132: for(bi=0,bp=cp->fi; bi<cp->bmny&&bp!=NULL; bi++,bp=bp->n)
5133: translate_blob(bp,off);
5134: }
5135:
5136: translate_blob(bp,off)
5137: Blob *bp;
5138: Sp off;
5139: { bp->bx = *translate_bbx(&bp->bx,off);
5140: }
5141:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.