profile.c File Reference

#include "awk.h"

Go to the source code of this file.

Defines
#define	SPACEOVER   0
#define	hakvar   forloop->init
#define	arrvar   forloop->incr
#define	BREAKPOINT   70
Enumerations
enum	redir_placement { BEFORE = 0, AFTER = 1 }
Functions
static void tree_eval	P ((NODE *tree))
void	init_profiling (int *flag ATTRIBUTE_UNUSED, const char *def_file ATTRIBUTE_UNUSED)
void	set_prof_file (const char *file)
void	init_profiling_signals ()
static void	indent (long count)
static void	indent_in (void)
static void	indent_out (void)
static void	pprint (register NODE *volatile tree)
static void	tree_eval (register NODE *tree)
static void	eval_condition (register NODE *tree)
static void	pp_op_assign (register NODE *tree)
static void	pp_lhs (register NODE *ptr)
static void	pp_match_op (register NODE *tree)
static void	pp_redir (register NODE *tree, enum redir_placement dir)
static void	pp_list (register NODE *tree)
static void	pp_print_stmt (const char *command, register NODE *tree)
static void	pp_delete (register NODE *tree)
static void	pp_in_array (NODE *array, NODE *subscript)
static void	pp_getline (register NODE *tree)
static void	pp_builtin (register NODE *tree)
static void	pp_func_call (NODE *tree)
void	dump_prog (NODE *begin, NODE *prog, NODE *end)
void	pp_func (const char *name, size_t namelen, NODE *f)
static void	pp_string (const char *str, size_t len, int delim)
void	pp_string_fp (FILE *fp, const char *in_str, size_t len, int delim, int breaklines)
static int	is_scalar (NODETYPE type)
static int	prec_level (NODETYPE type)
static void	parenthesize (NODETYPE parent_type, NODE *tree)
Variables
static char **	fparms
static FILE *	prof_fp
static long	indent_level = 0
static int	in_BEGIN_or_END = FALSE
static int	in_expr = FALSE

---

Define Documentation

#define arrvar   forloop->incr

#define BREAKPOINT   70

Referenced by pp_string_fp().

#define hakvar   forloop->init

#define SPACEOVER   0

Definition at line 67 of file profile.c. Referenced by pprint(), and tree_eval().

---

Enumeration Type Documentation

enum redir_placement

Enumerator: BEFORE  AFTER  Definition at line 29 of file profile.c. { BEFORE = 0, AFTER = 1 };

---

Function Documentation

void dump_prog (  NODE *  begin, NODE *  prog, NODE *  end )

Definition at line 1156 of file profile.c. References _, FALSE, NULL, pprint(), time(), and TRUE. Referenced by main(). { time_t now; (void) time(& now); /* \n on purpose, with \n in ctime() output */ fprintf(prof_fp, _("\t# gawk profile, created %s\n"), ctime(& now)); if (begin != NULL) { fprintf(prof_fp, _("\t# BEGIN block(s)\n\n")); fprintf(prof_fp, "\tBEGIN {\n"); in_BEGIN_or_END = TRUE; pprint(begin); in_BEGIN_or_END = FALSE; fprintf(prof_fp, "\t}\n"); if (prog != NULL || end != NULL) fprintf(prof_fp, "\n"); } if (prog != NULL) { fprintf(prof_fp, _("\t# Rule(s)\n\n")); pprint(prog); if (end != NULL) fprintf(prof_fp, "\n"); } if (end != NULL) { fprintf(prof_fp, _("\t# END block(s)\n\n")); fprintf(prof_fp, "\tEND {\n"); in_BEGIN_or_END = TRUE; pprint(end); in_BEGIN_or_END = FALSE; fprintf(prof_fp, "\t}\n"); } }

static void eval_condition (  register NODE *  tree  )  [static]

