This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
701aa051d0afcf15cfad6d8518609baf9d743f61
[perl5.git] / form.c
1 /* $RCSfile: form.c,v $$Revision: 4.0.1.2 $$Date: 91/11/05 17:18:43 $
2  *
3  *    Copyright (c) 1991, Larry Wall
4  *
5  *    You may distribute under the terms of either the GNU General Public
6  *    License or the Artistic License, as specified in the README file.
7  *
8  * $Log:        form.c,v $
9  * Revision 4.0.1.2  91/11/05  17:18:43  lwall
10  * patch11: formats didn't fill their fields as well as they could
11  * patch11: ^ fields chopped hyphens on line break
12  * patch11: # fields could write outside allocated memory
13  * 
14  * Revision 4.0.1.1  91/06/07  11:07:59  lwall
15  * patch4: new copyright notice
16  * patch4: default top-of-form format is now FILEHANDLE_TOP
17  * 
18  * Revision 4.0  91/03/20  01:19:23  lwall
19  * 4.0 baseline.
20  * 
21  */
22
23 #include "EXTERN.h"
24 #include "perl.h"
25
26 /* Forms stuff */
27
28 void
29 form_parseargs(fcmd)
30 register FCMD *fcmd;
31 {
32     register int i;
33     register ARG *arg;
34     register int items;
35     STR *str;
36     ARG *parselist();
37     line_t oldline = curcmd->c_line;
38     int oldsave = savestack->ary_fill;
39
40     str = fcmd->f_unparsed;
41     curcmd->c_line = fcmd->f_line;
42     fcmd->f_unparsed = Nullstr;
43     (void)savehptr(&curstash);
44     curstash = str->str_u.str_hash;
45     arg = parselist(str);
46     restorelist(oldsave);
47
48     items = arg->arg_len - 1;   /* ignore $$ on end */
49     for (i = 1; i <= items; i++) {
50         if (!fcmd || fcmd->f_type == F_NULL)
51             fatal("Too many field values");
52         dehoist(arg,i);
53         fcmd->f_expr = make_op(O_ITEM,1,
54           arg[i].arg_ptr.arg_arg,Nullarg,Nullarg);
55         if (fcmd->f_flags & FC_CHOP) {
56             if ((fcmd->f_expr[1].arg_type & A_MASK) == A_STAB)
57                 fcmd->f_expr[1].arg_type = A_LVAL;
58             else if ((fcmd->f_expr[1].arg_type & A_MASK) == A_EXPR)
59                 fcmd->f_expr[1].arg_type = A_LEXPR;
60             else
61                 fatal("^ field requires scalar lvalue");
62         }
63         fcmd = fcmd->f_next;
64     }
65     if (fcmd && fcmd->f_type)
66         fatal("Not enough field values");
67     curcmd->c_line = oldline;
68     Safefree(arg);
69     str_free(str);
70 }
71
72 int newsize;
73
74 #define CHKLEN(allow) \
75 newsize = (d - orec->o_str) + (allow); \
76 if (newsize >= curlen) { \
77     curlen = d - orec->o_str; \
78     GROWSTR(&orec->o_str,&orec->o_len,orec->o_len + (allow)); \
79     d = orec->o_str + curlen;   /* in case it moves */ \
80     curlen = orec->o_len - 2; \
81 }
82
83 format(orec,fcmd,sp)
84 register struct outrec *orec;
85 register FCMD *fcmd;
86 int sp;
87 {
88     register char *d = orec->o_str;
89     register char *s;
90     register int curlen = orec->o_len - 2;
91     register int size;
92     FCMD *nextfcmd;
93     FCMD *linebeg = fcmd;
94     char tmpchar;
95     char *t;
96     CMD mycmd;
97     STR *str;
98     char *chophere;
99
100     mycmd.c_type = C_NULL;
101     orec->o_lines = 0;
102     for (; fcmd; fcmd = nextfcmd) {
103         nextfcmd = fcmd->f_next;
104         CHKLEN(fcmd->f_presize);
105         /*SUPPRESS 560*/
106         if (s = fcmd->f_pre) {
107             while (*s) {
108                 if (*s == '\n') {
109                     while (d > orec->o_str && (d[-1] == ' ' || d[-1] == '\t'))
110                         d--;
111                     if (fcmd->f_flags & FC_NOBLANK) {
112                         if (d == orec->o_str || d[-1] == '\n') {
113                             orec->o_lines--;    /* don't print blank line */
114                             linebeg = fcmd->f_next;
115                             break;
116                         }
117                         else if (fcmd->f_flags & FC_REPEAT)
118                             nextfcmd = linebeg;
119                         else
120                             linebeg = fcmd->f_next;
121                     }
122                     else
123                         linebeg = fcmd->f_next;
124                 }
125                 *d++ = *s++;
126             }
127         }
128         if (fcmd->f_unparsed)
129             form_parseargs(fcmd);
130         switch (fcmd->f_type) {
131         case F_NULL:
132             orec->o_lines++;
133             break;
134         case F_LEFT:
135             (void)eval(fcmd->f_expr,G_SCALAR,sp);
136             str = stack->ary_array[sp+1];
137             s = str_get(str);
138             size = fcmd->f_size;
139             CHKLEN(size);
140             chophere = Nullch;
141             while (size && *s && *s != '\n') {
142                 if (*s == '\t')
143                     *s = ' ';
144                 size--;
145                 if (*s && index(chopset,(*d++ = *s++)))
146                     chophere = s;
147                 if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
148                     *s = ' ';
149             }
150             if (size || !*s)
151                 chophere = s;
152             else if (chophere && chophere < s && *s && index(chopset,*s))
153                 chophere = s;
154             if (fcmd->f_flags & FC_CHOP) {
155                 if (!chophere)
156                     chophere = s;
157                 size += (s - chophere);
158                 d -= (s - chophere);
159                 if (fcmd->f_flags & FC_MORE &&
160                   *chophere && strNE(chophere,"\n")) {
161                     while (size < 3) {
162                         d--;
163                         size++;
164                     }
165                     while (d[-1] == ' ' && size < fcmd->f_size) {
166                         d--;
167                         size++;
168                     }
169                     *d++ = '.';
170                     *d++ = '.';
171                     *d++ = '.';
172                     size -= 3;
173                 }
174                 while (*chophere && index(chopset,*chophere)
175                   && isSPACE(*chophere))
176                     chophere++;
177                 str_chop(str,chophere);
178             }
179             if (fcmd->f_next && fcmd->f_next->f_pre[0] == '\n')
180                 size = 0;                       /* no spaces before newline */
181             while (size) {
182                 size--;
183                 *d++ = ' ';
184             }
185             break;
186         case F_RIGHT:
187             (void)eval(fcmd->f_expr,G_SCALAR,sp);
188             str = stack->ary_array[sp+1];
189             t = s = str_get(str);
190             size = fcmd->f_size;
191             CHKLEN(size);
192             chophere = Nullch;
193             while (size && *s && *s != '\n') {
194                 if (*s == '\t')
195                     *s = ' ';
196                 size--;
197                 if (*s && index(chopset,*s++))
198                     chophere = s;
199                 if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
200                     *s = ' ';
201             }
202             if (size || !*s)
203                 chophere = s;
204             else if (chophere && chophere < s && *s && index(chopset,*s))
205                 chophere = s;
206             if (fcmd->f_flags & FC_CHOP) {
207                 if (!chophere)
208                     chophere = s;
209                 size += (s - chophere);
210                 s = chophere;
211                 while (*chophere && index(chopset,*chophere)
212                   && isSPACE(*chophere))
213                     chophere++;
214             }
215             tmpchar = *s;
216             *s = '\0';
217             while (size) {
218                 size--;
219                 *d++ = ' ';
220             }
221             size = s - t;
222             (void)bcopy(t,d,size);
223             d += size;
224             *s = tmpchar;
225             if (fcmd->f_flags & FC_CHOP)
226                 str_chop(str,chophere);
227             break;
228         case F_CENTER: {
229             int halfsize;
230
231             (void)eval(fcmd->f_expr,G_SCALAR,sp);
232             str = stack->ary_array[sp+1];
233             t = s = str_get(str);
234             size = fcmd->f_size;
235             CHKLEN(size);
236             chophere = Nullch;
237             while (size && *s && *s != '\n') {
238                 if (*s == '\t')
239                     *s = ' ';
240                 size--;
241                 if (*s && index(chopset,*s++))
242                     chophere = s;
243                 if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
244                     *s = ' ';
245             }
246             if (size || !*s)
247                 chophere = s;
248             else if (chophere && chophere < s && *s && index(chopset,*s))
249                 chophere = s;
250             if (fcmd->f_flags & FC_CHOP) {
251                 if (!chophere)
252                     chophere = s;
253                 size += (s - chophere);
254                 s = chophere;
255                 while (*chophere && index(chopset,*chophere)
256                   && isSPACE(*chophere))
257                     chophere++;
258             }
259             tmpchar = *s;
260             *s = '\0';
261             halfsize = size / 2;
262             while (size > halfsize) {
263                 size--;
264                 *d++ = ' ';
265             }
266             size = s - t;
267             (void)bcopy(t,d,size);
268             d += size;
269             *s = tmpchar;
270             if (fcmd->f_next && fcmd->f_next->f_pre[0] == '\n')
271                 size = 0;                       /* no spaces before newline */
272             else
273                 size = halfsize;
274             while (size) {
275                 size--;
276                 *d++ = ' ';
277             }
278             if (fcmd->f_flags & FC_CHOP)
279                 str_chop(str,chophere);
280             break;
281         }
282         case F_LINES:
283             (void)eval(fcmd->f_expr,G_SCALAR,sp);
284             str = stack->ary_array[sp+1];
285             s = str_get(str);
286             size = str_len(str);
287             CHKLEN(size+1);
288             orec->o_lines += countlines(s,size) - 1;
289             (void)bcopy(s,d,size);
290             d += size;
291             if (size && s[size-1] != '\n') {
292                 *d++ = '\n';
293                 orec->o_lines++;
294             }
295             linebeg = fcmd->f_next;
296             break;
297         case F_DECIMAL: {
298             double value;
299
300             (void)eval(fcmd->f_expr,G_SCALAR,sp);
301             str = stack->ary_array[sp+1];
302             size = fcmd->f_size;
303             CHKLEN(size+1);
304             /* If the field is marked with ^ and the value is undefined,
305                blank it out. */
306             if ((fcmd->f_flags & FC_CHOP) && !str->str_pok && !str->str_nok) {
307                 while (size) {
308                     size--;
309                     *d++ = ' ';
310                 }
311                 break;
312             }
313             value = str_gnum(str);
314             if (fcmd->f_flags & FC_DP) {
315                 sprintf(d, "%#*.*f", size, fcmd->f_decimals, value);
316             } else {
317                 sprintf(d, "%*.0f", size, value);
318             }
319             d += size;
320             break;
321         }
322         }
323     }
324     CHKLEN(1);
325     *d++ = '\0';
326 }
327
328 countlines(s,size)
329 register char *s;
330 register int size;
331 {
332     register int count = 0;
333
334     while (size--) {
335         if (*s++ == '\n')
336             count++;
337     }
338     return count;
339 }
340
341 do_write(orec,stab,sp)
342 struct outrec *orec;
343 STAB *stab;
344 int sp;
345 {
346     register STIO *stio = stab_io(stab);
347     FILE *ofp = stio->ofp;
348
349 #ifdef DEBUGGING
350     if (debug & 256)
351         fprintf(stderr,"left=%ld, todo=%ld\n",
352           (long)stio->lines_left, (long)orec->o_lines);
353 #endif
354     if (stio->lines_left < orec->o_lines) {
355         if (!stio->top_stab) {
356             STAB *topstab;
357             char tmpbuf[256];
358
359             if (!stio->top_name) {
360                 if (!stio->fmt_name)
361                     stio->fmt_name = savestr(stab_name(stab));
362                 sprintf(tmpbuf, "%s_TOP", stio->fmt_name);
363                 topstab = stabent(tmpbuf,FALSE);
364                 if (topstab && stab_form(topstab))
365                     stio->top_name = savestr(tmpbuf);
366                 else
367                     stio->top_name = savestr("top");
368             }
369             topstab = stabent(stio->top_name,FALSE);
370             if (!topstab || !stab_form(topstab)) {
371                 stio->lines_left = 100000000;
372                 goto forget_top;
373             }
374             stio->top_stab = topstab;
375         }
376         if (stio->lines_left >= 0 && stio->page > 0)
377             (void)putc('\f',ofp);
378         stio->lines_left = stio->page_len;
379         stio->page++;
380         format(&toprec,stab_form(stio->top_stab),sp);
381         fputs(toprec.o_str,ofp);
382         stio->lines_left -= toprec.o_lines;
383     }
384   forget_top:
385     fputs(orec->o_str,ofp);
386     stio->lines_left -= orec->o_lines;
387 }