[perl5.git] / dump.c

/* $RCSfile: dump.c,v $$Revision: 4.1 $$Date: 92/08/07 17:20:03 $
 *
 *    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:	dump.c,v $
 * Revision 4.1  92/08/07  17:20:03  lwall
 * Stage 6 Snapshot
 * 
 * Revision 4.0.1.2  92/06/08  13:14:22  lwall
 * patch20: removed implicit int declarations on funcions
 * patch20: fixed confusion between a *var's real name and its effective name
 * 
 * Revision 4.0.1.1  91/06/07  10:58:44  lwall
 * patch4: new copyright notice
 * 
 * Revision 4.0  91/03/20  01:08:25  lwall
 * 4.0 baseline.
 * 
 */

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

#ifdef DEBUGGING

static void dump();

void
dump_all()
{
    register I32 i;
    register HE *entry;

    setlinebuf(stderr);
    if (main_root)
	dump_op(main_root);
    for (i = 0; i <= 127; i++) {
	for (entry = HvARRAY(defstash)[i]; entry; entry = entry->hent_next)
	    dump_sub((GV*)entry->hent_val);
    }
}

void
dump_sub(gv)
GV* gv;
{
    SV *sv = sv_mortalcopy(&sv_undef);
    if (GvCV(gv)) {
	gv_fullname(sv,gv);
	dump("\nSUB %s = ", SvPV(sv));
	if (CvUSERSUB(GvCV(gv)))
	    dump("(usersub 0x%x %d)\n",
		(long)CvUSERSUB(GvCV(gv)),
		CvUSERINDEX(GvCV(gv)));
	else if (CvROOT(GvCV(gv)))
	    dump_op(CvROOT(GvCV(gv)));
	else
	    dump("<undef>\n");
    }
}

void
dump_eval()
{
    register I32 i;
    register GV *gv;
    register HE *entry;

    dump_op(eval_root);
}

