[unix-history] / usr / src / contrib / perl-4.036 / form.c

/* $RCSfile: form.c,v $$Revision: 4.0.1.4 $$Date: 1993/02/05 19:34:32 $
 *
 *    Copyright (c) 1991, Larry Wall
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * $Log: form.c,v $
 * Revision 4.0.1.4  1993/02/05  19:34:32  lwall
 * patch36: formats now ignore literal text for ~~ loop determination
 *
 * Revision 4.0.1.3  92/06/08  13:21:42  lwall
 * patch20: removed implicit int declarations on funcions
 * patch20: form feed for formats is now specifiable via $^L
 * patch20: Perl now distinguishes overlapped copies from non-overlapped
 * 
 * Revision 4.0.1.2  91/11/05  17:18:43  lwall
 * patch11: formats didn't fill their fields as well as they could
 * patch11: ^ fields chopped hyphens on line break
 * patch11: # fields could write outside allocated memory
 * 
 * Revision 4.0.1.1  91/06/07  11:07:59  lwall
 * patch4: new copyright notice
 * patch4: default top-of-form format is now FILEHANDLE_TOP
 * 
 * Revision 4.0  91/03/20  01:19:23  lwall
 * 4.0 baseline.
 * 
 */

#include "EXTERN.h"
#include "perl.h"

/* Forms stuff */

static int countlines();

void
form_parseargs(fcmd)
register FCMD *fcmd;
{
    register int i;
    register ARG *arg;
    register int items;
    STR *str;
    ARG *parselist();
    line_t oldline = curcmd->c_line;
    int oldsave = savestack->ary_fill;

    str = fcmd->f_unparsed;
    curcmd->c_line = fcmd->f_line;
    fcmd->f_unparsed = Nullstr;
    (void)savehptr(&curstash);
    curstash = str->str_u.str_hash;
    arg = parselist(str);
    restorelist(oldsave);

    items = arg->arg_len - 1;	/* ignore $$ on end */
    for (i = 1; i <= items; i++) {
	if (!fcmd || fcmd->f_type == F_NULL)
	    fatal("Too many field values");
	dehoist(arg,i);
	fcmd->f_expr = make_op(O_ITEM,1,
	  arg[i].arg_ptr.arg_arg,Nullarg,Nullarg);
	if (fcmd->f_flags & FC_CHOP) {
	    if ((fcmd->f_expr[1].arg_type & A_MASK) == A_STAB)
		fcmd->f_expr[1].arg_type = A_LVAL;
	    else if ((fcmd->f_expr[1].arg_type & A_MASK) == A_EXPR)
		fcmd->f_expr[1].arg_type = A_LEXPR;
	    else
		fatal("^ field requires scalar lvalue");
	}
	fcmd = fcmd->f_next;
    }
    if (fcmd && fcmd->f_type)
	fatal("Not enough field values");
    curcmd->c_line = oldline;
    Safefree(arg);
    str_free(str);
}

int newsize;

#define CHKLEN(allow) \
newsize = (d - orec->o_str) + (allow); \
if (newsize >= curlen) { \
    curlen = d - orec->o_str; \
    GROWSTR(&orec->o_str,&orec->o_len,orec->o_len + (allow)); \
    d = orec->o_str + curlen;	/* in case it moves */ \
    curlen = orec->o_len - 2; \
}

