home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 11 / AUCD11B.iso / LANGUAGES / WraithSet / AwkStuff / MawkSrc / c / da < prev    next >
Text File  |  1995-06-18  |  8KB  |  432 lines
  1.  
  2. /********************************************
  3. da.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /* $Log: da.c,v $
  15.  * Revision 1.6  1995/06/18  19:19:59  mike
  16.  * remove use of comma operator that broke some sysVr3 compilers
  17.  *
  18.  * Revision 1.5  1994/12/13  00:12:08  mike
  19.  * delete A statement to delete all of A at once
  20.  *
  21.  * Revision 1.4  1994/10/08  19:15:32  mike
  22.  * remove SM_DOS
  23.  *
  24.  * Revision 1.3  1993/12/01  14:25:10  mike
  25.  * reentrant array loops
  26.  *
  27.  * Revision 1.2  1993/07/22  00:04:05  mike
  28.  * new op code _LJZ _LJNZ
  29.  *
  30.  * Revision 1.1.1.1  1993/07/03     18:58:10  mike
  31.  * move source to cvs
  32.  *
  33.  * Revision 5.4     1993/01/09  19:05:48  mike
  34.  * dump code to stdout and exit(0)
  35.  *
  36.  * Revision 5.3     1993/01/07  02:50:33  mike
  37.  * relative vs absolute code
  38.  *
  39.  * Revision 5.2     1992/07/25  21:35:25  brennan
  40.  * patch2
  41.  * fixed small typo on da of _PRE_DEC
  42.  *
  43.  * Revision 5.1     1991/12/05  07:55:45  brennan
  44.  * 1.1 pre-release
  45.  *
  46. */
  47.  
  48.  
  49. /*  da.c  */
  50. /*  disassemble code */
  51.  
  52.  
  53.  
  54. #include  "mawk.h"
  55.  
  56.  
  57. #include  "code.h"
  58. #include  "bi_funct.h"
  59. #include  "repl.h"
  60. #include  "field.h"
  61.  
  62. static char *PROTO(find_bi_name, (PF_CP)) ;
  63.  
  64. static struct sc
  65. {
  66.    char op ; 
  67.    char *name ;
  68. } simple_code[] =
  69.  
  70. {
  71.    _STOP, "stop",
  72.    FE_PUSHA, "fe_pusha",
  73.    FE_PUSHI, "fe_pushi",
  74.    A_TEST, "a_test",
  75.    A_DEL, "a_del",
  76.    DEL_A, "del_a",
  77.    POP_AL, "pop_al",
  78.    _POP, "pop",
  79.    _ADD, "add",
  80.    _SUB, "sub",
  81.    _MUL, "mul",
  82.    _DIV, "div",
  83.    _MOD, "mod",
  84.    _POW, "pow",
  85.    _NOT, "not",
  86.    _UMINUS, "uminus",
  87.    _UPLUS, "uplus",
  88.    _TEST, "test",
  89.    _CAT, "cat",
  90.    _ASSIGN, "assign",
  91.    _ADD_ASG, "add_asg",
  92.    _SUB_ASG, "sub_asg",
  93.    _MUL_ASG, "mul_asg",
  94.    _DIV_ASG, "div_asg",
  95.    _MOD_ASG, "mod_asg",
  96.    _POW_ASG, "pow_asg",
  97.    NF_PUSHI, "nf_pushi",
  98.    F_ASSIGN, "f_assign",
  99.    F_ADD_ASG, "f_add_asg",
  100.    F_SUB_ASG, "f_sub_asg",
  101.    F_MUL_ASG, "f_mul_asg",
  102.    F_DIV_ASG, "f_div_asg",
  103.    F_MOD_ASG, "f_mod_asg",
  104.    F_POW_ASG, "f_pow_asg",
  105.    _POST_INC, "post_inc",
  106.    _POST_DEC, "post_dec",
  107.    _PRE_INC, "pre_inc",
  108.    _PRE_DEC, "pre_dec",
  109.    F_POST_INC, "f_post_inc",
  110.    F_POST_DEC, "f_post_dec",
  111.    F_PRE_INC, "f_pre_inc",
  112.    F_PRE_DEC, "f_pre_dec",
  113.    _EQ, "eq",
  114.    _NEQ, "neq",
  115.    _LT, "lt",
  116.    _LTE, "lte",
  117.    _GT, "gt",
  118.    _GTE, "gte",
  119.    _MATCH2, "match2",
  120.    _EXIT, "exit",
  121.    _EXIT0, "exit0",
  122.    _NEXT, "next",
  123.    _RET, "ret",
  124.    _RET0, "ret0",
  125.    _OMAIN, "omain",
  126.    _JMAIN, "jmain",
  127.    OL_GL, "ol_gl",
  128.    OL_GL_NR, "ol_gl_nr",
  129.    _HALT, (char *) 0
  130. } ;
  131.  
  132. static char *jfmt = "%s%s%03d\n" ; 
  133.    /* format to print jumps */
  134. static char *tab2 = "\t\t" ;
  135.  
  136. void
  137. da(start, fp)
  138.    INST *start ;
  139.    FILE *fp ;
  140. {
  141.    CELL *cp ;
  142.    register INST *p = start ;
  143.    char *name ;
  144.  
  145.    while (p->op != _HALT)
  146.    {
  147.       /* print the relative code address (label) */
  148.       fprintf(fp, "%03d ", p - start) ;
  149.  
  150.       switch (p++->op)
  151.       {
  152.  
  153.      case _PUSHC:
  154.         cp = (CELL *) p++->ptr ;
  155.         switch (cp->type)
  156.         {
  157.            case C_RE:
  158.           fprintf(fp, "pushc\t0x%lx\t/%s/\n", (long) cp->ptr,
  159.               re_uncompile(cp->ptr)) ;
  160.           break ;
  161.  
  162.            case C_SPACE:
  163.           fprintf(fp, "pushc\tspace split\n") ;
  164.           break ;
  165.  
  166.            case C_SNULL:
  167.           fprintf(fp, "pushc\tnull split\n") ;
  168.           break ;
  169.            case C_REPL:
  170.           fprintf(fp, "pushc\trepl\t%s\n",
  171.               repl_uncompile(cp)) ;
  172.           break ;
  173.            case C_REPLV:
  174.           fprintf(fp, "pushc\treplv\t%s\n",
  175.               repl_uncompile(cp)) ;
  176.           break ;
  177.  
  178.            default:
  179.           fprintf(fp,"pushc\tWEIRD\n") ;  ;
  180.           break ;
  181.         }
  182.         break ;
  183.  
  184.      case _PUSHD:
  185.         fprintf(fp, "pushd\t%.6g\n", *(double *) p++->ptr) ;
  186.         break ;
  187.      case _PUSHS:
  188.         {
  189.            STRING *sval = (STRING *) p++->ptr ;
  190.            fprintf(fp, "pushs\t\"%s\"\n", sval->str) ;
  191.            break ;
  192.         }
  193.  
  194.      case _MATCH0:
  195.      case _MATCH1:
  196.         fprintf(fp, "match%d\t0x%lx\t/%s/\n",
  197.             p[-1].op == _MATCH1, (long) p->ptr,
  198.             re_uncompile(p->ptr)) ;
  199.         p++ ;
  200.         break ;
  201.  
  202.      case _PUSHA:
  203.         fprintf(fp, "pusha\t%s\n",
  204.             reverse_find(ST_VAR, &p++->ptr)) ;
  205.         break ;
  206.  
  207.      case _PUSHI:
  208.         cp = (CELL *) p++->ptr ;
  209.         if (cp == field)  fprintf(fp, "pushi\t$0\n") ;
  210.         else if (cp == &fs_shadow)
  211.            fprintf(fp, "pushi\t@fs_shadow\n") ;
  212.         else
  213.         {
  214.            if (
  215. #ifdef  MSDOS
  216.              SAMESEG(cp, field) &&
  217. #endif
  218.              cp > NF && cp <= LAST_PFIELD)
  219.           name = reverse_find(ST_FIELD, &cp) ;
  220.            else  name = reverse_find(ST_VAR, &cp) ;
  221.  
  222.            fprintf(fp, "pushi\t%s\n", name) ;
  223.         }
  224.         break ;
  225.  
  226.      case L_PUSHA:
  227.         fprintf(fp, "l_pusha\t%d\n", p++->op) ;
  228.         break ;
  229.  
  230.      case L_PUSHI:
  231.         fprintf(fp, "l_pushi\t%d\n", p++->op) ;
  232.         break ;
  233.  
  234.      case LAE_PUSHI:
  235.         fprintf(fp, "lae_pushi\t%d\n", p++->op) ;
  236.         break ;
  237.  
  238.      case LAE_PUSHA:
  239.         fprintf(fp, "lae_pusha\t%d\n", p++->op) ;
  240.         break ;
  241.  
  242.      case LA_PUSHA:
  243.         fprintf(fp, "la_pusha\t%d\n", p++->op) ;
  244.         break ;
  245.  
  246.      case F_PUSHA:
  247.         cp = (CELL *) p++->ptr ;
  248.         if (
  249. #ifdef  MSDOS
  250.           SAMESEG(cp, field) &&
  251. #endif
  252.           cp >= NF && cp <= LAST_PFIELD)
  253.            fprintf(fp, "f_pusha\t%s\n",
  254.                reverse_find(ST_FIELD, &cp)) ;
  255.         else  fprintf(fp, "f_pusha\t$%d\n",
  256.                field_addr_to_index(cp)) ;
  257.         break ;
  258.  
  259.      case F_PUSHI:
  260.         p++ ;
  261.         fprintf(fp, "f_pushi\t$%d\n", p++->op) ;
  262.         break ;
  263.  
  264.      case AE_PUSHA:
  265.         fprintf(fp, "ae_pusha\t%s\n",
  266.             reverse_find(ST_ARRAY, &p++->ptr)) ;
  267.         break ;
  268.  
  269.      case AE_PUSHI:
  270.         fprintf(fp, "ae_pushi\t%s\n",
  271.             reverse_find(ST_ARRAY, &p++->ptr)) ;
  272.         break ;
  273.  
  274.      case A_PUSHA:
  275.         fprintf(fp, "a_pusha\t%s\n",
  276.             reverse_find(ST_ARRAY, &p++->ptr)) ;
  277.         break ;
  278.  
  279.      case _PUSHINT:
  280.         fprintf(fp, "pushint\t%d\n", p++->op) ;
  281.         break ;
  282.  
  283.      case _BUILTIN:
  284.         fprintf(fp, "%s\n",
  285.             find_bi_name((PF_CP) p++->ptr)) ;
  286.         break ;
  287.  
  288.      case _PRINT:
  289.         fprintf(fp, "%s\n",
  290.             (PF_CP) p++->ptr == bi_printf
  291.             ? "printf" : "print") ;
  292.         break ;
  293.  
  294.      case _JMP:
  295.         fprintf(fp, jfmt, "jmp", tab2, (p - start) + p->op) ;
  296.         p++ ;
  297.         break ;
  298.  
  299.      case _JNZ:
  300.         fprintf(fp, jfmt, "jnz", tab2, (p - start) + p->op) ;
  301.         p++ ;
  302.         break ;
  303.  
  304.      case _JZ:
  305.         fprintf(fp, jfmt, "jz", tab2, (p - start) + p->op) ;
  306.         p++ ;
  307.         break ;
  308.  
  309.      case _LJZ:
  310.         fprintf(fp, jfmt, "ljz", tab2, (p - start) + p->op) ;
  311.         p++ ;
  312.         break ;
  313.  
  314.      case _LJNZ:
  315.         fprintf(fp, jfmt, "ljnz", tab2+1 , (p - start) + p->op) ;
  316.         p++ ;
  317.         break ;
  318.  
  319.      case SET_ALOOP:
  320.         fprintf(fp, "set_al\t%03d\n", p + p->op - start) ;
  321.         p++ ;
  322.         break ;
  323.  
  324.      case ALOOP:
  325.         fprintf(fp, "aloop\t%03d\n", p - start + p->op) ;
  326.         p++ ;
  327.         break ;
  328.  
  329.      case  A_CAT :
  330.         fprintf(fp,"a_cat\t%d\n", p++->op) ;
  331.         break ;
  332.  
  333.      case _CALL:
  334.         fprintf(fp, "call\t%s\t%d\n",
  335.             ((FBLOCK *) p->ptr)->name, p[1].op) ;
  336.         p += 2 ;
  337.         break ;
  338.  
  339.      case _RANGE:
  340.         fprintf(fp, "range\t%03d %03d %03d\n",
  341.         /* label for pat2, action, follow */
  342.             p - start + p[1].op,
  343.             p - start + p[2].op,
  344.             p - start + p[3].op) ;
  345.         p += 4 ;
  346.         break ;
  347.      default:
  348.         {
  349.            struct sc *q = simple_code ;
  350.            int k = (p - 1)->op ;
  351.  
  352.            while (q->op != _HALT && q->op != k)  q++ ;
  353.  
  354.            fprintf(fp, "%s\n",
  355.                q->op != _HALT ? q->name : "bad instruction") ;
  356.         }
  357.         break ;
  358.       }
  359.    }
  360.    fflush(fp) ;
  361. }
  362.  
  363. static struct
  364. {
  365.    PF_CP action ;
  366.    char *name ;
  367. }
  368. special_cases[] =
  369. {
  370.    bi_split, "split",
  371.    bi_match, "match",
  372.    bi_getline, "getline",
  373.    bi_sub, "sub",
  374.    bi_gsub, "gsub",
  375.    (PF_CP) 0, (char *) 0
  376. } ;
  377.  
  378. static char *
  379. find_bi_name(p)
  380.    PF_CP p ;
  381. {
  382.    BI_REC *q ;
  383.    int i ;
  384.  
  385.    for (q = bi_funct; q->name; q++)
  386.    {
  387.       if (q->fp == p)
  388.       {
  389.      /* found */
  390.      return q->name ;
  391.       }
  392.    }
  393.    /* next check some special cases */
  394.    for (i = 0; special_cases[i].action; i++)
  395.    {
  396.       if (special_cases[i].action == p)     return special_cases[i].name ;
  397.    }
  398.  
  399.    return "unknown builtin" ;
  400. }
  401.  
  402. static struct fdump
  403. {
  404.    struct fdump *link ;
  405.    FBLOCK *fbp ;
  406. } *fdump_list ;             /* linked list of all user functions */
  407.  
  408. void
  409. add_to_fdump_list(fbp)
  410.    FBLOCK *fbp ;
  411. {
  412.    struct fdump *p = ZMALLOC(struct fdump) ;
  413.    p->fbp = fbp ;
  414.    p->link = fdump_list ;  fdump_list = p ;
  415. }
  416.  
  417. void
  418. fdump()
  419. {
  420.    register struct fdump *p, *q = fdump_list ;
  421.  
  422.    while (q)
  423.    {
  424.       p = q ;
  425.       q = p->link ;
  426.       fprintf(stdout, "function %s\n", p->fbp->name) ;
  427.       da(p->fbp->code, stdout) ;
  428.       ZFREE(p) ;
  429.    }
  430. }
  431.  
  432.