void
dump_op(op)
register OP *op;
{
    SV *tmpsv;

    dump("{\n");
    if (op->op_seq)
	fprintf(stderr, "%-4d", op->op_seq);
    else
	fprintf(stderr, "    ");
    dump("TYPE = %s  ===> ", op_name[op->op_type]);
    if (op->op_next) {
	if (op->op_seq)
	    fprintf(stderr, "%d\n", op->op_next->op_seq);
	else
	    fprintf(stderr, "(%d)\n", op->op_next->op_seq);
    }
    else
	fprintf(stderr, "DONE\n");
    dumplvl++;
    if (op->op_targ)
	dump("TARG = %d\n", op->op_targ);
#ifdef NOTDEF
    dump("ADDR = 0x%lx => 0x%lx\n",op, op->op_next);
#endif
    if (op->op_flags) {
	*buf = '\0';
	if (op->op_flags & OPf_KNOW) {
	    if (op->op_flags & OPf_LIST)
		(void)strcat(buf,"LIST,");
	    else
		(void)strcat(buf,"SCALAR,");
	}
	else
	    (void)strcat(buf,"UNKNOWN,");
	if (op->op_flags & OPf_KIDS)
	    (void)strcat(buf,"KIDS,");
	if (op->op_flags & OPf_PARENS)
	    (void)strcat(buf,"PARENS,");
	if (op->op_flags & OPf_STACKED)
	    (void)strcat(buf,"STACKED,");
	if (op->op_flags & OPf_LVAL)
	    (void)strcat(buf,"LVAL,");
	if (op->op_flags & OPf_INTRO)
	    (void)strcat(buf,"INTRO,");
	if (op->op_flags & OPf_SPECIAL)
	    (void)strcat(buf,"SPECIAL,");
	if (*buf)
	    buf[strlen(buf)-1] = '\0';
	dump("FLAGS = (%s)\n",buf);
    }
    if (op->op_private) {
	*buf = '\0';
	if (op->op_type == OP_AASSIGN) {
	    if (op->op_private & OPpASSIGN_COMMON)
		(void)strcat(buf,"COMMON,");
	}
	else if (op->op_type == OP_TRANS) {
	    if (op->op_private & OPpTRANS_SQUASH)
		(void)strcat(buf,"SQUASH,");
	    if (op->op_private & OPpTRANS_DELETE)
		(void)strcat(buf,"DELETE,");
	    if (op->op_private & OPpTRANS_COMPLEMENT)
		(void)strcat(buf,"COMPLEMENT,");
	}
	else if (op->op_type == OP_REPEAT) {
	    if (op->op_private & OPpREPEAT_DOLIST)
		(void)strcat(buf,"DOLIST,");
	}
	else if (op->op_type == OP_ENTERSUBR) {
	    if (op->op_private & OPpSUBR_DB)
		(void)strcat(buf,"DB,");
	}
	else if (op->op_type == OP_CONST) {
	    if (op->op_private & OPpCONST_BARE)
		(void)strcat(buf,"BARE,");
	}
	else if (op->op_type == OP_FLIP) {
	    if (op->op_private & OPpFLIP_LINENUM)
		(void)strcat(buf,"LINENUM,");
	}
	else if (op->op_type == OP_FLOP) {
	    if (op->op_private & OPpFLIP_LINENUM)
		(void)strcat(buf,"LINENUM,");
	}
	if (*buf) {
	    buf[strlen(buf)-1] = '\0';
	    dump("PRIVATE = (%s)\n",buf);
	}
    }

    switch (op->op_type) {
    case OP_GVSV:
    case OP_GV:
	if (cGVOP->op_gv) {
	    tmpsv = NEWSV(0,0);
	    gv_fullname(tmpsv,cGVOP->op_gv);
	    dump("GV = %s\n", SvPVn(tmpsv));
	    sv_free(tmpsv);
	}
	else
	    dump("GV = NULL\n");
	break;
    case OP_CONST:
	dump("SV = %s\n", SvPEEK(cSVOP->op_sv));
	break;
    case OP_NEXTSTATE:
    case OP_DBSTATE:
	if (cCOP->cop_line)
	    dump("LINE = %d\n",cCOP->cop_line);
	if (cCOP->cop_label)
	    dump("LABEL = \"%s\"\n",cCOP->cop_label);
	break;
    case OP_ENTERLOOP:
	dump("REDO ===> ");
	if (cLOOP->op_redoop)
	    fprintf(stderr, "%d\n", cLOOP->op_redoop->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	dump("NEXT ===> ");
	if (cLOOP->op_nextop)
	    fprintf(stderr, "%d\n", cLOOP->op_nextop->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	dump("LAST ===> ");
	if (cLOOP->op_lastop)
	    fprintf(stderr, "%d\n", cLOOP->op_lastop->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	break;
    case OP_COND_EXPR:
	dump("TRUE ===> ");
	if (cCONDOP->op_true)
	    fprintf(stderr, "%d\n", cCONDOP->op_true->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	dump("FALSE ===> ");
	if (cCONDOP->op_false)
	    fprintf(stderr, "%d\n", cCONDOP->op_false->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	break;
    case OP_GREPWHILE:
    case OP_OR:
    case OP_AND:
    case OP_METHOD:
	dump("OTHER ===> ");
	if (cLOGOP->op_other)
	    fprintf(stderr, "%d\n", cLOGOP->op_other->op_seq);
	else
	    fprintf(stderr, "DONE\n");
	break;
    case OP_PUSHRE:
    case OP_MATCH:
    case OP_SUBST:
	dump_pm(op);
	break;
    }
    if (op->op_flags & OPf_KIDS) {
	OP *kid;
	for (kid = cUNOP->op_first; kid; kid = kid->op_sibling)
	    dump_op(kid);
    }
    dumplvl--;
    dump("}\n");
}

void
dump_gv(gv)
register GV *gv;
{
    SV *sv;

    if (!gv) {
	fprintf(stderr,"{}\n");
	return;
    }
    sv = sv_mortalcopy(&sv_undef);
    dumplvl++;
    fprintf(stderr,"{\n");
    gv_fullname(sv,gv);
    dump("GV_NAME = %s", SvPV(sv));
    if (gv != GvEGV(gv)) {
	gv_efullname(sv,GvEGV(gv));
	dump("-> %s", SvPV(sv));
    }
    dump("\n");
    dumplvl--;
    dump("}\n");
}

void
dump_pm(pm)
register PMOP *pm;
{
    char ch;

    if (!pm) {
	dump("{}\n");
	return;
    }
    dump("{\n");
    dumplvl++;
    if (pm->op_pmflags & PMf_ONCE)
	ch = '?';
    else
	ch = '/';
    if (pm->op_pmregexp)
	dump("PMf_PRE %c%s%c\n",ch,pm->op_pmregexp->precomp,ch);
    if (pm->op_type != OP_PUSHRE && pm->op_pmreplroot) {
	dump("PMf_REPL = ");
	dump_op(pm->op_pmreplroot);
    }
    if (pm->op_pmshort) {
	dump("PMf_SHORT = %s\n",SvPEEK(pm->op_pmshort));
    }
    if (pm->op_pmflags) {
	*buf = '\0';
	if (pm->op_pmflags & PMf_USED)
	    (void)strcat(buf,"USED,");
	if (pm->op_pmflags & PMf_ONCE)
	    (void)strcat(buf,"ONCE,");
	if (pm->op_pmflags & PMf_SCANFIRST)
	    (void)strcat(buf,"SCANFIRST,");
	if (pm->op_pmflags & PMf_ALL)
	    (void)strcat(buf,"ALL,");
	if (pm->op_pmflags & PMf_SKIPWHITE)
	    (void)strcat(buf,"SKIPWHITE,");
	if (pm->op_pmflags & PMf_FOLD)
	    (void)strcat(buf,"FOLD,");
	if (pm->op_pmflags & PMf_CONST)
	    (void)strcat(buf,"CONST,");
	if (pm->op_pmflags & PMf_KEEP)
	    (void)strcat(buf,"KEEP,");
	if (pm->op_pmflags & PMf_GLOBAL)
	    (void)strcat(buf,"GLOBAL,");
	if (pm->op_pmflags & PMf_RUNTIME)
	    (void)strcat(buf,"RUNTIME,");
	if (pm->op_pmflags & PMf_EVAL)
	    (void)strcat(buf,"EVAL,");
	if (*buf)
	    buf[strlen(buf)-1] = '\0';
	dump("PMFLAGS = (%s)\n",buf);
    }

    dumplvl--;
    dump("}\n");
}

/* VARARGS1 */
static void dump(arg1,arg2,arg3,arg4,arg5)
char *arg1;
long arg2, arg3, arg4, arg5;
{
    I32 i;

    for (i = dumplvl*4; i; i--)
	(void)putc(' ',stderr);
    fprintf(stderr,arg1, arg2, arg3, arg4, arg5);
}
#endif
Commit	Line	Data
79072805	1	/* $RCSfile: dump.c,v $$Revision: 4.1 $$Date: 92/08/07 17:20:03 $
a687059c	2	*
6e21c824	3	* Copyright (c) 1991, Larry Wall
a687059c	4	*
6e21c824 LW	5	* You may distribute under the terms of either the GNU General Public
6e21c824 LW	6	* License or the Artistic License, as specified in the README file.
8d063cd8 LW	7	*
8d063cd8 LW	8	* $Log: dump.c,v $
79072805 LW	9	* Revision 4.1 92/08/07 17:20:03 lwall
	10	* Stage 6 Snapshot
	11	*
8adcabd8 LW	12	* Revision 4.0.1.2 92/06/08 13:14:22 lwall
	13	* patch20: removed implicit int declarations on funcions
	14	* patch20: fixed confusion between a *var's real name and its effective name
	15	*
6e21c824 LW	16	* Revision 4.0.1.1 91/06/07 10:58:44 lwall
	17	* patch4: new copyright notice
	18	*
fe14fcc3 LW	19	* Revision 4.0 91/03/20 01:08:25 lwall
fe14fcc3 LW	20	* 4.0 baseline.
8d063cd8 LW	21	*
	22	*/
	23
8d063cd8	24	#include "EXTERN.h"
8d063cd8 LW	25	#include "perl.h"
	26
	27	#ifdef DEBUGGING
8d063cd8	28
8adcabd8 LW	29	static void dump();
	30
	31	void
93a17b20	32	dump_all()
79072805	33	{
93a17b20 LW	34	register I32 i;
93a17b20 LW	35	register HE *entry;
79072805	36
93a17b20 LW	37	setlinebuf(stderr);
	38	if (main_root)
	39	dump_op(main_root);
	40	for (i = 0; i <= 127; i++) {
	41	for (entry = HvARRAY(defstash)[i]; entry; entry = entry->hent_next)
	42	dump_sub((GV*)entry->hent_val);
79072805 LW	43	}
	44	}
	45
	46	void
93a17b20 LW	47	dump_sub(gv)
93a17b20 LW	48	GV* gv;
a687059c	49	{
79072805	50	SV *sv = sv_mortalcopy(&sv_undef);
93a17b20 LW	51	if (GvCV(gv)) {
	52	gv_fullname(sv,gv);
	53	dump("\nSUB %s = ", SvPV(sv));
	54	if (CvUSERSUB(GvCV(gv)))
	55	dump("(usersub 0x%x %d)\n",
	56	(long)CvUSERSUB(GvCV(gv)),
	57	CvUSERINDEX(GvCV(gv)));
	58	else if (CvROOT(GvCV(gv)))
	59	dump_op(CvROOT(GvCV(gv)));
	60	else
	61	dump("<undef>\n");
a687059c LW	62	}
	63	}
	64
8adcabd8	65	void
79072805	66	dump_eval()
8d063cd8	67	{
79072805 LW	68	register I32 i;
	69	register GV *gv;
	70	register HE *entry;
	71
79072805 LW	72	dump_op(eval_root);
	73	}
	74
	75	void
	76	dump_op(op)
	77	register OP *op;
	78	{
	79	SV *tmpsv;
	80
79072805	81	dump("{\n");
93a17b20 LW	82	if (op->op_seq)
	83	fprintf(stderr, "%-4d", op->op_seq);
	84	else
	85	fprintf(stderr, " ");
79072805	86	dump("TYPE = %s ===> ", op_name[op->op_type]);
93a17b20 LW	87	if (op->op_next) {
	88	if (op->op_seq)
	89	fprintf(stderr, "%d\n", op->op_next->op_seq);
	90	else
	91	fprintf(stderr, "(%d)\n", op->op_next->op_seq);
	92	}
79072805 LW	93	else
	94	fprintf(stderr, "DONE\n");
	95	dumplvl++;
	96	if (op->op_targ)
	97	dump("TARG = %d\n", op->op_targ);
	98	#ifdef NOTDEF
	99	dump("ADDR = 0x%lx => 0x%lx\n",op, op->op_next);
	100	#endif
	101	if (op->op_flags) {
8d063cd8	102	*buf = '\0';
79072805 LW	103	if (op->op_flags & OPf_KNOW) {
	104	if (op->op_flags & OPf_LIST)
	105	(void)strcat(buf,"LIST,");
	106	else
	107	(void)strcat(buf,"SCALAR,");
	108	}
	109	else
	110	(void)strcat(buf,"UNKNOWN,");
	111	if (op->op_flags & OPf_KIDS)
	112	(void)strcat(buf,"KIDS,");
	113	if (op->op_flags & OPf_PARENS)
	114	(void)strcat(buf,"PARENS,");
	115	if (op->op_flags & OPf_STACKED)
	116	(void)strcat(buf,"STACKED,");
	117	if (op->op_flags & OPf_LVAL)
	118	(void)strcat(buf,"LVAL,");
93a17b20 LW	119	if (op->op_flags & OPf_INTRO)
93a17b20 LW	120	(void)strcat(buf,"INTRO,");
79072805 LW	121	if (op->op_flags & OPf_SPECIAL)
79072805 LW	122	(void)strcat(buf,"SPECIAL,");
8d063cd8 LW	123	if (*buf)
8d063cd8 LW	124	buf[strlen(buf)-1] = '\0';
79072805 LW	125	dump("FLAGS = (%s)\n",buf);
	126	}
	127	if (op->op_private) {
	128	*buf = '\0';
	129	if (op->op_type == OP_AASSIGN) {
	130	if (op->op_private & OPpASSIGN_COMMON)
	131	(void)strcat(buf,"COMMON,");
8d063cd8	132	}
79072805 LW	133	else if (op->op_type == OP_TRANS) {
	134	if (op->op_private & OPpTRANS_SQUASH)
	135	(void)strcat(buf,"SQUASH,");
	136	if (op->op_private & OPpTRANS_DELETE)
	137	(void)strcat(buf,"DELETE,");
	138	if (op->op_private & OPpTRANS_COMPLEMENT)
	139	(void)strcat(buf,"COMPLEMENT,");
8d063cd8	140	}
79072805 LW	141	else if (op->op_type == OP_REPEAT) {
	142	if (op->op_private & OPpREPEAT_DOLIST)
	143	(void)strcat(buf,"DOLIST,");
8d063cd8	144	}
79072805 LW	145	else if (op->op_type == OP_ENTERSUBR) {
	146	if (op->op_private & OPpSUBR_DB)
	147	(void)strcat(buf,"DB,");
8d063cd8	148	}
79072805 LW	149	else if (op->op_type == OP_CONST) {
	150	if (op->op_private & OPpCONST_BARE)
	151	(void)strcat(buf,"BARE,");
	152	}
	153	else if (op->op_type == OP_FLIP) {
	154	if (op->op_private & OPpFLIP_LINENUM)
	155	(void)strcat(buf,"LINENUM,");
	156	}
	157	else if (op->op_type == OP_FLOP) {
	158	if (op->op_private & OPpFLIP_LINENUM)
	159	(void)strcat(buf,"LINENUM,");
	160	}
	161	if (*buf) {
	162	buf[strlen(buf)-1] = '\0';
	163	dump("PRIVATE = (%s)\n",buf);
8d063cd8	164	}
8d063cd8	165	}
8d063cd8	166
79072805	167	switch (op->op_type) {
93a17b20	168	case OP_GVSV:
79072805 LW	169	case OP_GV:
	170	if (cGVOP->op_gv) {
	171	tmpsv = NEWSV(0,0);
	172	gv_fullname(tmpsv,cGVOP->op_gv);
	173	dump("GV = %s\n", SvPVn(tmpsv));
	174	sv_free(tmpsv);
378cc40b	175	}
79072805 LW	176	else
	177	dump("GV = NULL\n");
	178	break;
	179	case OP_CONST:
	180	dump("SV = %s\n", SvPEEK(cSVOP->op_sv));
	181	break;
93a17b20 LW	182	case OP_NEXTSTATE:
93a17b20 LW	183	case OP_DBSTATE:
79072805 LW	184	if (cCOP->cop_line)
	185	dump("LINE = %d\n",cCOP->cop_line);
	186	if (cCOP->cop_label)
	187	dump("LABEL = \"%s\"\n",cCOP->cop_label);
	188	break;
	189	case OP_ENTERLOOP:
	190	dump("REDO ===> ");
93a17b20	191	if (cLOOP->op_redoop)
79072805	192	fprintf(stderr, "%d\n", cLOOP->op_redoop->op_seq);
79072805 LW	193	else
	194	fprintf(stderr, "DONE\n");
	195	dump("NEXT ===> ");
93a17b20	196	if (cLOOP->op_nextop)
79072805	197	fprintf(stderr, "%d\n", cLOOP->op_nextop->op_seq);
79072805 LW	198	else
	199	fprintf(stderr, "DONE\n");
	200	dump("LAST ===> ");
93a17b20	201	if (cLOOP->op_lastop)
79072805	202	fprintf(stderr, "%d\n", cLOOP->op_lastop->op_seq);
79072805 LW	203	else
	204	fprintf(stderr, "DONE\n");
	205	break;
	206	case OP_COND_EXPR:
	207	dump("TRUE ===> ");
93a17b20	208	if (cCONDOP->op_true)
79072805	209	fprintf(stderr, "%d\n", cCONDOP->op_true->op_seq);
79072805 LW	210	else
	211	fprintf(stderr, "DONE\n");
	212	dump("FALSE ===> ");
93a17b20	213	if (cCONDOP->op_false)
79072805	214	fprintf(stderr, "%d\n", cCONDOP->op_false->op_seq);
79072805 LW	215	else
	216	fprintf(stderr, "DONE\n");
	217	break;
	218	case OP_GREPWHILE:
	219	case OP_OR:
	220	case OP_AND:
	221	case OP_METHOD:
	222	dump("OTHER ===> ");
93a17b20	223	if (cLOGOP->op_other)
79072805	224	fprintf(stderr, "%d\n", cLOGOP->op_other->op_seq);
79072805 LW	225	else
	226	fprintf(stderr, "DONE\n");
	227	break;
	228	case OP_PUSHRE:
	229	case OP_MATCH:
	230	case OP_SUBST:
	231	dump_pm(op);
	232	break;
	233	}
	234	if (op->op_flags & OPf_KIDS) {
	235	OP *kid;
	236	for (kid = cUNOP->op_first; kid; kid = kid->op_sibling)
	237	dump_op(kid);
8d063cd8 LW	238	}
	239	dumplvl--;
	240	dump("}\n");
	241	}
	242
8adcabd8	243	void
79072805 LW	244	dump_gv(gv)
79072805 LW	245	register GV *gv;
378cc40b	246	{
79072805	247	SV *sv;
378cc40b	248
79072805	249	if (!gv) {
378cc40b LW	250	fprintf(stderr,"{}\n");
	251	return;
	252	}
79072805	253	sv = sv_mortalcopy(&sv_undef);
8d063cd8 LW	254	dumplvl++;
8d063cd8 LW	255	fprintf(stderr,"{\n");
79072805 LW	256	gv_fullname(sv,gv);
	257	dump("GV_NAME = %s", SvPV(sv));
	258	if (gv != GvEGV(gv)) {
	259	gv_efullname(sv,GvEGV(gv));
	260	dump("-> %s", SvPV(sv));
8adcabd8 LW	261	}
8adcabd8 LW	262	dump("\n");
8d063cd8 LW	263	dumplvl--;
	264	dump("}\n");
	265	}
	266
8adcabd8	267	void
79072805 LW	268	dump_pm(pm)
79072805 LW	269	register PMOP *pm;
8d063cd8 LW	270	{
	271	char ch;
	272
79072805 LW	273	if (!pm) {
79072805 LW	274	dump("{}\n");
378cc40b LW	275	return;
378cc40b LW	276	}
79072805	277	dump("{\n");
8d063cd8	278	dumplvl++;
79072805 LW	279	if (pm->op_pmflags & PMf_ONCE)
	280	ch = '?';
	281	else
	282	ch = '/';
	283	if (pm->op_pmregexp)
	284	dump("PMf_PRE %c%s%c\n",ch,pm->op_pmregexp->precomp,ch);
	285	if (pm->op_type != OP_PUSHRE && pm->op_pmreplroot) {
	286	dump("PMf_REPL = ");
	287	dump_op(pm->op_pmreplroot);
8d063cd8	288	}
79072805 LW	289	if (pm->op_pmshort) {
79072805 LW	290	dump("PMf_SHORT = %s\n",SvPEEK(pm->op_pmshort));
8d063cd8	291	}
79072805 LW	292	if (pm->op_pmflags) {
	293	*buf = '\0';
	294	if (pm->op_pmflags & PMf_USED)
	295	(void)strcat(buf,"USED,");
	296	if (pm->op_pmflags & PMf_ONCE)
	297	(void)strcat(buf,"ONCE,");
	298	if (pm->op_pmflags & PMf_SCANFIRST)
	299	(void)strcat(buf,"SCANFIRST,");
	300	if (pm->op_pmflags & PMf_ALL)
	301	(void)strcat(buf,"ALL,");
	302	if (pm->op_pmflags & PMf_SKIPWHITE)
	303	(void)strcat(buf,"SKIPWHITE,");
	304	if (pm->op_pmflags & PMf_FOLD)
	305	(void)strcat(buf,"FOLD,");
	306	if (pm->op_pmflags & PMf_CONST)
	307	(void)strcat(buf,"CONST,");
	308	if (pm->op_pmflags & PMf_KEEP)
	309	(void)strcat(buf,"KEEP,");
	310	if (pm->op_pmflags & PMf_GLOBAL)
	311	(void)strcat(buf,"GLOBAL,");
	312	if (pm->op_pmflags & PMf_RUNTIME)
	313	(void)strcat(buf,"RUNTIME,");
	314	if (pm->op_pmflags & PMf_EVAL)
	315	(void)strcat(buf,"EVAL,");
	316	if (*buf)
	317	buf[strlen(buf)-1] = '\0';
	318	dump("PMFLAGS = (%s)\n",buf);
378cc40b	319	}
79072805	320
8d063cd8 LW	321	dumplvl--;
	322	dump("}\n");
	323	}
	324
378cc40b	325	/* VARARGS1 */
8adcabd8	326	static void dump(arg1,arg2,arg3,arg4,arg5)
378cc40b LW	327	char *arg1;
378cc40b LW	328	long arg2, arg3, arg4, arg5;
8d063cd8	329	{
79072805	330	I32 i;
8d063cd8 LW	331
8d063cd8 LW	332	for (i = dumplvl*4; i; i--)
a687059c	333	(void)putc(' ',stderr);
8d063cd8 LW	334	fprintf(stderr,arg1, arg2, arg3, arg4, arg5);
	335	}
	336	#endif