void
format(orec,fcmd,sp)
register struct outrec *orec;
register FCMD *fcmd;
int sp;
{
    register char *d = orec->o_str;
    register char *s;
    register int curlen = orec->o_len - 2;
    register int size;
    FCMD *nextfcmd;
    FCMD *linebeg = fcmd;
    char tmpchar;
    char *t;
    CMD mycmd;
    STR *str;
    char *chophere;
    int blank = TRUE;

    mycmd.c_type = C_NULL;
    orec->o_lines = 0;
    for (; fcmd; fcmd = nextfcmd) {
	nextfcmd = fcmd->f_next;
	CHKLEN(fcmd->f_presize);
	/*SUPPRESS 560*/
	if (s = fcmd->f_pre) {
	    while (*s) {
		if (*s == '\n') {
		    t = orec->o_str;
		    if (blank && (fcmd->f_flags & FC_REPEAT)) {
			while (d > t && (d[-1] != '\n'))
			    d--;
		    }
		    else {
			while (d > t && (d[-1] == ' ' || d[-1] == '\t'))
			    d--;
		    }
		    if (fcmd->f_flags & FC_NOBLANK) {
			if (blank || d == orec->o_str || d[-1] == '\n') {
			    orec->o_lines--;	/* don't print blank line */
			    linebeg = fcmd->f_next;
			    break;
			}
			else if (fcmd->f_flags & FC_REPEAT)
			    nextfcmd = linebeg;
			else
			    linebeg = fcmd->f_next;
		    }
		    else
			linebeg = fcmd->f_next;
		    blank = TRUE;
		}
		*d++ = *s++;
	    }
	}
	if (fcmd->f_unparsed)
	    form_parseargs(fcmd);
	switch (fcmd->f_type) {
	case F_NULL:
	    orec->o_lines++;
	    break;
	case F_LEFT:
	    (void)eval(fcmd->f_expr,G_SCALAR,sp);
	    str = stack->ary_array[sp+1];
	    s = str_get(str);
	    size = fcmd->f_size;
	    CHKLEN(size);
	    chophere = Nullch;
	    while (size && *s && *s != '\n') {
		if (*s == '\t')
		    *s = ' ';
		else if (*s != ' ')
		    blank = FALSE;
		size--;
		if (*s && index(chopset,(*d++ = *s++)))
		    chophere = s;
		if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
		    *s = ' ';
	    }
	    if (size || !*s)
		chophere = s;
	    else if (chophere && chophere < s && *s && index(chopset,*s))
		chophere = s;
	    if (fcmd->f_flags & FC_CHOP) {
		if (!chophere)
		    chophere = s;
		size += (s - chophere);
		d -= (s - chophere);
		if (fcmd->f_flags & FC_MORE &&
		  *chophere && strNE(chophere,"\n")) {
		    while (size < 3) {
			d--;
			size++;
		    }
		    while (d[-1] == ' ' && size < fcmd->f_size) {
			d--;
			size++;
		    }
		    *d++ = '.';
		    *d++ = '.';
		    *d++ = '.';
		    size -= 3;
		}
		while (*chophere && index(chopset,*chophere)
		  && isSPACE(*chophere))
		    chophere++;
		str_chop(str,chophere);
	    }
	    if (fcmd->f_next && fcmd->f_next->f_pre[0] == '\n')
		size = 0;			/* no spaces before newline */
	    while (size) {
		size--;
		*d++ = ' ';
	    }
	    break;
	case F_RIGHT:
	    (void)eval(fcmd->f_expr,G_SCALAR,sp);
	    str = stack->ary_array[sp+1];
	    t = s = str_get(str);
	    size = fcmd->f_size;
	    CHKLEN(size);
	    chophere = Nullch;
	    while (size && *s && *s != '\n') {
		if (*s == '\t')
		    *s = ' ';
		else if (*s != ' ')
		    blank = FALSE;
		size--;
		if (*s && index(chopset,*s++))
		    chophere = s;
		if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
		    *s = ' ';
	    }
	    if (size || !*s)
		chophere = s;
	    else if (chophere && chophere < s && *s && index(chopset,*s))
		chophere = s;
	    if (fcmd->f_flags & FC_CHOP) {
		if (!chophere)
		    chophere = s;
		size += (s - chophere);
		s = chophere;
		while (*chophere && index(chopset,*chophere)
		  && isSPACE(*chophere))
		    chophere++;
	    }
	    tmpchar = *s;
	    *s = '\0';
	    while (size) {
		size--;
		*d++ = ' ';
	    }
	    size = s - t;
	    Copy(t,d,size,char);
	    d += size;
	    *s = tmpchar;
	    if (fcmd->f_flags & FC_CHOP)
		str_chop(str,chophere);
	    break;
	case F_CENTER: {
	    int halfsize;

	    (void)eval(fcmd->f_expr,G_SCALAR,sp);
	    str = stack->ary_array[sp+1];
	    t = s = str_get(str);
	    size = fcmd->f_size;
	    CHKLEN(size);
	    chophere = Nullch;
	    while (size && *s && *s != '\n') {
		if (*s == '\t')
		    *s = ' ';
		else if (*s != ' ')
		    blank = FALSE;
		size--;
		if (*s && index(chopset,*s++))
		    chophere = s;
		if (*s == '\n' && (fcmd->f_flags & FC_CHOP))
		    *s = ' ';
	    }
	    if (size || !*s)
		chophere = s;
	    else if (chophere && chophere < s && *s && index(chopset,*s))
		chophere = s;
	    if (fcmd->f_flags & FC_CHOP) {
		if (!chophere)
		    chophere = s;
		size += (s - chophere);
		s = chophere;
		while (*chophere && index(chopset,*chophere)
		  && isSPACE(*chophere))
		    chophere++;
	    }
	    tmpchar = *s;
	    *s = '\0';
	    halfsize = size / 2;
	    while (size > halfsize) {
		size--;
		*d++ = ' ';
	    }
	    size = s - t;
	    Copy(t,d,size,char);
	    d += size;
	    *s = tmpchar;
	    if (fcmd->f_next && fcmd->f_next->f_pre[0] == '\n')
		size = 0;			/* no spaces before newline */
	    else
		size = halfsize;
	    while (size) {
		size--;
		*d++ = ' ';
	    }
	    if (fcmd->f_flags & FC_CHOP)
		str_chop(str,chophere);
	    break;
	}
	case F_LINES:
	    (void)eval(fcmd->f_expr,G_SCALAR,sp);
	    str = stack->ary_array[sp+1];
	    s = str_get(str);
	    size = str_len(str);
	    CHKLEN(size+1);
	    orec->o_lines += countlines(s,size) - 1;
	    Copy(s,d,size,char);
	    d += size;
	    if (size && s[size-1] != '\n') {
		*d++ = '\n';
		orec->o_lines++;
	    }
	    linebeg = fcmd->f_next;
	    break;
	case F_DECIMAL: {
	    double value;

	    (void)eval(fcmd->f_expr,G_SCALAR,sp);
	    str = stack->ary_array[sp+1];
	    size = fcmd->f_size;
	    CHKLEN(size+1);
	    /* If the field is marked with ^ and the value is undefined,
	       blank it out. */
	    if ((fcmd->f_flags & FC_CHOP) && !str->str_pok && !str->str_nok) {
		while (size) {
		    size--;
		    *d++ = ' ';
		}
		break;
	    }
	    blank = FALSE;
	    value = str_gnum(str);
	    if (fcmd->f_flags & FC_DP) {
		sprintf(d, "%#*.*f", size, fcmd->f_decimals, value);
	    } else {
		sprintf(d, "%*.0f", size, value);
	    }
	    d += size;
	    break;
	}
	}
    }
    CHKLEN(1);
    *d++ = '\0';
}

static int
countlines(s,size)
register char *s;
register int size;
{
    register int count = 0;

    while (size--) {
	if (*s++ == '\n')
	    count++;
    }
    return count;
}

void
do_write(orec,stab,sp)
struct outrec *orec;
STAB *stab;
int sp;
{
    register STIO *stio = stab_io(stab);
    FILE *ofp = stio->ofp;

#ifdef DEBUGGING
    if (debug & 256)
	fprintf(stderr,"left=%ld, todo=%ld\n",
	  (long)stio->lines_left, (long)orec->o_lines);
#endif
    if (stio->lines_left < orec->o_lines) {
	if (!stio->top_stab) {
	    STAB *topstab;
	    char tmpbuf[256];

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