8 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
9 #define IS(w, y) !strcmp(w, y)
11 #include "protoparse.h"
16 #define awarn(fmt, ...) \
17 printf("warning:%s:%d: " fmt, asmfn, asmln, ##__VA_ARGS__)
18 #define aerr(fmt, ...) do { \
19 printf("error:%s:%d: " fmt, asmfn, asmln, ##__VA_ARGS__); \
25 OPC_RMD, /* removed or optimized out */
26 OPC_DATA, /* data processing */
27 OPC_DATA_FLAGS, /* data processing + sets flags */
28 OPC_JMP, /* .. and call */
29 OPC_JCC, /* conditional jump */
30 OPC_SCC, /* conditionel set */
78 #define MAX_OPERANDS 2
91 struct parsed_opr operand[MAX_OPERANDS];
93 int regmask; // all referensed regs
105 static struct parsed_op ops[MAX_OPS];
106 static struct parsed_equ *g_eqs;
108 static char g_labels[MAX_OPS][32];
109 static struct parsed_proto g_func_pp;
110 static char g_func[256];
111 static char g_comment[256];
112 static int g_bp_frame;
113 static int g_bp_stack;
114 #define ferr(op_, fmt, ...) do { \
115 printf("error:%s:#%ld: " fmt, g_func, (op_) - ops, ##__VA_ARGS__); \
121 const char *regs_r32[] = { "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp" };
122 const char *regs_r16[] = { "ax", "bx", "cx", "dx", "si", "di", "bp", "sp" };
123 const char *regs_r8l[] = { "al", "bl", "cl", "dl" };
124 const char *regs_r8h[] = { "ah", "bh", "ch", "dh" };
126 enum x86_regs { xUNSPEC = -1, xAX, xBX, xCX, xDX, xSI, xDI, xBP, xSP };
128 static int char_array_i(const char *array[], size_t len, const char *s)
132 for (i = 0; i < len; i++)
139 static void parse_reg(struct parsed_opr *opr, int *regmask,
147 while (my_isblank(*s) || my_issep(*s))
149 s = next_idt(w, sizeof(w), s);
153 reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), w);
155 opr->lmod = OPLM_DWORD;
156 *regmask |= 1 << reg;
159 reg = char_array_i(regs_r16, ARRAY_SIZE(regs_r16), w);
161 opr->lmod = OPLM_WORD;
162 *regmask |= 1 << reg;
165 reg = char_array_i(regs_r8h, ARRAY_SIZE(regs_r8h), w);
167 opr->lmod = OPLM_BYTE;
168 *regmask |= 1 << reg;
171 reg = char_array_i(regs_r8l, ARRAY_SIZE(regs_r8l), w);
173 opr->lmod = OPLM_BYTE;
174 *regmask |= 1 << reg;
179 aerr("bad reg: '%s'\n", w);
186 static long parse_number(const char *number)
188 int len = strlen(number);
189 const char *p = number;
199 if (len > 1 && *p == '0')
201 if (number[len - 1] == 'h') {
202 ret = strtol(p, &endp, 16);
203 bad = (*endp != 'h');
206 ret = strtol(p, &endp, 10);
210 aerr("number parsing failed\n");
216 static int parse_operand(struct parsed_opr *opr, int *regmask,
217 char words[16][256], int wordc, int w, enum op_class cls)
223 aerr("parse_operand w %d, wordc %d\n", w, wordc);
227 for (i = w; i < wordc; i++) {
228 len = strlen(words[i]);
229 if (words[i][len - 1] == ',') {
230 words[i][len - 1] = 0;
236 if (cls == OPC_JMP || cls == OPC_JCC) {
239 if (wordc - w == 3 && IS(words[w + 1], "ptr"))
240 label = words[w + 2];
241 else if (wordc - w == 2 && IS(words[w], "short"))
242 label = words[w + 1];
243 else if (wordc - w == 1)
246 aerr("jump parse error");
248 opr->type = OPT_LABEL;
249 strcpy(opr->name, label);
253 if (wordc - w >= 3) {
254 if (IS(words[w + 1], "ptr")) {
255 if (IS(words[w], "dword"))
256 opr->lmod = OPLM_DWORD;
257 else if (IS(words[w], "word"))
258 opr->lmod = OPLM_WORD;
259 else if (IS(words[w], "byte"))
260 opr->lmod = OPLM_BYTE;
262 aerr("type parsing failed\n");
267 if (wordc - w == 2 && IS(words[w], "offset")) {
268 opr->type = OPT_LABEL;
269 strcpy(opr->name, words[w + 1]);
274 aerr("parse_operand 1 word expected\n");
276 len = strlen(words[w]);
278 if (words[w][0] == '[') {
279 opr->type = OPT_REGMEM;
280 ret = sscanf(words[w], "[%[^]]]", opr->name);
282 aerr("[] parse failure\n");
283 parse_reg(opr, regmask, opr->name, 0);
286 else if (('0' <= words[w][0] && words[w][0] <= '9')
287 || words[w][0] == '-')
289 opr->type = OPT_CONST;
290 opr->val = (unsigned int)parse_number(words[w]);
295 strcpy(opr->name, words[w]);
296 parse_reg(opr, regmask, opr->name, 1);
301 static const struct {
308 { "push", OP_PUSH, OPC_DATA, 1, 1 },
309 { "pop", OP_POP, OPC_DATA, 1, 1 },
310 { "mov" , OP_MOV, OPC_DATA, 2, 2 },
311 { "add", OP_ADD, OPC_DATA_FLAGS, 2, 2 },
312 { "test", OP_TEST, OPC_DATA_FLAGS, 2, 2 },
313 { "cmp", OP_CMP, OPC_DATA_FLAGS, 2, 2 },
314 { "retn", OP_RET, OPC_JMP, 0, 1 },
315 { "call", OP_CALL, OPC_JMP, 1, 1 },
316 { "jmp", OP_JMP, OPC_JMP, 1, 1 },
317 { "jo", OP_JO, OPC_JCC, 1, 1 }, // 70 OF=1
318 { "jno", OP_JNO, OPC_JCC, 1, 1 }, // 71 OF=0
319 { "jc", OP_JC, OPC_JCC, 1, 1 }, // 72 CF=1
320 { "jb", OP_JC, OPC_JCC, 1, 1 }, // 72
321 { "jnc", OP_JNC, OPC_JCC, 1, 1 }, // 73 CF=0
322 { "jae", OP_JNC, OPC_JCC, 1, 1 }, // 73
323 { "jz", OP_JZ, OPC_JCC, 1, 1 }, // 74 ZF=1
324 { "je", OP_JZ, OPC_JCC, 1, 1 }, // 74
325 { "jnz", OP_JNZ, OPC_JCC, 1, 1 }, // 75 ZF=0
326 { "jne", OP_JNZ, OPC_JCC, 1, 1 }, // 75
327 { "jbe", OP_JBE, OPC_JCC, 1, 1 }, // 76 CF=1 || ZF=1
328 { "jna", OP_JBE, OPC_JCC, 1, 1 }, // 76
329 { "ja", OP_JA, OPC_JCC, 1, 1 }, // 77 CF=0 && ZF=0
330 { "jnbe", OP_JA, OPC_JCC, 1, 1 }, // 77
331 { "js", OP_JS, OPC_JCC, 1, 1 }, // 78 SF=1
332 { "jns", OP_JNS, OPC_JCC, 1, 1 }, // 79 SF=0
333 { "jp", OP_JP, OPC_JCC, 1, 1 }, // 7a PF=1
334 { "jpe", OP_JP, OPC_JCC, 1, 1 }, // 7a
335 { "jnp", OP_JNP, OPC_JCC, 1, 1 }, // 7b PF=0
336 { "jpo", OP_JNP, OPC_JCC, 1, 1 }, // 7b
337 { "jl", OP_JL, OPC_JCC, 1, 1 }, // 7c SF!=OF
338 { "jnge", OP_JL, OPC_JCC, 1, 1 }, // 7c
339 { "jge", OP_JGE, OPC_JCC, 1, 1 }, // 7d SF=OF
340 { "jnl", OP_JGE, OPC_JCC, 1, 1 }, // 7d
341 { "jle", OP_JLE, OPC_JCC, 1, 1 }, // 7e ZF=1 || SF!=OF
342 { "jng", OP_JLE, OPC_JCC, 1, 1 }, // 7e
343 { "jg", OP_JG, OPC_JCC, 1, 1 }, // 7f ZF=0 && SF=OF
344 { "jnle", OP_JG, OPC_JCC, 1, 1 }, // 7f
347 static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
353 for (i = 0; i < ARRAY_SIZE(op_table); i++) {
354 if (!IS(words[0], op_table[i].name))
359 for (opr = 0; opr < op_table[i].minopr; opr++) {
360 w = parse_operand(&op->operand[opr], &op->regmask,
361 words, wordc, w, op_table[i].cls);
364 for (; w < wordc && opr < op_table[i].maxopr; opr++) {
365 w = parse_operand(&op->operand[opr], &op->regmask,
366 words, wordc, w, op_table[i].cls);
372 aerr("unhandled op: '%s'\n", words[0]);
376 aerr("parse_op %s incomplete: %d/%d\n",
379 op->cls = op_table[i].cls;
380 op->op = op_table[i].op;
381 op->operand_cnt = opr;
385 static const char *opr_name(struct parsed_op *po, int opr_num)
387 if (opr_num >= po->operand_cnt)
388 ferr(po, "opr OOR: %d/%d\n", opr_num, po->operand_cnt);
389 return po->operand[opr_num].name;
392 static unsigned int opr_const(struct parsed_op *po, int opr_num)
394 if (opr_num >= po->operand_cnt)
395 ferr(po, "opr OOR: %d/%d\n", opr_num, po->operand_cnt);
396 if (po->operand[opr_num].type != OPT_CONST)
397 ferr(po, "opr %d: const expected\n", opr_num);
398 return po->operand[opr_num].val;
401 static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
403 if ((unsigned int)popr->reg >= MAX_REGS)
404 ferr(po, "invalid reg: %d\n", popr->reg);
405 return regs_r32[popr->reg];
408 static void bg_frame_access(struct parsed_op *po, char *buf,
409 size_t buf_size, const char *bp_arg, int is_src)
411 struct parsed_equ *eq;
414 snprintf(g_comment, sizeof(g_comment), "%s", bp_arg);
416 for (i = 0; i < g_eqcnt; i++)
417 if (IS(g_eqs[i].name, bp_arg))
420 ferr(po, "unresolved bp_arg: '%s'\n", bp_arg);
423 if (eq->offset >= 0) {
424 arg_i = eq->offset / 4 - 2;
425 if (arg_i < 0 || arg_i >= g_func_pp.argc_stack)
426 ferr(po, "offset %d doesn't map to any arg\n", eq->offset);
428 for (i = arg_s = 0; i < g_func_pp.argc; i++) {
429 if (g_func_pp.arg[i].reg != NULL)
435 if (i == g_func_pp.argc)
436 ferr(po, "arg %d not in prototype?\n", arg_i);
437 snprintf(buf, buf_size, "%sa%d", is_src ? "(u32)" : "", i + 1);
441 ferr(po, "bp_stack access after it was not detected\n");
446 static char *out_src_opr(char *buf, size_t buf_size,
447 struct parsed_op *po, struct parsed_opr *popr)
449 switch (popr->type) {
451 switch (popr->lmod) {
453 snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
456 ferr(po, "invalid src lmod: %d\n", popr->lmod);
460 if (g_bp_frame && !strncmp(popr->name, "ebp+", 4)) {
461 bg_frame_access(po, buf, buf_size, popr->name + 4, 1);
464 ferr(po, "unhandled OPT_REGMEM variation\n");
467 snprintf(buf, buf_size, "%s", popr->name);
470 snprintf(buf, buf_size, popr->val < 10 ? "%u" : "0x%02x", popr->val);
473 ferr(po, "invalid src type: %d\n", popr->type);
479 static char *out_dst_opr(char *buf, size_t buf_size,
480 struct parsed_op *po, struct parsed_opr *popr)
482 switch (popr->type) {
484 switch (popr->lmod) {
486 snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
489 ferr(po, "invalid dst lmod: %d\n", popr->lmod);
493 ferr(po, "invalid dst type: %d\n", popr->type);
499 static void split_cond(struct parsed_op *po, enum op_op *op, int *is_neg)
538 ferr(po, "split_cond: bad op %d\n", *op);
543 static void out_test_for_cc(char *buf, size_t buf_size,
544 struct parsed_op *po, enum opr_lenmod lmod, const char *expr)
546 enum op_op op = po->op;
549 split_cond(po, &op, &is_neg);
554 snprintf(buf, buf_size, "(%s %s 0)", expr, is_neg ? "!=" : "==");
557 ferr(po, "%s: unhandled lmod for JZ: %d\n", __func__, lmod);
561 ferr(po, "%s: unhandled op: %d\n", __func__, op);
565 static void propagete_lmod(struct parsed_op *po, struct parsed_opr *popr1,
566 struct parsed_opr *popr2)
568 if (popr1->lmod == OPLM_UNSPEC && popr2->lmod == OPLM_UNSPEC)
569 ferr(po, "missing lmod for both operands\n");
571 if (popr1->lmod == OPLM_UNSPEC)
572 popr1->lmod = popr2->lmod;
573 else if (popr2->lmod == OPLM_UNSPEC)
574 popr2->lmod = popr1->lmod;
575 else if (popr1->lmod != popr2->lmod)
576 ferr(po, "conflicting lmods: %d vs %d\n", popr1->lmod, popr2->lmod);
579 static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
581 struct parsed_op *delayed_op = NULL, *tmp_op;
582 char buf1[256], buf2[256], buf3[256];
583 struct parsed_proto *pp;
594 g_bp_frame = g_bp_stack = 0;
596 ret = proto_parse(fhdr, funcn, &g_func_pp);
598 ferr(ops, "proto_parse failed for '%s'\n", funcn);
600 fprintf(fout, "%s %s(", g_func_pp.ret_type, funcn);
601 for (i = 0; i < g_func_pp.argc; i++) {
604 fprintf(fout, "%s a%d", g_func_pp.arg[i].type, i + 1);
606 fprintf(fout, ")\n{\n");
609 // - handle ebp frame, remove ops related to it
610 if (ops[0].op == OP_PUSH && IS(opr_name(&ops[0], 0), "ebp")
611 && ops[1].op == OP_MOV
612 && IS(opr_name(&ops[1], 0), "ebp")
613 && IS(opr_name(&ops[1], 1), "esp"))
616 ops[0].cls = OPC_RMD;
617 ops[1].cls = OPC_RMD;
619 if (ops[2].op == OP_SUB && IS(opr_name(&ops[2], 0), "esp")) {
620 g_bp_stack = opr_const(&ops[2], 1);
621 ops[2].cls = OPC_RMD;
626 for (; i < opcnt; i++)
627 if (ops[i].op == OP_RET)
629 if (ops[i - 1].op != OP_POP || !IS(opr_name(&ops[i - 1], 0), "ebp"))
630 ferr(&ops[i - 1], "'pop ebp' expected\n");
631 ops[i - 1].cls = OPC_RMD;
633 if (g_bp_stack != 0) {
634 if (ops[i - 2].op != OP_MOV
635 || !IS(opr_name(&ops[i - 2], 0), "esp")
636 || !IS(opr_name(&ops[i - 2], 1), "ebp"))
638 ferr(&ops[i - 2], "esp restore expected\n");
640 ops[i - 2].cls = OPC_RMD;
647 // - scan for all used registers
649 for (i = 0; i < opcnt; i++) {
650 if (ops[i].cls == OPC_RMD)
652 regmask |= ops[i].regmask;
654 if (ops[i].op == OP_CALL) {
655 pp = malloc(sizeof(*pp));
656 my_assert_not(pp, NULL);
657 tmpname = opr_name(&ops[i], 0);
658 ret = proto_parse(fhdr, tmpname, pp);
660 ferr(&ops[i], "proto_parse failed for '%s'\n", tmpname);
662 for (arg = 0; arg < pp->argc; arg++)
663 if (pp->arg[arg].reg == NULL)
666 for (j = i - 1; j >= 0 && arg < pp->argc; j--) {
667 if (ops[j].cls == OPC_RMD)
669 if (ops[j].op != OP_PUSH)
672 pp->arg[arg].datap = &ops[j];
673 ops[j].cls = OPC_RMD;
674 for (arg++; arg < pp->argc; arg++)
675 if (pp->arg[arg].reg == NULL)
679 ferr(&ops[i], "arg collect failed for '%s'\n", tmpname);
684 // instantiate arg-registers
685 for (i = 0; i < g_func_pp.argc; i++) {
686 if (g_func_pp.arg[i].reg != NULL) {
687 reg = char_array_i(regs_r32,
688 ARRAY_SIZE(regs_r32), g_func_pp.arg[i].reg);
690 ferr(ops, "arg '%s' is not a reg?\n", g_func_pp.arg[i].reg);
692 regmask_arg |= 1 << reg;
693 fprintf(fout, " u32 %s = (u32)a%d;\n",
694 g_func_pp.arg[i].reg, i);
699 // instantiate other regs - special case for eax
700 if (!((regmask | regmask_arg) & 1) && !IS(g_func_pp.ret_type, "void")) {
701 fprintf(fout, " u32 eax = 0;\n");
705 regmask &= ~regmask_arg;
707 regmask &= ~(1 << xBP);
709 for (reg = 0; reg < 8; reg++) {
710 if (regmask & (1 << reg)) {
711 fprintf(fout, " u32 %s;\n", regs_r32[reg]);
721 for (i = 0; i < opcnt; i++) {
722 if (g_labels[i][0] != 0)
723 fprintf(fout, "\n%s:\n", g_labels[i]);
725 if (ops[i].cls == OPC_RMD)
730 #define internal_error() \
731 ferr(&ops[i], "%s:%d: ICE\n", __FILE__, __LINE__)
732 #define assert_operand_cnt(n_) \
733 if (ops[i].operand_cnt != n_) \
734 ferr(&ops[i], "operand_cnt is %d/%d\n", ops[i].operand_cnt, n_)
737 if (ops[i].cls == OPC_JCC || ops[i].cls == OPC_SCC) {
738 if (delayed_op == NULL)
739 ferr(&ops[i], "no delayed_op before cond op\n");
740 if (delayed_op->op == OP_TEST) {
741 if (IS(opr_name(delayed_op, 0), opr_name(delayed_op, 1))) {
742 out_dst_opr(buf3, sizeof(buf3), delayed_op,
743 &delayed_op->operand[0]);
746 out_dst_opr(buf1, sizeof(buf1), delayed_op,
747 &delayed_op->operand[0]);
748 out_src_opr(buf2, sizeof(buf2), delayed_op,
749 &delayed_op->operand[1]);
750 snprintf(buf3, sizeof(buf3), "(%s & %s)", buf1, buf2);
752 out_test_for_cc(buf1, sizeof(buf1), &ops[i],
753 delayed_op->operand[0].lmod, buf3);
754 if (ops[i].cls == OPC_JCC)
755 fprintf(fout, " if %s\n", buf1);
757 out_dst_opr(buf2, sizeof(buf2), &ops[i], &ops[i].operand[0]);
758 fprintf(fout, " %s = %s;", buf2, buf1);
762 ferr(&ops[i], "TODO\n");
769 assert_operand_cnt(2);
770 propagete_lmod(&ops[i], &ops[i].operand[0], &ops[i].operand[1]);
771 fprintf(fout, " %s = %s;",
772 out_dst_opr(buf1, sizeof(buf1), &ops[i], &ops[i].operand[0]),
773 out_src_opr(buf2, sizeof(buf2), &ops[i], &ops[i].operand[1]));
778 propagete_lmod(&ops[i], &ops[i].operand[0], &ops[i].operand[1]);
779 delayed_op = &ops[i];
783 // note: we reuse OP_Jcc for SETcc, only cls differs
784 case OP_JO ... OP_JG:
785 if (ops[i].cls == OPC_JCC)
786 fprintf(fout, " goto %s;", ops[i].operand[0].name);
792 ferr(&ops[i], "NULL pp\n");
795 if (!IS(pp->ret_type, "void")) {
796 fprintf(fout, "eax = ");
797 if (strchr(pp->ret_type, '*'))
798 fprintf(fout, "(u32)");
800 fprintf(fout, "%s(", opr_name(&ops[i], 0));
801 for (arg = 0; arg < pp->argc; arg++) {
804 if (pp->arg[arg].reg != NULL) {
805 fprintf(fout, "%s", pp->arg[i].reg);
810 tmp_op = pp->arg[arg].datap;
812 ferr(&ops[i], "parsed_op missing for arg%d\n", arg);
814 out_src_opr(buf1, sizeof(buf1), tmp_op, &tmp_op->operand[0]));
820 if (IS(g_func_pp.ret_type, "void"))
821 fprintf(fout, " return;");
823 fprintf(fout, " return eax;");
827 ferr(&ops[i], "push encountered\n");
831 ferr(&ops[i], "pop encountered\n");
836 ferr(&ops[i], "unhandled op type %d, cls %d\n",
837 ops[i].op, ops[i].cls);
841 if (g_comment[0] != 0) {
842 fprintf(fout, " // %s", g_comment);
850 fprintf(fout, "}\n\n");
853 for (i = 0; i < opcnt; i++) {
854 if (ops[i].op == OP_CALL) {
862 proto_release(&g_func_pp);
865 int main(int argc, char *argv[])
867 FILE *fout, *fasm, *fhdr;
878 printf("usage:\n%s <.c> <.asm> <hdrf>\n",
884 fhdr = fopen(hdrfn, "r");
885 my_assert_not(fhdr, NULL);
888 fasm = fopen(asmfn, "r");
889 my_assert_not(fasm, NULL);
891 fout = fopen(argv[1], "w");
892 my_assert_not(fout, NULL);
895 g_eqs = malloc(eq_alloc * sizeof(g_eqs[0]));
896 my_assert_not(g_eqs, NULL);
898 while (fgets(line, sizeof(line), fasm))
903 if (*p == 0 || *p == ';')
906 memset(words, 0, sizeof(words));
907 for (wordc = 0; wordc < 16; wordc++) {
908 p = sskip(next_word(words[wordc], sizeof(words[0]), p));
909 if (*p == 0 || *p == ';') {
917 awarn("wordc == 0?\n");
921 // don't care about this:
922 if (words[0][0] == '.'
923 || IS(words[0], "include")
924 || IS(words[0], "assume") || IS(words[1], "segment")
925 || IS(words[0], "align"))
930 if (IS(words[1], "proc")) {
932 aerr("proc '%s' while in_func '%s'?\n",
934 strcpy(g_func, words[0]);
939 if (IS(words[1], "endp")) {
941 aerr("endp '%s' while not in_func?\n", words[0]);
942 if (!IS(g_func, words[0]))
943 aerr("endp '%s' while in_func '%s'?\n",
945 gen_func(fout, fhdr, g_func, pi);
949 memset(&ops, 0, pi * sizeof(ops[0]));
950 memset(g_labels, 0, pi * sizeof(g_labels[0]));
958 if (IS(words[1], "=")) {
960 aerr("unhandled equ, wc=%d\n", wordc);
961 if (g_eqcnt >= eq_alloc) {
963 g_eqs = realloc(g_eqs, eq_alloc * sizeof(g_eqs[0]));
964 my_assert_not(g_eqs, NULL);
967 len = strlen(words[0]);
968 if (len > sizeof(g_eqs[0].name) - 1)
969 aerr("equ name too long: %d\n", len);
970 strcpy(g_eqs[g_eqcnt].name, words[0]);
972 if (!IS(words[3], "ptr"))
973 aerr("unhandled equ\n");
974 if (IS(words[2], "dword"))
975 g_eqs[g_eqcnt].lmod = OPLM_DWORD;
976 else if (IS(words[2], "word"))
977 g_eqs[g_eqcnt].lmod = OPLM_WORD;
978 else if (IS(words[2], "byte"))
979 g_eqs[g_eqcnt].lmod = OPLM_BYTE;
981 aerr("bad lmod: '%s'\n", words[2]);
983 g_eqs[g_eqcnt].offset = parse_number(words[4]);
988 if (pi >= ARRAY_SIZE(ops))
989 aerr("too many ops\n");
991 p = strchr(words[0], ':');
994 if (len > sizeof(g_labels[0]) - 1)
995 aerr("label too long: %d\n", len);
996 if (g_labels[pi][0] != 0)
997 aerr("dupe label?\n");
998 memcpy(g_labels[pi], words[0], len);
999 g_labels[pi][len] = 0;
1003 parse_op(&ops[pi], words, wordc);
1016 // vim:ts=2:shiftwidth=2:expandtab