Definition at line 694 of file profile.c. References eval_condition(), Node_line_range, NULL, and tree_eval. { if (tree == NULL) /* Null trees are the easiest kinds */ return; if (tree->type == Node_line_range) { /* /.../, /.../ */ eval_condition(tree->condpair->lnode); fprintf(prof_fp,", "); eval_condition(tree->condpair->rnode); return; } /* * Could just be J.random expression. in which case, null and 0 are * false, anything else is true */ tree_eval(tree); return; }

static void indent (  long  count  )  [static]

Definition at line 121 of file profile.c. References i. Referenced by pp_delete(), pp_func(), pp_print_stmt(), pprint(), and tree_eval(). { int i; if (count == 0) putc('\t', prof_fp); else fprintf(prof_fp, "%6ld ", count); assert(indent_level >= 0); for (i = 0; i < indent_level; i++) putc('\t', prof_fp); }

static void indent_in (  void   )  [static]

Definition at line 138 of file profile.c. Referenced by pp_func(), pprint(), and tree_eval(). { assert(indent_level >= 0); indent_level++; }

static void indent_out (  void   )  [static]

Definition at line 147 of file profile.c. Referenced by pp_func(), pprint(), and tree_eval(). { indent_level--; assert(indent_level >= 0); }

void init_profiling (  int *flag  ATTRIBUTE_UNUSED, const char *def_file  ATTRIBUTE_UNUSED )

