home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / MAWK113.ZIP / mawk113 / da.c < prev    next >
C/C++ Source or Header  |  1992-07-25  |  9KB  |  368 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 5.2  1992/07/25  21:35:25  brennan
  16.  * patch2
  17.  * fixed small typo on da of _PRE_DEC
  18.  *
  19.  * Revision 5.1  1991/12/05  07:55:45  brennan
  20.  * 1.1 pre-release
  21.  *
  22. */
  23.  
  24.  
  25. /*  da.c  */
  26. /*  disassemble code */ 
  27.  
  28. /* This and new posix stuff won't fit in small model DOS  */
  29.  
  30.  
  31.  
  32. #include  "mawk.h"
  33.  
  34. #if ! SM_DOS
  35.  
  36. #include  "code.h"
  37. #include  "bi_funct.h"
  38. #include  "repl.h"
  39. #include  "field.h"
  40.  
  41. static char *PROTO(find_bi_name, (PF_CP) ) ;
  42.  
  43. static struct sc {
  44. char op ; char *name ;
  45. } simple_code[] = {
  46. _STOP, "stop",
  47. FE_PUSHA, "fe_pusha",
  48. FE_PUSHI, "fe_pushi",
  49. A_TEST, "a_test",
  50. A_DEL , "a_del",
  51. A_CAT, "a_cat",
  52. _POP, "pop",
  53. _ADD, "add",
  54. _SUB, "sub",
  55. _MUL, "mul",
  56. _DIV, "div",
  57. _MOD, "mod",
  58. _POW, "pow",
  59. _NOT, "not",
  60. _UMINUS, "uminus",
  61. _UPLUS, "uplus",
  62. _DUP, "dup",
  63. _TEST, "test",
  64. _CAT, "cat",
  65. _ASSIGN, "assign",
  66. _ADD_ASG, "add_asg",
  67. _SUB_ASG, "sub_asg",
  68. _MUL_ASG, "mul_asg",
  69. _DIV_ASG, "div_asg",
  70. _MOD_ASG, "mod_asg",
  71. _POW_ASG, "pow_asg",
  72. NF_PUSHI, "nf_pushi",
  73. F_ASSIGN, "f_assign",
  74. F_ADD_ASG, "f_add_asg",
  75. F_SUB_ASG, "f_sub_asg",
  76. F_MUL_ASG, "f_mul_asg",
  77. F_DIV_ASG, "f_div_asg",
  78. F_MOD_ASG, "f_mod_asg",
  79. F_POW_ASG, "f_pow_asg",
  80. _POST_INC, "post_inc",
  81. _POST_DEC, "post_dec",
  82. _PRE_INC, "pre_inc",
  83. _PRE_DEC, "pre_dec",
  84. F_POST_INC, "f_post_inc",
  85. F_POST_DEC, "f_post_dec",
  86. F_PRE_INC, "f_pre_inc",
  87. F_PRE_DEC, "f_pre_dec",
  88. _EQ, "eq",
  89. _NEQ, "neq",
  90. _LT, "lt",
  91. _LTE, "lte",
  92. _GT, "gt",
  93. _GTE, "gte",
  94. _MATCH2, "match2",
  95. _EXIT, "exit",
  96. _EXIT0, "exit0",
  97. _NEXT, "next",
  98. _RET, "ret",
  99. _RET0, "ret0",
  100. _OMAIN, "omain",
  101. _JMAIN, "jmain",
  102. OL_GL, "ol_gl",
  103. OL_GL_NR, "ol_gl_nr",
  104. _HALT , (char *) 0 } ;
  105.  
  106. void  da(start, fp)
  107.   INST *start ;
  108.   FILE *fp ;
  109. { CELL *cp ;
  110.   register INST *p = start ;
  111.   char *name ;
  112.  
  113.   while ( p->op != _HALT )
  114.   { /* print the relative code address (label) */
  115.     fprintf(fp,"%03d ", p - start) ;
  116.  
  117.     switch( p++->op )
  118.     {
  119.  
  120.       case _PUSHC :
  121.             cp = (CELL *) p++->ptr ;
  122.             switch( cp->type )
  123.             { 
  124.               case C_RE :
  125.                   fprintf(fp,"pushc\t0x%lx\t/%s/\n" , (long) cp->ptr ,
  126.                     re_uncompile(cp->ptr) ) ;
  127.                   break ;
  128.  
  129.               case C_SPACE : 
  130.                   fprintf(fp, "pushc\tspace split\n") ;
  131.                   break ;
  132.  
  133.               case C_SNULL : 
  134.                   fprintf(fp, "pushc\tnull split\n") ;
  135.                   break ;
  136.               case C_REPL  :
  137.                   fprintf(fp, "pushc\trepl\t%s\n" ,
  138.                         repl_uncompile(cp) ) ;
  139.                   break ;
  140.               case C_REPLV :
  141.                   fprintf(fp, "pushc\treplv\t%s\n" ,
  142.                         repl_uncompile(cp) ) ;
  143.                   break ;
  144.                   
  145.               default :
  146.                   fprintf(fp,"pushc\tWEIRD\n") ;  ;
  147.                   break ;
  148.             }
  149.             break ;
  150.  
  151.       case  _PUSHD :
  152.                   fprintf(fp,"pushd\t%.6g\n" ,  *(double*)p++->ptr) ;
  153.                   break ;
  154.       case  _PUSHS :
  155.                 { STRING *sval = (STRING *) p++->ptr ;
  156.                   fprintf(fp,"pushs\t\"%s\"\n" , sval->str) ;
  157.                   break ;
  158.                 }
  159.  
  160.       case  _MATCH0 :
  161.       case  _MATCH1 :
  162.             fprintf(fp, "match%d\t0x%lx\t/%s/\n" , 
  163.                 p[-1].op == _MATCH1, (long) p->ptr,
  164.                 re_uncompile(p->ptr) ) ;
  165.             p++ ;
  166.             break ;
  167.  
  168.       case _PUSHA :
  169.             fprintf(fp,"pusha\t%s\n", 
  170.                   reverse_find(ST_VAR, & p++ -> ptr)) ;
  171.             break ;
  172.  
  173.       case _PUSHI :
  174.             cp = (CELL *) p++ -> ptr ;
  175.             if ( cp == field )
  176.                 fprintf(fp, "pushi\t$0\n") ;
  177.             else
  178.             if ( cp == &fs_shadow )
  179.                 fprintf(fp, "pushi\t@fs_shadow\n") ;
  180.             else 
  181.             { 
  182.                if ( 
  183. #if  LM_DOS
  184.         SAMESEG(cp,field) &&
  185. #endif
  186.            cp > NF && cp <= LAST_PFIELD )
  187.                   name = reverse_find(ST_FIELD, &cp) ;
  188.                else
  189.                   name = reverse_find(ST_VAR, &cp) ;
  190.  
  191.                fprintf(fp, "pushi\t%s\n", name) ;
  192.             }
  193.             break ;
  194.  
  195.       case  L_PUSHA :
  196.             fprintf( fp, "l_pusha\t%d\n", p++->op) ;
  197.             break ;
  198.  
  199.       case  L_PUSHI :
  200.             fprintf( fp, "l_pushi\t%d\n", p++->op) ;
  201.             break ;
  202.  
  203.       case  LAE_PUSHI :
  204.             fprintf( fp, "lae_pushi\t%d\n", p++->op) ;
  205.             break ;
  206.  
  207.       case  LAE_PUSHA :
  208.             fprintf( fp, "lae_pusha\t%d\n", p++->op) ;
  209.             break ;
  210.  
  211.       case  LA_PUSHA :
  212.             fprintf( fp, "la_pusha\t%d\n", p++->op) ;
  213.             break ;
  214.  
  215.       case F_PUSHA :
  216.             cp = (CELL *) p++ -> ptr ;
  217.             if (
  218. #if  LM_DOS
  219.         SAMESEG(cp,field) &&
  220. #endif
  221.             cp >= NF && cp <= LAST_PFIELD )
  222.                  fprintf(fp, "f_pusha\t%s\n", 
  223.                         reverse_find(ST_FIELD, &cp)) ;
  224.             else
  225.                 fprintf(fp, "f_pusha\t$%d\n", 
  226.                     field_addr_to_index(cp)) ;
  227.             break ;
  228.  
  229.       case F_PUSHI :
  230.             p++ ;
  231.             fprintf(fp, "f_pushi\t$%d\n", p++ -> op) ;
  232.             break ;
  233.  
  234.       case AE_PUSHA :
  235.             fprintf(fp,"ae_pusha\t%s\n" , 
  236.                      reverse_find(ST_ARRAY, & p++->ptr) ) ;
  237.             break ;
  238.  
  239.       case AE_PUSHI :
  240.             fprintf(fp,"ae_pushi\t%s\n" , 
  241.                 reverse_find(ST_ARRAY, & p++->ptr)) ;
  242.             break ;
  243.  
  244.       case A_PUSHA :
  245.             fprintf(fp,"a_pusha\t%s\n" , 
  246.                 reverse_find(ST_ARRAY, & p++->ptr)) ;
  247.             break ;
  248.  
  249.       case  _PUSHINT :
  250.             fprintf(fp,"pushint\t%d\n" , p++ -> op ) ;
  251.             break ;
  252.  
  253.       case  _BUILTIN  :
  254.             fprintf(fp,"%s\n" , 
  255.                     find_bi_name( (PF_CP) p++ -> ptr ) ) ;
  256.             break ;
  257.  
  258.       case  _PRINT :
  259.             fprintf(fp,"%s\n", 
  260.             (PF_CP) p++ -> ptr == bi_printf
  261.                 ? "printf" : "print") ;
  262.             break ;
  263.       
  264.       case  _JMP :
  265.       case  _JNZ :
  266.       case  _JZ  :
  267.           { int j = (p-1)->op ;
  268.             char *s = j == _JMP ? "jmp" : 
  269.                       j == _JNZ ? "jnz" : "jz" ;
  270.  
  271.             fprintf(fp,"%s\t\t%03d\n" , s ,
  272.               (p - start) + p->op  ) ;
  273.             p++ ;
  274.             break ;
  275.           }
  276.  
  277.       case  SET_ALOOP :
  278.         fprintf(fp, "s_aloop\t%03d\n", p + p->op - start ) ;
  279.         p++ ;
  280.         break ;
  281.     
  282.       case  ALOOP :
  283.             fprintf(fp,"aloop\t%03d\n", p-start+p->op) ;
  284.             p += 2 ;
  285.             break ;
  286.  
  287.       case  _CALL :
  288.             fprintf(fp, "call\t%s\t%d\n", 
  289.                 ((FBLOCK*)p->ptr)->name , p[1].op) ;
  290.             p += 2 ;
  291.             break ;
  292.  
  293.       case  _RANGE :
  294.             fprintf(fp, "range\t%03d %03d %03d\n",
  295.               /* label for pat2, action, follow */
  296.               p - start + p[1].op ,
  297.               p - start + p[2].op ,
  298.               p - start + p[3].op ) ;
  299.             p += 4 ; 
  300.             break ;
  301.       default :
  302.             { 
  303.               struct sc *q = simple_code ;
  304.           int k = (p-1)->op ;
  305.  
  306.               while ( q->op != _HALT && q->op != k )  q++ ;
  307.  
  308.               fprintf(fp, "%s\n",
  309.                 q->op != _HALT  ? q->name : "bad instruction") ;
  310.             }
  311.             break ;
  312.     }
  313.   }
  314. }
  315.  
  316. static struct {
  317. PF_CP action ;
  318. char *name ;
  319. } special_cases[] = {
  320. bi_split, "split",
  321. bi_match, "match",
  322. bi_getline,"getline",
  323. bi_sub, "sub",
  324. bi_gsub , "gsub",
  325. (PF_CP) 0, (char *) 0 } ;
  326.  
  327. static char *find_bi_name( p )
  328.   PF_CP p ;
  329. { BI_REC *q ;
  330.   int i ;
  331.  
  332.   for( q = bi_funct ; q->name ; q++ )
  333.     if ( q->fp == p )  /* found */
  334.         return q->name ;
  335.   /* next check some special cases */
  336.   for( i = 0 ; special_cases[i].action ; i++)
  337.     if ( special_cases[i].action == p )
  338.         return  special_cases[i].name ;
  339.  
  340.   return  "unknown builtin" ;
  341. }
  342.  
  343. static struct fdump {
  344. struct fdump *link ;
  345. FBLOCK  *fbp ;
  346. }  *fdump_list ;  /* linked list of all user functions */
  347.  
  348. void add_to_fdump_list( fbp )
  349.   FBLOCK *fbp ;
  350. { struct fdump *p = (struct fdump *)zmalloc(sizeof(struct fdump)) ;
  351.   p->fbp = fbp ;
  352.   p->link = fdump_list ;  fdump_list = p ;
  353. }
  354.  
  355. void  fdump()
  356. {
  357.   register struct fdump *p, *q = fdump_list ;
  358.  
  359.   while ( p = q )
  360.   { q = p->link ;
  361.     fprintf(stderr, "function %s\n" , p->fbp->name) ;
  362.     da(p->fbp->code, stderr) ;
  363.     zfree(p, sizeof(struct fdump)) ;
  364.   }
  365. }
  366.  
  367. #endif  /* SM_DOS */
  368.