Lines Matching refs:TT
251 #define GLOBAL ((struct symtab_slot *)TT.globals_table.base)
252 #define LOCAL ((struct symtab_slot *)TT.locals_table.base)
253 #define FUNC_DEF ((struct functab_slot *)TT.func_def_table.base)
255 #define LITERAL ((struct zvalue *)TT.literals.base)
256 #define STACK ((struct zvalue *)TT.stack.base)
257 #define FIELD ((struct zvalue *)TT.fields.base)
259 #define ZCODE ((int *)TT.zcode.base)
347 fprintf(stderr, "%s: ", TT.progname);
353 fprintf(stderr, "file %s line %d: ", TT.scs->filename, TT.scs->line_num);
361 else if (!strstr(format, "arning")) TT.cgl.compile_error_count++;
546 *++TT.stackp = *v;
728 TT.scs->filename = TT.scs->prog_args->arg;
729 TT.scs->prog_args = TT.scs->prog_args->next;
730 TT.scs->fp = stdin;
731 if (strcmp(TT.scs->filename, "-")) TT.scs->fp = fopen(TT.scs->filename, "r");
732 if (!TT.scs->fp) error_exit("Can't open %s", TT.scs->filename);
733 TT.scs->line_num = 0;
739 // On first entry, TT.scs->p points to progstring if any, or null string.
741 int c = *(TT.scs->p)++;
745 if (TT.scs->progstring) { // Fake newline at end of progstring.
746 if (TT.scs->progstring == nl) return EOF;
747 TT.scs->p = TT.scs->progstring = nl;
751 if (TT.scs->line == nl) return EOF;
752 if (!TT.scs->fp) {
758 int lastchar = (TT.scs->p)[-2];
759 TT.scs->line_len = getline(&TT.scs->line, &TT.scs->line_size, TT.scs->fp);
760 if (TT.scs->line_len > 0) {
761 TT.scs->line_num++;
762 TT.scs->p = TT.scs->line;
767 fclose(TT.scs->fp);
768 TT.scs->fp = 0;
769 TT.scs->p = " " + 2;
770 if (!TT.scs->prog_args) {
771 xfree(TT.scs->line);
774 TT.scs->line = TT.scs->p = nl;
781 if (TT.scs->toklen == TT.scs->maxtok - 1) {
782 TT.scs->maxtok *= 2;
783 TT.scs->tokstr = xrealloc(TT.scs->tokstr, TT.scs->maxtok);
785 TT.scs->tokstr[TT.scs->toklen++] = c;
786 TT.scs->tokstr[TT.scs->toklen] = 0;
793 TT.scs->ch = get_char();
794 } while (TT.scs->ch == '\r');
799 append_this_char(TT.scs->ch);
809 if (TT.scs->toklen >= 10) return 0;
810 strcat(s, TT.scs->tokstr);
822 strcat(s, TT.scs->tokstr);
841 // Assumes TT.scs->ch is digit or dot on entry.
842 // TT.scs->p points to the following character.
850 TT.scs->numval = strtod(TT.scs->p - 1, &leftover);
851 len = leftover - TT.scs->p + 1;
854 TT.scs->toktype = ERROR;
855 TT.scs->tok = tkerr;
856 TT.scs->error = 1;
857 FFATAL("Unexpected token '%s'\n", TT.scs->tokstr);
867 while (TT.scs->ch != endchar) {
868 if (TT.scs->ch == '\n') {
873 } else if (TT.scs->ch == '\\') {
877 if (TT.scs->ch == '\n') { // backslash newline is continuation
880 } else if ((p = strchr(escapes, TT.scs->ch))) {
888 } else if (TT.scs->ch == 'x') {
890 if (isxdigit(TT.scs->ch)) {
891 int c = hexval(TT.scs->ch);
893 if (isxdigit(TT.scs->ch)) {
894 c = c * 16 + hexval(TT.scs->ch);
899 } else if (TT.scs->ch == 'u') {
901 if (isxdigit(TT.scs->ch)) {
905 codep[j++] = TT.scs->ch;
907 } while (j < 8 && isxdigit(TT.scs->ch));
912 } else if (isdigit(TT.scs->ch)) {
913 if (TT.scs->ch < '8') {
916 if (isdigit(TT.scs->ch) && TT.scs->ch < '8') {
917 c = c * 8 + TT.scs->ch - '0';
930 if (!strchr(".[]()*+?{}|^$-", TT.scs->ch)) {
931 XERR("warning: '\\%c' -- unknown regex escape\n", TT.scs->ch);
935 XERR("warning: '\\%c' treated as plain '%c'\n", TT.scs->ch, TT.scs->ch);
938 } else if (TT.scs->ch == EOF) {
951 TT.scs->tokbuiltin = 0;
952 TT.scs->toklen = 0;
953 TT.scs->tokstr[0] = 0;
954 while (TT.scs->ch == ' ' || TT.scs->ch == '\t')
956 if (TT.scs->ch == '\\') {
958 if (TT.scs->ch == '\n') {
962 TT.scs->toktype = ERROR; // \ not last char in line.
963 TT.scs->tok = tkerr;
964 TT.scs->error = 3;
971 if (TT.scs->ch == '#') {
973 while (TT.scs->ch != '\n')
977 if (TT.scs->ch == '\n') {
978 TT.scs->toktype = NEWLINE;
979 TT.scs->tok = tknl;
981 } else if (isalpha(TT.scs->ch) || TT.scs->ch == '_') {
983 while (isalnum(TT.scs->ch) || TT.scs->ch == '_') {
987 TT.scs->toktype = KEYWORD;
988 TT.scs->tok = n;
990 TT.scs->toktype = BUILTIN;
991 TT.scs->tok = tkbuiltin;
992 TT.scs->tokbuiltin = n;
993 } else if ((TT.scs->ch == '(')) {
994 TT.scs->toktype = USERFUNC;
995 TT.scs->tok = tkfunc;
997 TT.scs->toktype = VAR;
998 TT.scs->tok = tkvar;
1000 while (TT.scs->ch == ' ' || TT.scs->ch == '\t')
1004 } else if (TT.scs->ch == '"') {
1005 TT.scs->toktype = STRING;
1006 TT.scs->tok = tkstring;
1008 } else if (isdigit(TT.scs->ch) || TT.scs->ch == '.') {
1009 TT.scs->toktype = NUMBER;
1010 TT.scs->tok = tknumber;
1012 } else if (TT.scs->ch == '/' && ! div_op_allowed_here) {
1013 TT.scs->toktype = REGEX;
1014 TT.scs->tok = tkregex;
1016 } else if (TT.scs->ch == EOF) {
1017 TT.scs->toktype = EOF;
1018 TT.scs->tok = tkeof;
1019 } else if (TT.scs->ch == '\0') {
1021 TT.scs->toktype = ERROR;
1022 TT.scs->tok = tkerr;
1023 TT.scs->error = 5;
1027 TT.scs->toktype = TT.scs->ch;
1030 if (TT.scs->toktype == '*' && TT.scs->ch == '*') {
1032 if (TT.scs->ch == '=') {
1034 TT.scs->tok = tkpowasgn;
1035 } else TT.scs->tok = tkpow;
1036 TT.scs->toktype = TT.scs->tok + 200;
1040 if (TT.scs->ch != ' ' && TT.scs->ch != '\n') {
1041 append_this_char(TT.scs->ch);
1043 TT.scs->tok = find_token();
1044 TT.scs->toktype = TT.scs->tok + 200;
1048 TT.scs->toklen--; // Not 2-character token; back off.
1049 TT.scs->tokstr[TT.scs->toklen] = 0;
1051 TT.scs->tok = find_token();
1052 if (TT.scs->tok) return;
1053 TT.scs->toktype = ERROR;
1054 TT.scs->tok = tkerr;
1055 TT.scs->error = 4;
1056 FFATAL("Unexpected token '%s'\n", TT.scs->tokstr);
1064 do ascan_opt_div(div_op_allowed_here); while (TT.scs->tok == tkerr);
1069 TT.prevtok = tkeof;
1081 TT.prevtok = TT.scs->tok;
1082 if (TT.prevtok && strchr(div_preceders, TT.prevtok)) scan_opt_div(1);
1084 TT.tokstr = TT.scs->tokstr;
1104 #define CURTOK() (TT.scs->tok)
1105 #define ISTOK(toknum) (TT.scs->tok == (toknum))
1117 zlist_append(&TT.zcode, &op);
1118 TT.zcode_last = zlist_append(&TT.zcode, &n);
1123 TT.zcode_last = zlist_append(&TT.zcode, &op);
1130 return zlist_append(&TT.literals, &v);
1142 return zlist_append(&TT.literals, &v);
1148 return zlist_append(&TT.literals, &v);
1154 return zlist_append(&TT.literals, &v);
1161 for (int k = 1; k < zlist_len(&TT.func_def_table); k++)
1170 int slotnum = zlist_append(&TT.func_def_table, &ent);
1177 for (int k = 1; k < zlist_len(&TT.globals_table); k++)
1186 int slotnum = zlist_append(&TT.globals_table, &ent);
1193 for (int k = 1; k < zlist_len(&TT.locals_table); k++)
1202 int slotnum = zlist_append(&TT.locals_table, &ent);
1211 int locals_ent = find_local_entry(TT.tokstr); // in local symbol table?
1215 globals_ent = find_global(TT.tokstr);
1216 if (!globals_ent) globals_ent = add_global(TT.tokstr);
1218 if (find_func_def_entry(TT.tokstr))
1221 XERR("var '%s' used as function name\n", TT.tokstr);
1232 zlist_init(&TT.locals_table, sizeof(struct symtab_slot));
1233 zlist_append(&TT.locals_table, &locals_ent);
1242 zlist_init(&TT.globals_table, sizeof(struct symtab_slot));
1243 zlist_append(&TT.globals_table, &global_ent);
1244 zlist_init(&TT.func_def_table, sizeof(struct functab_slot));
1245 zlist_append(&TT.func_def_table, &func_ent);
1247 zlist_init(&TT.zcode, sizeof(int));
1249 zlist_init(&TT.literals, sizeof(struct zvalue));
1253 zlist_initx(&TT.stack, sizeof(struct zvalue), 2 * MIN_STACK_LEFT);
1254 TT.stackp = (struct zvalue *)TT.stack.base;
1255 zlist_init(&TT.fields, sizeof(struct zvalue));
1256 zlist_append(&TT.literals, &uninit_zvalue);
1257 zlist_append(&TT.stack, &uninit_zvalue);
1258 zlist_append(&TT.fields, &uninit_zvalue);
1271 TT.spec_var_limit = add_global(spec_vars[k]);
1272 GLOBAL[TT.spec_var_limit++].flags |= (k == 1 || k == 3) ? ZF_MAP : ZF_SCALAR;
1278 //// Parsing and compiling to TT.zcode
1303 if (TT.cgl.in_print_stmt && ! TT.cgl.paren_level && (tok == tkgt || tok == tkpipe))
1335 if (!strcmp(TT.tokstr, "\n")) TT.tokstr = "<newline>";
1338 XERR("syntax near '%s' -- '%s' expected\n", TT.tokstr, op);
1343 XERR("syntax near '%s' -- '%s' expected\n", TT.tokstr, tkstr);
1344 } else XERR("syntax near '%s'\n", TT.tokstr);
1447 TT.cgl.paren_level++;
1452 gen2cd(tkregex, make_literal_regex_val(TT.tokstr));
1472 gen2cd(tkregex, make_literal_regex_val(TT.tokstr));
1482 if (ISTOK(tkvar) && (TT.scs->ch == ',' || TT.scs->ch == ')')) {
1493 gen2cd(tkregex, make_literal_regex_val(TT.tokstr));
1501 if (ISTOK(tkvar) && (TT.scs->ch == ',' || TT.scs->ch == ')')) {
1517 TT.cgl.paren_level--;
1526 // Function call: generate TT.zcode to:
1536 functk = TT.scs->tokbuiltin;
1537 strcpy(builtin_name, TT.tokstr);
1539 funcnum = find_func_def_entry(TT.tokstr);
1540 if (!funcnum) funcnum = add_func_def_entry(TT.tokstr);
1543 } else error_exit("bad function %s!", TT.tokstr);
1556 TT.cgl.paren_level++;
1561 if (ISTOK(tkvar) && (TT.scs->ch == ',' || TT.scs->ch == ')')) {
1571 TT.cgl.paren_level--;
1577 // var name is in TT.tokstr
1636 // can find either tkfield or tkvar at same place (ZCODE[TT.zcode_last-1]).
1660 if (ZCODE[TT.zcode_last - 1] == tkvar) ZCODE[TT.zcode_last-1] = opvarref;
1661 else if (ZCODE[TT.zcode_last - 1] == opmap) ZCODE[TT.zcode_last - 1] = opmapref;
1662 else if (ZCODE[TT.zcode_last - 1] == tkfield) ZCODE[TT.zcode_last - 1] = opfldref;
1675 XERR("syntax near '%s' (bad lvalue)\n", TT.tokstr);
1721 gen2cd(tknumber, make_literal_num_val(TT.scs->numval));
1726 gen2cd(tkstring, make_literal_str_val(TT.tokstr));
1736 gen2cd(opmatchrec, make_literal_regex_val(TT.tokstr));
1767 TT.cgl.paren_level++;
1774 TT.cgl.paren_level--;
1801 XERR("syntax near '%s'\n", TT.tokstr[0] == '\n' ? "\\n" : TT.tokstr);
1810 int nargs, cdx = 0; // index in TT.zcode list
1843 cdx = TT.zcode_last; // tkor: jump if true, else drop
1845 gencd(opnotnot); // replace TT.stack top with truth value
1846 ZCODE[cdx] = TT.zcode_last - cdx;
1851 cdx = TT.zcode_last;
1855 ZCODE[cdx] = TT.zcode_last - cdx;
1856 cdx = TT.zcode_last;
1858 ZCODE[cdx] = TT.zcode_last - cdx;
1864 if (ZCODE[TT.zcode_last - 1] == opmatchrec) ZCODE[TT.zcode_last - 1] = tkregex;
1888 // On entry: TT.scs has first symbol of expression, e.g. var, number, string,
1906 XERR("syntax near '%s'; expected 'in'\n", TT.tokstr);
1928 XERR("syntax near '%s'\n", TT.tokstr[0] == '\n' ? "\\n" : TT.tokstr);
1945 TT.cgl.in_print_stmt = 1;
1965 TT.cgl.in_print_stmt = 0;
2011 XERR("syntax near '%s'\n", TT.tokstr[0] == '\n' ? "\\n" : TT.tokstr);
2018 return !!strchr(stmtendsy, TT.prevtok);
2033 int cdx = TT.zcode_last;
2043 ZCODE[cdx] = TT.zcode_last - cdx;
2044 cdx = TT.zcode_last;
2049 ZCODE[cdx] = TT.zcode_last - cdx;
2054 *brk = TT.cgl.break_dest;
2055 *cont = TT.cgl.continue_dest;
2060 TT.cgl.break_dest = *brk;
2061 TT.cgl.continue_dest = *cont;
2070 TT.cgl.continue_dest = TT.zcode_last + 1;
2074 TT.cgl.break_dest = TT.zcode_last + 1;
2078 ZCODE[TT.zcode_last] = TT.cgl.continue_dest - TT.zcode_last - 1;
2079 ZCODE[TT.cgl.break_dest + 1] = TT.zcode_last - TT.cgl.break_dest - 1;
2090 TT.cgl.continue_dest = TT.zcode_last + 1;
2092 TT.cgl.break_dest = TT.zcode_last + 1;
2100 XERR("syntax near '%s' -- ';' or newline expected\n", TT.tokstr);
2104 ZCODE[TT.cgl.continue_dest + 1] = TT.zcode_last - TT.cgl.continue_dest - 1;
2110 gen2cd(tkwhile, TT.cgl.break_dest - TT.zcode_last - 1);
2111 ZCODE[TT.cgl.break_dest + 1] = TT.zcode_last - TT.cgl.break_dest - 1;
2118 int condition_loc = TT.zcode_last + 1;
2130 TT.cgl.break_dest = TT.zcode_last + 1;
2132 TT.cgl.continue_dest = TT.zcode_last + 1;
2134 gen2cd(opjump, condition_loc - TT.zcode_last - 3);
2136 ZCODE[TT.cgl.break_dest - 1] = TT.zcode_last - TT.cgl.break_dest + 1;
2138 gen2cd(opjump, TT.cgl.continue_dest - TT.zcode_last - 3);
2139 ZCODE[TT.cgl.break_dest + 1] = TT.zcode_last - TT.cgl.break_dest - 1;
2159 int loop_start_loc = TT.zcode_last + 1;
2167 // FIXME TODO must examine generated TT.zcode for var in array?
2168 if (!valid_for_array_iteration(loop_start_loc, TT.zcode_last))
2171 ZCODE[TT.zcode_last-5] = opvarref;
2172 ZCODE[TT.zcode_last-1] = tknumber;
2173 ZCODE[TT.zcode_last] = make_literal_num_val(-1);
2174 TT.cgl.continue_dest = TT.zcode_last + 1;
2176 TT.cgl.break_dest = TT.zcode_last + 1;
2180 // fixup TT.stack if return or exit inside for (var in array)
2181 TT.cgl.stack_offset_to_fix += 3;
2183 TT.cgl.stack_offset_to_fix -= 3;
2184 gen2cd(opjump, TT.cgl.continue_dest - TT.zcode_last - 3);
2185 ZCODE[TT.cgl.break_dest + 1] = TT.zcode_last - TT.cgl.break_dest - 1;
2202 if (TT.cgl.break_dest) gen2cd(tkbreak, TT.cgl.break_dest - TT.zcode_last - 3);
2208 if (TT.cgl.continue_dest)
2209 gen2cd(tkcontinue, TT.cgl.continue_dest - TT.zcode_last - 3);
2216 if (TT.cgl.rule_type) XERR("%s", "next inside BEGIN or END\n");
2217 if (TT.cgl.in_function_body) XERR("%s", "next inside function def\n");
2223 if (TT.cgl.rule_type) XERR("%s", "nextfile inside BEGIN or END\n");
2224 if (TT.cgl.in_function_body) XERR("%s", "nextfile inside function def\n");
2237 if (TT.cgl.stack_offset_to_fix) gen2cd(opdrop_n, TT.cgl.stack_offset_to_fix);
2241 gen2cd(tkreturn, TT.cgl.nparms);
2242 if (!TT.cgl.in_function_body) XERR("%s", "return outside function def\n");
2277 TT.cgl.nparms++;
2286 if (find_global(s) && find_global(s) < TT.spec_var_limit)
2294 int funcnum = find_func_def_entry(TT.tokstr);
2296 funcnum = add_func_def_entry(TT.tokstr);
2298 XERR("dup defined function '%s'\n", TT.tokstr);
2301 if (find_global(TT.tokstr)) {
2304 XERR("function name '%s' previously defined\n", TT.tokstr);
2308 FUNC_DEF[funcnum].zcode_addr = TT.zcode_last - 1;
2309 TT.cgl.funcnum = funcnum;
2310 TT.cgl.nparms = 0;
2315 add_param(funcnum, TT.tokstr);
2317 // FIXME is the the best way? what if TT.tokstr not a tkvar?
2319 add_param(funcnum, TT.tokstr);
2325 TT.cgl.in_function_body = 1;
2327 TT.cgl.in_function_body = 0;
2330 gen2cd(tkreturn, TT.cgl.nparms);
2332 XERR("syntax near '%s'\n", TT.tokstr);
2338 FUNC_DEF[funcnum].function_locals = TT.locals_table;
2362 XERR("syntax near '%s' -- newline, ';', or '}' expected\n", TT.tokstr);
2386 if (TT.cgl.last_begin) ZCODE[TT.cgl.last_begin] = TT.zcode_last - TT.cgl.last_begin;
2387 else TT.cgl.first_begin = TT.zcode_last + 1;
2389 TT.cgl.rule_type = tkbegin;
2391 TT.cgl.rule_type = 0;
2393 TT.cgl.last_begin = TT.zcode_last;
2398 if (TT.cgl.last_end) ZCODE[TT.cgl.last_end] = TT.zcode_last - TT.cgl.last_end;
2399 else TT.cgl.first_end = TT.zcode_last + 1;
2401 TT.cgl.rule_type = tkbegin;
2403 TT.cgl.rule_type = 0;
2405 TT.cgl.last_end = TT.zcode_last;
2409 if (TT.cgl.last_recrule)
2410 ZCODE[TT.cgl.last_recrule] = TT.zcode_last - TT.cgl.last_recrule;
2411 else TT.cgl.first_recrule = TT.zcode_last + 1;
2414 TT.cgl.last_recrule = TT.zcode_last;
2421 if (TT.cgl.last_recrule)
2422 ZCODE[TT.cgl.last_recrule] = TT.zcode_last - TT.cgl.last_recrule;
2423 else TT.cgl.first_recrule = TT.zcode_last + 1;
2426 int cdx = 0, saveloc = TT.zcode_last;
2430 cdx = TT.zcode_last;
2432 gen2cd(oprange2, ++TT.cgl.range_pattern_num);
2434 cdx = TT.zcode_last;
2436 ZCODE[saveloc-1] = TT.cgl.range_pattern_num;
2437 ZCODE[saveloc] = TT.zcode_last - saveloc;
2439 gen2cd(oprange3, TT.cgl.range_pattern_num);
2443 ZCODE[cdx] = TT.zcode_last - cdx;
2446 ZCODE[cdx] = TT.zcode_last - cdx;
2449 TT.cgl.last_recrule = TT.zcode_last;
2455 int n = zlist_len(&TT.func_def_table);
2477 if (TT.cgl.last_begin) ZCODE[TT.cgl.last_begin-1] = opquit;
2478 if (TT.cgl.last_end) ZCODE[TT.cgl.last_end-1] = opquit;
2479 if (TT.cgl.last_recrule) ZCODE[TT.cgl.last_recrule-1] = opquit;
2486 if (TT.cgl.first_end && !TT.cgl.first_recrule) {
2488 TT.cgl.first_recrule = TT.zcode_last;
2516 if (n == (long long)n) k = snprintf(TT.pbuf, PBUFSIZE, "%lld", (long long)n);
2517 else k = snprintf(TT.pbuf, PBUFSIZE, fmt, n);
2519 return new_zstring(TT.pbuf, k);
2688 snprintf(TT.one_char_fs, sizeof(TT.one_char_fs), "[%c]", fs[0]);
2689 return TT.one_char_fs;
2694 if (!strcmp(fs, " ")) return &TT.rx_default;
2695 if (!strcmp(fs, TT.fs_last)) return &TT.rx_last;
2697 strcpy(TT.fs_last, fs);
2698 regfree(&TT.rx_last);
2699 xregcomp(&TT.rx_last, fmt_one_char_fs(fs), REG_EXTENDED);
2700 return &TT.rx_last;
2724 STACK[NF].num = TT.nf_internal = nf;
2731 int nfields = zlist_len(&TT.fields);
2732 // Need nfields to be > fnum b/c e.g. fnum==1 implies 2 TT.fields
2734 nfields = zlist_append(&TT.fields, &uninit_zvalue) + 1;
2740 // Split s via fs, using setter; return number of TT.fields.
2741 // This is used to split TT.fields and also for split() builtin.
2770 // is zero and FS is found and FS is ' ' (TT.rx_default "[ \t]+"),
2773 if (offs || r || rx != &TT.rx_default) setter(m, ++nf, s, offs);
2776 if (!r && rx != &TT.rx_default) setter(m, ++nf, "", 0);
2791 int nf = TT.nf_internal;
2812 // increase the value of NF; create any intervening TT.fields with the
2814 // TT.fields being separated by the value of OFS.]
2819 if (fnum > TT.nf_internal) {
2820 // Ensure TT.fields list is large enough for fnum
2821 // Need len of TT.fields to be > fnum b/c e.g. fnum==1 implies 2 TT.fields
2822 for (int i = TT.nf_internal + 1; i <= fnum; i++) {
2823 if (i == zlist_len(&TT.fields)) zlist_append(&TT.fields, &uninit_zvalue);
2845 // After changing $0, must rebuild TT.fields & reset NF
2852 // Ensure TT.fields list is large enough for fnum
2853 // Need len of TT.fields to be > fnum b/c e.g. fnum==1 implies 2 TT.fields
2854 for (int i = TT.nf_internal + 1; i <= new_nf; i++) {
2855 if (i == zlist_len(&TT.fields)) zlist_append(&TT.fields, &uninit_zvalue);
2858 set_nf(TT.nf_internal = STACK[NF].num);
2863 // If it's 0, need to rebuild the TT.fields 1... n.
2876 // Contrary to posix, awk evaluates TT.fields beyond $NF as empty strings.
2877 if (fnum > TT.nf_internal) push_val(&uninit_string_zvalue);
2885 #define STKP TT.stackp // pointer to top of stack
2918 // Set and return logical (0/1) val of top TT.stack value; flag value as NUM.
3005 *f = (struct zfile){TT.zfiles, xstrdup(fn), fp, mode, file_or_pipe,
3007 return TT.zfiles = f;
3013 for (struct zfile *p = TT.zfiles; p; p = p->next)
3022 to_str(STKP); // filename at top of TT.stack
3027 for (struct zfile *p = TT.zfiles; p; p = p->next)
3036 struct zfile *np, **pp = &TT.zfiles;
3037 for (struct zfile *p = TT.zfiles; p; p = np) {
3061 to_str(STKP); // filename at top of TT.stack
3064 for (struct zfile *p = TT.zfiles; p; p = p->next)
3081 #define stkn(n) ((int)(TT.stackp - (n) - (struct zvalue *)TT.stack.base))
3099 if (TT.rgl.zspr->size + len + 1 > TT.rgl.zspr->capacity) {
3101 unsigned cap = 2 * TT.rgl.zspr->capacity + len;
3102 TT.rgl.zspr = xrealloc(TT.rgl.zspr, sizeof(*TT.rgl.zspr) + cap);
3103 TT.rgl.zspr->capacity = cap;
3105 vsnprintf(TT.rgl.zspr->str + TT.rgl.zspr->size, len+1, fmt, args2);
3106 TT.rgl.zspr->size += len;
3107 TT.rgl.zspr->str[TT.rgl.zspr->size] = 0;
3135 if (rx_find(&TT.rx_printf_fmt, fmt, &offs, &e, 0))
3165 pfmt = strcpy(TT.pbuf, fmt);
3267 if (++TT.rgl.narg >= (int)to_num(&STACK[ARGC])) return 0;
3270 num_to_zstring(TT.rgl.narg, to_str(&STACK[CONVFMT])->vst->str));
3273 zvalue_copy(&TT.rgl.cur_arg, to_str(get_map_val(v, &zkey)));
3274 arg = TT.rgl.cur_arg.vst->str;
3278 TT.rgl.nfiles++;
3285 if (TT.cfile->fp && TT.cfile->fp != stdin) fclose(TT.cfile->fp);
3286 if ((!fn && !TT.rgl.nfiles && TT.cfile->fp != stdin) || (fn && !strcmp(fn, "-"))) {
3287 TT.cfile->fp = stdin;
3291 if (!(TT.cfile->fp = fopen(fn, "r"))) FFATAL("can't open %s\n", fn);
3292 zvalue_copy(&STACK[FILENAME], &TT.rgl.cur_arg);
3295 TT.rgl.eof = 1;
3307 TT.rgl.recptr = zfp->recbuf_multi;
3322 TT.rgl.recptr = zfp->recbuf_multi;
3357 TT.rgl.recptr = zfp->recbuf + zfp->recoffs;
3358 r = rx_findx(rsrxp, TT.rgl.recptr, zfp->endoffs - zfp->recoffs, &so, &eo, 0);
3369 memmove(zfp->recbuf, TT.rgl.recptr, zfp->endoffs - zfp->recoffs);
3380 TT.rgl.recptr[so] = 0;
3392 if (TT.rgl.eof) return -1;
3393 if (!TT.cfile->fp) next_fp();
3395 if ((k = getrec_f(TT.cfile)) >= 0) return k;
3404 copy_to_field0(TT.rgl.recptr, k);
3413 copy_to_field0(TT.rgl.recptr, k);
3432 v->vst = new_zstring(TT.rgl.recptr, k);
3555 zlist_expand(&TT.stack);
3556 STKP = (struct zvalue *)TT.stack.base + k;
3557 *stackp_needmore = (struct zvalue *)TT.stack.limit - MIN_STACK_LEFT;
3573 *stackp_needmore = (struct zvalue*)TT.stack.limit - MIN_STACK_LEFT;
3754 // Now reverse the incr/decr on the top TT.stack val.
3777 struct zfile *outfp = TT.zstdout;
3799 ////// FIXME refcnt -- prob. don't need to copy from TT.stack?
3871 // Remove the local args (not supplied by caller) from TT.stack, check to
3923 if (k < 0) k = parmbase - k; // loc of var on TT.stack
3984 // can find either tkfield or tkvar at same place (ZCODE[TT.zcode_last-1]).
4055 if (TT.range_sw[range_num]) ip += op2;
4063 if (t) TT.range_sw[range_num] = 1;
4071 if (t) TT.range_sw[range_num] = 0;
4086 // TT.stack is:
4108 // nargs source TT.stack
4286 zstring_release(&TT.rgl.zspr);
4287 TT.rgl.zspr = new_zstring("", 0);
4290 vv = (struct zvalue)ZVINIT(ZF_STR, 0, TT.rgl.zspr);
4329 // is to allow the TT.stack to be readjusted after an 'exit' from a function.
4330 // Also catches errors, as the normal operation should leave the TT.stack
4336 // If exit from function, TT.stack will be loaded with args etc. Clean it.
4359 // Global variables reside at the bottom of the TT.stack. Start with the awk
4383 insert_argv_map(&m, 0, TT.progname);
4407 // Push global variables on the TT.stack at offsets matching their index in the
4419 int gstx, len = zlist_len(&TT.globals_table);
4420 for (gstx = TT.spec_var_limit; gstx < len; gstx++) {
4444 TT.rgl.cur_arg = new_str_val("<cmdline>");
4453 if ((r = interp(TT.cgl.first_recrule, status)) == tknextfile) next_fp();
4458 int len = zlist_len(&TT.literals);
4468 TT.cfile = xzalloc(sizeof(struct zfile));
4469 xregcomp(&TT.rx_default, "[ \t\n]+", REG_EXTENDED);
4470 xregcomp(&TT.rx_last, "[ \t\n]+", REG_EXTENDED);
4471 xregcomp(&TT.rx_printf_fmt, printf_fmt_rx, REG_EXTENDED);
4475 TT.zstdout = TT.zfiles;
4479 if (TT.cgl.first_begin) r = interp(TT.cgl.first_begin, &status);
4481 if (TT.cgl.first_recrule) run_files(&status);
4482 if (TT.cgl.first_end) r = interp(TT.cgl.first_end, &status);
4483 regfree(&TT.rx_printf_fmt);
4484 regfree(&TT.rx_default);
4485 regfree(&TT.rx_last);
4497 TT.scs->p = progstring ? progstring : " " + 2;
4498 TT.scs->progstring = progstring;
4499 TT.scs->prog_args = prog_args;
4500 TT.scs->filename = "(cmdline)";
4501 TT.scs->maxtok = 256;
4502 TT.scs->tokstr = xzalloc(TT.scs->maxtok);
4510 TT.scs = &ss;
4516 if (TT.cgl.compile_error_count)
4517 error_exit("%d syntax error(s)", TT.cgl.compile_error_count);
4523 return TT.cgl.compile_error_count;
4528 char *sepstring = TT.F ? escape_str(TT.F, 0) : " ";
4532 TT.pbuf = toybuf;
4534 if (!TT.f) {
4538 TT.progname = toys.which->name;
4539 toys.exitval = awk(sepstring, progstring, TT.f, TT.v,