Definition at line 72 of file profile.c. References FALSE, set_prof_file(), and TRUE. Referenced by main(). { #ifdef PROFILING if (*flag == FALSE) { *flag = TRUE; set_prof_file(def_file); } #endif }

void init_profiling_signals (   )

Definition at line 101 of file profile.c. Referenced by main(). { #ifdef PROFILING #ifdef __DJGPP__ signal(SIGINT, dump_and_exit); signal(SIGQUIT, just_dump); #else /* !__DJGPP__ */ #ifdef SIGHUP signal(SIGHUP, dump_and_exit); #endif #ifdef SIGUSR1 signal(SIGUSR1, just_dump); #endif #endif /* !__DJGPP__ */ #endif /* PROFILING */ }

static int is_scalar (  NODETYPE  type  )  [static]

Definition at line 1289 of file profile.c. References FALSE, Node_BINMODE, Node_CONVFMT, Node_FIELDWIDTHS, Node_FNR, Node_FS, Node_IGNORECASE, Node_LINT, Node_NF, Node_NR, Node_OFMT, Node_OFS, Node_ORS, Node_RS, Node_subscript, Node_TEXTDOMAIN, Node_val, Node_var, Node_var_array, Node_var_new, and TRUE. Referenced by pp_lhs(), pp_redir(), and tree_eval(). { switch (type) { case Node_var_new: case Node_var: case Node_var_array: case Node_val: case Node_BINMODE: case Node_CONVFMT: case Node_FIELDWIDTHS: case Node_FNR: case Node_FS: case Node_IGNORECASE: case Node_LINT: case Node_NF: case Node_NR: case Node_OFMT: case Node_OFS: case Node_ORS: case Node_RS: case Node_TEXTDOMAIN: case Node_subscript: return TRUE; default: return FALSE; } }

static void tree_eval P (  (NODE *tree)   )  [static]

static void parenthesize (  NODETYPE  parent_type, NODE *  tree )  [static]

Definition at line 1421 of file profile.c. References Node_in_array, Node_not, NULL, pp_in_array(), prec_level(), tree_eval, and exp_node::type. Referenced by tree_eval(). { NODETYPE child_type; if (tree == NULL) return; child_type = tree->type; in_expr++; /* first the special cases, then the general ones */ if (parent_type == Node_not && child_type == Node_in_array) { fprintf(prof_fp, "! ("); pp_in_array(tree->lnode, tree->rnode); fprintf(prof_fp, ")"); /* other special cases here, as needed */ } else if (prec_level(child_type) < prec_level(parent_type)) { fprintf(prof_fp, "("); tree_eval(tree); fprintf(prof_fp, ")"); } else tree_eval(tree); in_expr--; }

static void pp_builtin (  register NODE *  tree  )  [static]

Definition at line 1124 of file profile.c. References getfname(), and pp_list(). Referenced by tree_eval(). { const char *func = getfname(tree->builtin); fprintf(prof_fp, "%s(", func ? func : "extension_function"); if (func) pp_list(tree->subnode); fprintf(prof_fp, ")"); }

static void pp_delete (  register NODE *  tree  )  [static]

Definition at line 1049 of file profile.c. References indent(), Node_param_list, NULL, pp_list(), and exp_node::type. Referenced by pprint(). { NODE *array, *subscript; array = tree->lnode; subscript = tree->rnode; indent(array->exec_count); if (array->type == Node_param_list) fprintf(prof_fp, "delete %s", fparms[array->param_cnt]); else fprintf(prof_fp, "delete %s", array->vname); if (subscript != NULL) { fprintf(prof_fp, "["); pp_list(subscript); fprintf(prof_fp, "]"); } fprintf(prof_fp, "\n"); }

void pp_func (  const char *  name, size_t  namelen, NODE *  f )

Definition at line 1193 of file profile.c. References _, FALSE, indent(), indent_in(), indent_out(), lnode, pprint(), and TRUE. Referenced by dump_funcs(). { int j; char **pnames; static int first = TRUE; if (first) { first = FALSE; fprintf(prof_fp, _("\n\t# Functions, listed alphabetically\n")); } fprintf(prof_fp, "\n"); indent(f->exec_count); fprintf(prof_fp, "function %.*s(", (int) namelen, name); pnames = f->parmlist; fparms = pnames; for (j = 0; j < f->lnode->param_cnt; j++) { fprintf(prof_fp, "%s", pnames[j]); if (j < f->lnode->param_cnt - 1) fprintf(prof_fp, ", "); } fprintf(prof_fp, ")\n\t{\n"); indent_in(); pprint(f->rnode); /* body */ indent_out(); fprintf(prof_fp, "\t}\n"); }

static void pp_func_call (  NODE *  tree  )  [static]

Definition at line 1137 of file profile.c. References name, and pp_list(). Referenced by tree_eval(). { NODE *name, *arglist; name = tree->rnode; arglist = tree->lnode; fprintf(prof_fp, "%s(", name->stptr); pp_list(arglist); fprintf(prof_fp, ")"); }

static void pp_getline (  register NODE *  tree  )  [static]

Definition at line 1089 of file profile.c. References AFTER, BEFORE, FALSE, Node_redirect_pipein, Node_redirect_twoway, NULL, pp_lhs(), pp_redir(), and exp_node::type. Referenced by tree_eval(). { NODE *redir = tree->rnode; int before, after; /* * command | getline * or * command |& getline * or * getline < file */ if (redir != NULL) { before = (redir->type == Node_redirect_pipein || redir->type == Node_redirect_twoway); after = ! before; } else before = after = FALSE; if (before) pp_redir(redir, BEFORE); fprintf(prof_fp, "getline"); if (tree->lnode != NULL) { /* optional var */ fprintf(prof_fp, " "); pp_lhs(tree->lnode); } if (after) pp_redir(redir, AFTER); }

static void pp_in_array (  NODE *  array, NODE *  subscript )  [static]

Definition at line 1071 of file profile.c. References Node_expression_list, Node_param_list, pp_list(), pprint(), and exp_node::type. Referenced by parenthesize(), and tree_eval(). { if (subscript->type == Node_expression_list) { fprintf(prof_fp, "("); pp_list(subscript); fprintf(prof_fp, ")"); } else pprint(subscript); if (array->type == Node_param_list) fprintf(prof_fp, " in %s", fparms[array->param_cnt]); else fprintf(prof_fp, " in %s", array->vname); }

static void pp_lhs (  register NODE *  ptr  )  [static]

Definition at line 801 of file profile.c. References _, cant_happen, fatal, is_scalar(), n, Node_BINMODE, Node_builtin, Node_CONVFMT, Node_expression_list, Node_field_spec, Node_FIELDWIDTHS, Node_FNR, Node_FS, Node_IGNORECASE, Node_LINT, Node_NF, Node_NR, Node_OFMT, Node_OFS, Node_ORS, Node_param_list, Node_RS, Node_subscript, Node_TEXTDOMAIN, Node_var, Node_var_array, Node_var_new, pp_list(), tree_eval, and exp_node::type. Referenced by pp_getline(), pp_op_assign(), pprint(), and tree_eval(). { register NODE *n; switch (ptr->type) { case Node_var_array: fatal(_("attempt to use array `%s' in a scalar context"), ptr->vname); case Node_var_new: case Node_var: fprintf(prof_fp, "%s", ptr->vname); break; case Node_FIELDWIDTHS: fprintf(prof_fp, "FIELDWIDTHS"); break; case Node_RS: fprintf(prof_fp, "RS"); break; case Node_FS: fprintf(prof_fp, "FS"); break; case Node_FNR: fprintf(prof_fp, "FNR"); break; case Node_NR: fprintf(prof_fp, "NR"); break; case Node_NF: fprintf(prof_fp, "NF"); break; case Node_IGNORECASE: fprintf(prof_fp, "IGNORECASE"); break; case Node_BINMODE: fprintf(prof_fp, "BINMODE"); break; case Node_LINT: fprintf(prof_fp, "LINT"); break; case Node_OFMT: fprintf(prof_fp, "OFMT"); break; case Node_CONVFMT: fprintf(prof_fp, "CONVFMT"); break; case Node_ORS: fprintf(prof_fp, "ORS"); break; case Node_OFS: fprintf(prof_fp, "OFS"); break; case Node_TEXTDOMAIN: fprintf(prof_fp, "TEXTDOMAIN"); break; case Node_param_list: fprintf(prof_fp, "%s", fparms[ptr->param_cnt]); break; case Node_field_spec: fprintf(prof_fp, "$"); if (is_scalar(ptr->lnode->type)) tree_eval(ptr->lnode); else { fprintf(prof_fp, "("); tree_eval(ptr->lnode); fprintf(prof_fp, ")"); } break; case Node_subscript: n = ptr->lnode; if (n->type == Node_param_list) { fprintf(prof_fp, "%s[", fparms[n->param_cnt]); } else fprintf(prof_fp, "%s[", n->vname); if (ptr->rnode->type == Node_expression_list) pp_list(ptr->rnode); else tree_eval(ptr->rnode); fprintf(prof_fp, "]"); break; case Node_builtin: fatal(_("assignment is not allowed to result of builtin function")); default: cant_happen(); } }

static void pp_list (  register NODE *  tree  )  [static]

Definition at line 1003 of file profile.c. References Node_expression_list, nodetype2str(), NULL, and tree_eval. Referenced by pp_builtin(), pp_delete(), pp_func_call(), pp_in_array(), pp_lhs(), and pp_print_stmt(). { for (; tree != NULL; tree = tree->rnode) { if (tree->type != Node_expression_list) { fprintf(stderr, "pp_list: got %s\n", nodetype2str(tree->type)); fflush(stderr); } assert(tree->type == Node_expression_list); tree_eval(tree->lnode); if (tree->rnode != NULL) fprintf(prof_fp, ", "); } }

static void pp_match_op (  register NODE *  tree  )  [static]

Definition at line 910 of file profile.c. References Node_dynregex, Node_match, Node_nomatch, Node_regex, NULL, pp_string(), and tree_eval. Referenced by tree_eval(). { register NODE *re; const char *op; const char *restr; size_t relen; NODE *text = NULL; if (tree->type == Node_dynregex) { tree_eval(tree->re_exp); return; } if (tree->type == Node_regex) { re = tree->re_exp; restr = re->stptr; relen = re->stlen; pp_string(restr, relen, '/'); return; } /* at this point, have either ~ or !~ */ text = tree->lnode; re = tree->rnode; if (tree->type == Node_nomatch) op = "!~"; else if (tree->type == Node_match) op = "~"; else op = ""; tree_eval(text); fprintf(prof_fp, " %s ", op); tree_eval(re); }

static void pp_op_assign (  register NODE *  tree  )  [static]

Definition at line 719 of file profile.c. References cant_happen, Node_assign_exp, Node_assign_minus, Node_assign_mod, Node_assign_plus, Node_assign_quotient, Node_assign_times, Node_postdecrement, Node_postincrement, Node_predecrement, Node_preincrement, NULL, pp_lhs(), and tree_eval. Referenced by tree_eval(). { const char *op = NULL; enum Order { NA = 0, PRE = 1, POST = 2 } order = NA; switch(tree->type) { case Node_preincrement: op = "++"; order = PRE; break; case Node_predecrement: op = "--"; order = PRE; break; case Node_postincrement: op = "++"; order = POST; break; case Node_postdecrement: op = "--"; order = POST; break; default: break; /* handled below */ } if (order == PRE) { fprintf(prof_fp, "%s", op); pp_lhs(tree->lnode); return; } else if (order == POST) { pp_lhs(tree->lnode); fprintf(prof_fp, "%s", op); return; } /* a binary op */ pp_lhs(tree->lnode); switch(tree->type) { case Node_assign_exp: fprintf(prof_fp, " ^= "); break; case Node_assign_times: fprintf(prof_fp, " *= "); break; case Node_assign_quotient: fprintf(prof_fp, " /= "); break; case Node_assign_mod: fprintf(prof_fp, " %%= "); break; case Node_assign_plus: fprintf(prof_fp, " += "); break; case Node_assign_minus: fprintf(prof_fp, " -= "); break; default: cant_happen(); } tree_eval(tree->rnode); }

static void pp_print_stmt (  const char *  command, register NODE *  tree )  [static]

Definition at line 1021 of file profile.c. References AFTER, indent(), NULL, pp_list(), and pp_redir(). Referenced by pprint(). { NODE *redir = tree->rnode; indent(tree->exec_count); fprintf(prof_fp, "%s", command); if (redir != NULL) { if (tree->lnode != NULL) { /* parenthesize if have a redirection and a list */ fprintf(prof_fp, "("); pp_list(tree->lnode); fprintf(prof_fp, ")"); } else fprintf(prof_fp, " $0"); pp_redir(redir, AFTER); } else { fprintf(prof_fp, " "); if (tree->lnode != NULL) pp_list(tree->lnode); else fprintf(prof_fp, "$0"); } fprintf(prof_fp, "\n"); }

static void pp_redir (  register NODE *  tree, enum redir_placement  dir )  [static]

Definition at line 951 of file profile.c. References BEFORE, cant_happen, is_scalar(), Node_redirect_append, Node_redirect_input, Node_redirect_output, Node_redirect_pipe, Node_redirect_pipein, Node_redirect_twoway, NULL, and tree_eval. Referenced by pp_getline(), and pp_print_stmt(). { const char *op = "[BOGUS]"; /* should never be seen */ if (tree == NULL) return; switch (tree->type) { case Node_redirect_output: op = ">"; break; case Node_redirect_append: op = ">>"; break; case Node_redirect_pipe: op = "|"; break; case Node_redirect_pipein: op = "|"; break; case Node_redirect_input: op = "<"; break; case Node_redirect_twoway: op = "|&"; break; default: cant_happen(); } if (dir == BEFORE) { if (! is_scalar(tree->subnode->type)) { fprintf(prof_fp, "("); tree_eval(tree->subnode); fprintf(prof_fp, ")"); } else tree_eval(tree->subnode); fprintf(prof_fp, " %s ", op); } else { fprintf(prof_fp, " %s ", op); if (! is_scalar(tree->subnode->type)) { fprintf(prof_fp, "("); tree_eval(tree->subnode); fprintf(prof_fp, ")"); } else tree_eval(tree->subnode); } }

static void pp_string (  const char *  str, size_t  len, int  delim )  [static]

Definition at line 1224 of file profile.c. References FALSE, and pp_string_fp(). Referenced by pp_match_op(), and tree_eval(). { pp_string_fp(prof_fp, str, len, delim, FALSE); }

void pp_string_fp (  FILE *  fp, const char *  in_str, size_t  len, int  delim, int  breaklines )

Definition at line 1237 of file profile.c. References BELL, BREAKPOINT, i, NULL, strchr(), and whiny_users. Referenced by dumpintlstr(), dumpintlstr2(), pp_string(), and valinfo(). { static char escapes[] = "\b\f\n\r\t\v\\"; static char printables[] = "bfnrtv\\"; char *cp; int i; int count; #define BREAKPOINT 70 /* arbitrary */ const unsigned char *str = (const unsigned char *) in_str; fprintf(fp, "%c", delim); for (count = 0; len > 0; len--, str++) { if (++count >= BREAKPOINT && breaklines) { fprintf(fp, "%c\n%c", delim, delim); count = 0; } if (*str == delim) { fprintf(fp, "\\%c", delim); count++; } else if (*str == BELL) { fprintf(fp, "\\a"); count++; } else if ((cp = strchr(escapes, *str)) != NULL) { i = cp - escapes; putc('\\', fp); count++; putc(printables[i], fp); if (breaklines && *str == '\n' && delim == '"') { fprintf(fp, "\"\n\""); count = 0; } /* NB: Deliberate use of lower-case versions. */ } else if (isascii(*str) && isprint(*str)) { putc(*str, fp); } else { char buf[10]; /* print 'em as they came if for whiny users */ if (whiny_users) sprintf(buf, "%c", *str & 0xff); else sprintf(buf, "\\%03o", *str & 0xff); count += strlen(buf) - 1; fprintf(fp, "%s", buf); } } fprintf(fp, "%c", delim); }

static void pprint (  register NODE *volatile  tree  )  [static]

Definition at line 159 of file profile.c. References eval_condition(), FALSE, indent(), indent_in(), indent_out(), Node_case_list, Node_K_arrayfor, Node_K_break, Node_K_case, Node_K_continue, Node_K_default, Node_K_delete, Node_K_do, Node_K_exit, Node_K_for, Node_K_if, Node_K_next, Node_K_nextfile, Node_K_print, Node_K_print_rec, Node_K_printf, Node_K_return, Node_K_switch, Node_K_while, Node_param_list, Node_rule_list, Node_rule_node, Node_statement_list, Node_switch_body, NULL, pp_delete(), pp_lhs(), pp_print_stmt(), source, sourceline, SPACEOVER, tree_eval, TRUE, and exp_node::type. Referenced by dump_prog(), pp_func(), and pp_in_array(). { register NODE *volatile t = NULL; /* temporary */ int volatile traverse = TRUE; /* True => loop thru tree (Node_rule_list) */ /* avoid false source indications */ source = NULL; sourceline = 0; if (tree == NULL) return; sourceline = tree->source_line; source = tree->source_file; switch (tree->type) { case Node_rule_node: traverse = FALSE; /* False => one for-loop iteration only */ /* FALL THROUGH */ case Node_rule_list: for (t = tree; t != NULL; t = t->rnode) { if (traverse) tree = t->lnode; sourceline = tree->source_line; source = tree->source_file; if (! in_BEGIN_or_END) indent(tree->exec_count); if (tree->lnode) { eval_condition(tree->lnode); if (tree->rnode) fprintf(prof_fp, "\t"); } if (tree->rnode) { if (! in_BEGIN_or_END) { fprintf(prof_fp, "{"); if (tree->lnode != NULL && tree->lnode->exec_count) fprintf(prof_fp, " # %ld", tree->lnode->exec_count); fprintf(prof_fp, "\n"); } indent_in(); pprint(tree->rnode); indent_out(); if (! in_BEGIN_or_END) { indent(SPACEOVER); fprintf(prof_fp, "}\n"); } } if (! traverse) /* case Node_rule_node */ break; /* don't loop */ if (t->rnode && ! in_BEGIN_or_END) fprintf(prof_fp, "\n"); } break; case Node_statement_list: for (t = tree; t != NULL; t = t->rnode) { pprint(t->lnode);