home *** CD-ROM | disk | FTP | other *** search
/ AMIGA PD 1 / AMIGA-PD-1.iso / Programme_zum_Heft / Programmieren / Kurztests / ACE / utils / ab2ascii / ab2ascii.c < prev    next >
C/C++ Source or Header  |  1994-10-23  |  13KB  |  909 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <ctype.h>
  4.  
  5. struct symbol
  6. {
  7.     struct symbol *next;
  8.     int id;
  9.     char s[256];
  10. };
  11.  
  12. struct symbol *sym_tab = NULL;
  13.  
  14. struct symbol *read_sym( int len, int id )
  15. {
  16.     struct symbol *sym;
  17.     int i;
  18.  
  19.     if( sym = malloc( sizeof( struct symbol ) ) )
  20.     {
  21.         sym->next = NULL;
  22.         sym->id = id;
  23.         for( i = 0; i < len; i++ )
  24.             sym->s[i] = getchar();
  25.         sym->s[len] = '\0';
  26.     }
  27.     return sym;
  28. }
  29.  
  30. void store_sym( struct symbol *sym )
  31. {
  32.     struct symbol *s = (struct symbol *)&sym_tab;
  33.  
  34.     while( s->next ) s = s->next;
  35.     s->next = sym;
  36. }
  37.  
  38. char *get_sym( int id )
  39. {
  40.     struct symbol *sym;
  41.  
  42.     for( sym = sym_tab; sym; sym = sym->next )
  43.         if( sym->id == id )
  44.             return sym->s;
  45.     return NULL;
  46. }
  47.  
  48. void delete_sym_tab( void )
  49. {
  50.     struct symbol *sym, *next;
  51.  
  52.     for( sym = sym_tab; sym; sym = next )
  53.     {
  54.         next = sym->next;
  55.         free( sym );
  56.     }
  57. }
  58.  
  59. int getword( void )
  60. {
  61.     int hi;
  62.     
  63.     hi = 0x100 * getchar();
  64.     return hi + getchar();
  65. }
  66.  
  67. int getlong( void )
  68. {
  69.     int hi;
  70.  
  71.     hi = 0x10000 * getword();
  72.     return hi + getword();
  73. }
  74.  
  75. int expand( void )
  76. {
  77.     int count = 0, c, id;
  78.     char *s;
  79.     float f;
  80.  
  81.     c = getchar();
  82.     count++;
  83.     switch( c )
  84.     {
  85.     case '"':
  86.         putchar( c );
  87.         for(;;)
  88.         {
  89.             c = getchar();
  90.             count++;
  91.             putchar( c );
  92.             if( c == '"' )
  93.             {
  94.                 char c1;
  95.                 
  96.                 c1 = getchar();
  97.                 if( c1 == '"' )
  98.                 {
  99.                     count++;
  100.                     putchar( c1 );
  101.                 }
  102.                 else
  103.                 {
  104.                     ungetc( c1, stdin );
  105.                     break;
  106.                 }
  107.             }
  108.         }
  109.         break;
  110.     case 0x00:
  111.         putchar( '\n' );
  112.         break;
  113.     case 0x08:
  114.         getchar();
  115.         count++;
  116.         getchar();
  117.         count++;
  118.         getchar();
  119.         count++;
  120.         break;
  121.     case 0xAF:
  122.         printf( "REM" );
  123.         do
  124.         {
  125.             c = getchar();
  126.             count++;
  127.             if( c ) putchar( c );
  128.         } while( c );
  129.         putchar( '\n' );
  130.         break;
  131.     case 0xC0:
  132.         printf( "ELSE IF" );
  133.         break;
  134.     case 0xf1:
  135.         printf( "AND" );
  136.         break;
  137.     case 0x80:
  138.         printf( "ABS" );
  139.         break;
  140.     case 0x81:
  141.         printf( "ASC" );
  142.         break;
  143.     case 0x82:
  144.         printf( "ATN" );
  145.         break;
  146.     case 0xc4:
  147.         printf( "AREA" );
  148.         break;
  149.     case 0x83:
  150.         printf( "CALL" );
  151.         break;
  152.     case 0x84:
  153.         printf( "CDBL" );
  154.         break;
  155.     case 0x85:
  156.         printf( "CHR$" );
  157.         break;
  158.     case 0x86:
  159.         printf( "CINT" );
  160.         break;
  161.     case 0x87:
  162.         printf( "CLOSE" );
  163.         break;
  164.     case 0x88:
  165.         printf( "COMMON" );
  166.         break;
  167.     case 0x89:
  168.         printf( "COS" );
  169.         break;
  170.     case 0x8a:
  171.         printf( "CVD" );
  172.         break;
  173.     case 0x8b:
  174.         printf( "CVI" );
  175.         break;
  176.     case 0x8c:
  177.         printf( "CVS" );
  178.         break;
  179.     case 0xc1:
  180.         printf( "CLNG" );
  181.         break;
  182.     case 0xc2:
  183.         printf( "CVL" );
  184.         break;
  185.     case 0x8d:
  186.         printf( "DATA" );
  187.         break;
  188.     case 0xf4:
  189.         printf( "EQV" );
  190.         break;
  191.     case 0x8e:
  192.         printf( "ELSE" );
  193.         break;
  194.     case 0x8f:
  195.         printf( "EOF" );
  196.         break;
  197.     case 0x90:
  198.         printf( "EXP" );
  199.         break;
  200.     case 0x91:
  201.         printf( "FIELD" );
  202.         break;
  203.     case 0x92:
  204.         printf( "FIX" );
  205.         break;
  206.     case 0x93:
  207.         printf( "FN" );
  208.         break;
  209.     case 0x94:
  210.         printf( "FOR" );
  211.         break;
  212.     case 0x95:
  213.         printf( "GET" );
  214.         break;
  215.     case 0x96:
  216.         printf( "GOSUB" );
  217.         break;
  218.     case 0x97:
  219.         printf( "GOTO" );
  220.         break;
  221.     case 0xf5:
  222.         printf( "IMP" );
  223.         break;
  224.     case 0x98:
  225.         printf( "IF" );
  226.         break;
  227.     case 0x99:
  228.         printf( "INKEY$" );
  229.         break;
  230.     case 0x9a:
  231.         printf( "INPUT" );
  232.         break;
  233.     case 0x9b:
  234.         printf( "INT" );
  235.         break;
  236.     case 0x9c:
  237.         printf( "LEFT$" );
  238.         break;
  239.     case 0x9d:
  240.         printf( "LEN" );
  241.         break;
  242.     case 0x9e:
  243.         printf( "LET" );
  244.         break;
  245.     case 0x9f:
  246.         printf( "LINE" );
  247.         break;
  248.     case 0xa1:
  249.         printf( "LOC" );
  250.         break;
  251.     case 0xa2:
  252.         printf( "LOF" );
  253.         break;
  254.     case 0xa3:
  255.         printf( "LOG" );
  256.         break;
  257.     case 0xa4:
  258.         printf( "LSET" );
  259.         break;
  260.     case 0xf6:
  261.         printf( "MOD" );
  262.         break;
  263.     case 0xa5:
  264.         printf( "MID$" );
  265.         break;
  266.     case 0xa6:
  267.         printf( "MKD$" );
  268.         break;
  269.     case 0xa7:
  270.         printf( "MKI$" );
  271.         break;
  272.     case 0xa8:
  273.         printf( "MKS$" );
  274.         break;
  275.     case 0xc3:
  276.         printf( "MKL$" );
  277.         break;
  278.     case 0xa9:
  279.         printf( "NEXT" );
  280.         break;
  281.     case 0xe7:
  282.         printf( "NOT" );
  283.         break;
  284.     case 0xf2:
  285.         printf( "OR" );
  286.         break;
  287.     case 0xaa:
  288.         printf( "ON" );
  289.         break;
  290.     case 0xab:
  291.         printf( "OPEN" );
  292.         break;
  293.     case 0xac:
  294.         printf( "PRINT" );
  295.         break;
  296.     case 0xad:
  297.         printf( "PUT" );
  298.         break;
  299.     case 0xae:
  300.         printf( "READ" );
  301.         break;
  302.     case 0xb0:
  303.         printf( "RETURN" );
  304.         break;
  305.     case 0xb1:
  306.         printf( "RIGHT$" );
  307.         break;
  308.     case 0xb2:
  309.         printf( "RND" );
  310.         break;
  311.     case 0xb3:
  312.         printf( "RSET" );
  313.         break;
  314.     case 0xb4:
  315.         printf( "SGN" );
  316.         break;
  317.     case 0xb5:
  318.         printf( "SIN" );
  319.         break;
  320.     case 0xb6:
  321.         printf( "SPACE$" );
  322.         break;
  323.     case 0xb7:
  324.         printf( "SQR" );
  325.         break;
  326.     case 0xb8:
  327.         printf( "STR$" );
  328.         break;
  329.     case 0xb9:
  330.         printf( "STRING$" );
  331.         break;
  332.     case 0xe3:
  333.         printf( "STATIC" );
  334.         break;
  335.     case 0xba:
  336.         printf( "TAN" );
  337.         break;
  338.     case 0xe6:
  339.         printf( "THEN" );
  340.         break;
  341.     case 0xe5:
  342.         printf( "TO" );
  343.         break;
  344.     case 0xe4:
  345.         printf( "USING" );
  346.         break;
  347.     case 0xbc:
  348.         printf( "VAL" );
  349.         break;
  350.     case 0xbd:
  351.         printf( "WEND" );
  352.         break;
  353.     case 0xbe:
  354.         printf( "WHILE" );
  355.         break;
  356.     case 0xbf:
  357.         printf( "WRITE" );
  358.         break;
  359.     case 0xf3:
  360.         printf( "XOR" );
  361.         break;
  362.     case 0xF8:
  363.         c = getchar();
  364.         count++;
  365.         switch( c )
  366.         {
  367.         case 0xd8:
  368.             printf( "AREAFILL" );
  369.             break;
  370.         case 0xb5:
  371.             printf( "BEEP" );
  372.             break;
  373.         case 0x81:
  374.             printf( "CHAIN" );
  375.             break;
  376.         case 0x82:
  377.             printf( "CLEAR" );
  378.             break;
  379.         case 0x83:
  380.             printf( "CLS" );
  381.             break;
  382.         case 0x84:
  383.             printf( "CONT" );
  384.             break;
  385.         case 0x85:
  386.             printf( "CSNG" );
  387.             break;
  388.         case 0xb6:
  389.             printf( "CIRCLE" );
  390.             break;
  391.         case 0xc6:
  392.             printf( "CSRLIN" );
  393.             break;
  394.         case 0xd9:
  395.             printf( "COLOR" );
  396.             break;
  397.         case 0xdd:
  398.             printf( "CHDIR" );
  399.             break;
  400.         case 0x86:
  401.             printf( "DATE$" );
  402.             break;
  403.         case 0x87:
  404.             printf( "DEFINT" );
  405.             break;
  406.         case 0x88:
  407.             printf( "DEFSNG" );
  408.             break;
  409.         case 0x89:
  410.             printf( "DEFDBL" );
  411.             break;
  412.         case 0x8a:
  413.             printf( "DEFSTR" );
  414.             break;
  415.         case 0x8b:
  416.             printf( "DEF" );
  417.             break;
  418.         case 0x8c:
  419.             printf( "DELETE" );
  420.             break;
  421.         case 0x8d:
  422.             printf( "DIM" );
  423.             break;
  424.         case 0xd4:
  425.             printf( "DECLARE" );
  426.             break;
  427.         case 0xd6:
  428.             printf( "DEFLNG" );
  429.             break;
  430.         case 0x8e:
  431.             printf( "EDIT" );
  432.             break;
  433.         case 0x8f:
  434.             printf( "END" );
  435.             break;
  436.         case 0x90:
  437.             printf( "ERASE" );
  438.             break;
  439.         case 0x91:
  440.             printf( "ERL" );
  441.             break;
  442.         case 0x92:
  443.             printf( "ERROR" );
  444.             break;
  445.         case 0x93:
  446.             printf( "ERR" );
  447.             break;
  448.         case 0xbf:
  449.             printf( "EXIT" );
  450.             break;
  451.         case 0x94:
  452.             printf( "FILES" );
  453.             break;
  454.         case 0x95:
  455.             printf( "FRE" );
  456.             break;
  457.         case 0xd5:
  458.             printf( "FUNCTION" );
  459.             break;
  460.         case 0x96:
  461.             printf( "HEX$" );
  462.             break;
  463.         case 0x97:
  464.             printf( "INSTR" );
  465.             break;
  466.         case 0x98:
  467.             printf( "KILL" );
  468.             break;
  469.         case 0x99:
  470.             printf( "LIST" );
  471.             break;
  472.         case 0x9a:
  473.             printf( "LLIST" );
  474.             break;
  475.         case 0x9b:
  476.             printf( "LOAD" );
  477.             break;
  478.         case 0x9c:
  479.             printf( "LPOS" );
  480.             break;
  481.         case 0x9d:
  482.             printf( "LPRINT" );
  483.             break;
  484.         case 0xc5:
  485.             printf( "LOCATE" );
  486.             break;
  487.         case 0xc7:
  488.             printf( "LBOUND" );
  489.             break;
  490.         case 0xcc:
  491.             printf( "LIBRARY" );
  492.             break;
  493.         case 0x9e:
  494.             printf( "MERGE" );
  495.             break;
  496.         case 0xb8:
  497.             printf( "MOUSE" );
  498.             break;
  499.         case 0xc2:
  500.             printf( "MENU" );
  501.             break;
  502.         case 0x9f:
  503.             printf( "NAME" );
  504.             break;
  505.         case 0xa0:
  506.             printf( "NEW" );
  507.             break;
  508.         case 0xa1:
  509.             printf( "OCT$" );
  510.             break;
  511.         case 0xa2:
  512.             printf( "OPTION" );
  513.             break;
  514.         case 0xa3:
  515.             printf( "PEEK" );
  516.             break;
  517.         case 0xa4:
  518.             printf( "POKE" );
  519.             break;
  520.         case 0xa5:
  521.             printf( "POS" );
  522.             break;
  523.         case 0xb9:
  524.             printf( "POINT" );
  525.             break;
  526.         case 0xba:
  527.             printf( "PRESET" );
  528.             break;
  529.         case 0xbb:
  530.             printf( "PSET" );
  531.             break;
  532.         case 0xd2:
  533.             printf( "PAINT" );
  534.             break;
  535.         case 0xda:
  536.             printf( "PATTERN" );
  537.             break;
  538.         case 0xdb:
  539.             printf( "PALETTE" );
  540.             break;
  541.         case 0xa6:
  542.             printf( "RANDOMIZE" );
  543.             break;
  544.         case 0xa8:
  545.             printf( "RESTORE" );
  546.             break;
  547.         case 0xa9:
  548.             printf( "RESUME" );
  549.             break;
  550.         case 0xaa:
  551.             printf( "RUN" );
  552.             break;
  553.         case 0xbc:
  554.             printf( "RESET" );
  555.             break;
  556.         case 0xab:
  557.             printf( "SAVE" );
  558.             break;
  559.         case 0xad:
  560.             printf( "STOP" );
  561.             break;
  562.         case 0xae:
  563.             printf( "SWAP" );
  564.             break;
  565.         case 0xaf:
  566.             printf( "SYSTEM" );
  567.             break;
  568.         case 0xbe:
  569.             printf( "SUB" );
  570.             break;
  571.         case 0xc0:
  572.             printf( "SOUND" );
  573.             break;
  574.         case 0xc9:
  575.             printf( "SHARED" );
  576.             break;
  577.         case 0xcb:
  578.             printf( "SCROLL" );
  579.             break;
  580.         case 0xd3:
  581.             printf( "SCREEN" );
  582.             break;
  583.         case 0xd7:
  584.             printf( "SADD" );
  585.             break;
  586.         case 0xdc:
  587.             printf( "SLEEP" );
  588.             break;
  589.         case 0xde:
  590.             printf( "STRIG" );
  591.             break;
  592.         case 0xdf:
  593.             printf( "STICK" );
  594.             break;
  595.         case 0xb0:
  596.             printf( "TIME" );
  597.             break;
  598.         case 0xb1:
  599.             printf( "TRON" );
  600.             break;
  601.         case 0xb2:
  602.             printf( "TROFF" );
  603.             break;
  604.         case 0xbd:
  605.             printf( "TIMER" );
  606.             break;
  607.         case 0xc8:
  608.             printf( "UBOUND" );
  609.             break;
  610.         case 0xca:
  611.             printf( "UCASE$" );
  612.             break;
  613.         case 0xb3:
  614.             printf( "VARPTR" );
  615.             break;
  616.         case 0xb4:
  617.             printf( "WIDTH" );
  618.             break;
  619.         case 0xc3:
  620.             printf( "WINDOW" );
  621.             break;
  622.         }
  623.         break;
  624.     case 0xF9:
  625.         c = getchar();
  626.         count++;
  627.         switch( c )
  628.         {
  629.         case 0xfa:
  630.             printf( "SPC" );
  631.             break;
  632.         case 0xff:
  633.             printf( "ALL" );
  634.             break;
  635.         case 0xfe:
  636.             printf( "APPEND" );
  637.             break;
  638.         case 0xfd:
  639.             printf( "AS" );
  640.             break;
  641.         case 0xfc:
  642.             printf( "BASE" );
  643.             break;
  644.         case 0xf5:
  645.             printf( "BREAK" );
  646.             break;
  647.         case 0xfb:
  648.             printf( "OUTPUT" );
  649.             break;
  650.         case 0xf4:
  651.             printf( "OFF" );
  652.             break;
  653.         case 0xf9:
  654.             printf( "STEP" );
  655.             break;
  656.         case 0xf8:
  657.             printf( "TAB" );
  658.             break;
  659.         case 0xf6:
  660.             printf( "WAIT" );
  661.             break;
  662.         case 0xf7:
  663.             printf( "USR" );
  664.             break;
  665.         }
  666.         break;
  667.     case 0xFA:
  668.         c = getchar();
  669.         count++;
  670.         switch( c )
  671.         {
  672.         case 0x97:
  673.             printf( "COLLISION" );
  674.             break;
  675.         case 0x87:
  676.             printf( "OBJECT.SHAPE" );
  677.             break;
  678.         case 0x88:
  679.             printf( "OBJECT.PRIORITY" );
  680.             break;
  681.         case 0x89:
  682.             printf( "OBJECT.X" );
  683.             break;
  684.         case 0x8a:
  685.             printf( "OBJECT.Y" );
  686.             break;
  687.         case 0x8b:
  688.             printf( "OBJECT.VX" );
  689.             break;
  690.         case 0x8c:
  691.             printf( "OBJECT.VY" );
  692.             break;
  693.         case 0x8d:
  694.             printf( "OBJECT.AX" );
  695.             break;
  696.         case 0x8e:
  697.             printf( "OBJECT.AY" );
  698.             break;
  699.         case 0x8f:
  700.             printf( "OBJECT.CLIP" );
  701.             break;
  702.         case 0x90:
  703.             printf( "OBJECT.PLANES" );
  704.             break;
  705.         case 0x91:
  706.             printf( "OBJECT.HIT" );
  707.             break;
  708.         case 0x92:
  709.             printf( "OBJECT.ON" );
  710.             break;
  711.         case 0x93:
  712.             printf( "OBJECT.OFF" );
  713.             break;
  714.         case 0x94:
  715.             printf( "OBJECT.START" );
  716.             break;
  717.         case 0x95:
  718.             printf( "OBJECT.STOP" );
  719.             break;
  720.         case 0x96:
  721.             printf( "OBJECT.CLOSE" );
  722.             break;
  723.         case 0x81:
  724.             printf( "POKEW" );
  725.             break;
  726.         case 0x82:
  727.             printf( "POKEL" );
  728.             break;
  729.         case 0x83:
  730.             printf( "PEEKW" );
  731.             break;
  732.         case 0x84:
  733.             printf( "PEEKL" );
  734.             break;
  735.         case 0x85:
  736.             printf( "SAY" );
  737.             break;
  738.         case 0x86:
  739.             printf( "TRANSLATE$" );
  740.             break;
  741.         case 0x80:
  742.             printf( "WAVE" );
  743.             break;
  744.         }
  745.         break;
  746.     case 0xFB:
  747.         c = getchar();
  748.         count++;
  749.         switch( c )
  750.         {
  751.         case 0xFF:
  752.             printf( "PTAB" );
  753.             break;
  754.         default:
  755.             printf( "<fb><%02x>", c );
  756.             break;
  757.         }
  758.         break;
  759.     case 0x01:    /* variable */
  760.     case 0x02:    /* define label */
  761.         id = getword();
  762.         count += 2;
  763.         if( s = get_sym( id ) )
  764.             printf( "%s", s );
  765.         else
  766.             printf( "<%04x>", id );
  767.         break;
  768.     case 0x03:    /* use label */
  769.         c = getchar();
  770.         count++;
  771.         if( !c )
  772.         {
  773.             id = getword();
  774.             count += 2;
  775.             if( s = get_sym( id ) )
  776.                 printf( "%s", s );
  777.             else
  778.                 printf( "<%04x>", id );
  779.         }
  780.         break;
  781.     case 0xE9:
  782.         putchar( '>' );
  783.         break;
  784.     case 0xF0:
  785.         putchar( '^' );
  786.         break;
  787.     case 0xEB:
  788.         putchar( '<' );
  789.         break;
  790.     case 0xEA:
  791.         putchar( '=' );
  792.         break;
  793.     case 0xED:
  794.         putchar( '-' );
  795.         break;
  796.     case 0xEE:
  797.         putchar( '*' );
  798.         break;
  799.     case 0xEF:
  800.         putchar( '/' );
  801.         break;
  802.     case 0xEC:
  803.         putchar( '+' );
  804.         break;
  805.     case 0x0F:
  806.         printf( "%d", getchar() );
  807.         count++;
  808.         break;
  809.     case 0x11:
  810.         putchar( '0' );
  811.         break;
  812.     case 0x12:
  813.         putchar( '1' );
  814.         break;
  815.     case 0x13:
  816.         putchar( '2' );
  817.         break;
  818.     case 0x14:
  819.         putchar( '3' );
  820.         break;
  821.     case 0x15:
  822.         putchar( '4' );
  823.         break;
  824.     case 0x16:
  825.         putchar( '5' );
  826.         break;
  827.     case 0x17:
  828.         putchar( '6' );
  829.         break;
  830.     case 0x18:
  831.         putchar( '7' );
  832.         break;
  833.     case 0x19:
  834.         putchar( '8' );
  835.         break;
  836.     case 0x1A:
  837.         putchar( '9' );
  838.         break;
  839.     case 0x0C:
  840.         printf( "&H%x", getword() );
  841.         count += 2;
  842.         break;
  843.     case 0x1C:
  844.         printf( "%d", getword() );
  845.         count += 2;
  846.         break;
  847.     case 0x1D:
  848.         *((long *)&f) = getlong();
  849.         printf( "%g", f );
  850.         count += 4;
  851.         break;
  852.     case 0x1E:
  853.         printf( "%ld", getlong() );
  854.         count += 4;
  855.         break;
  856.     default:
  857.         if( isprint( c ) )
  858.             putchar( c );
  859.         else
  860.             printf( "<%02x>", c );
  861.         break;
  862.     }
  863.     return count;
  864. }
  865.  
  866. void main( int argc, char *argv[] )
  867. {
  868.     int chars = 0, count, indent, nsym = 0;
  869.     struct symbol *sym;
  870.  
  871.     /* pass 1 - read symbol table */
  872.     getchar(); /* skip F5 */
  873.     while( count = getword() )    /* skip code area */
  874.     {
  875.         chars += count;
  876.         count -= 2;
  877.         while( count-- ) getchar();
  878.     }
  879.     getchar(); /* skip null byte */
  880.     if( !( chars & 1 ) ) getchar();
  881.     while( ( count = getchar() ) != EOF )
  882.     {
  883.         if( sym = read_sym( count, nsym++ ) )
  884.             store_sym( sym );
  885.     }
  886. #ifdef DUMP_SYM_TAB
  887.     printf( "--- %d symbols ---\n", nsym );
  888.     for( sym = sym_tab; sym; sym = sym->next )
  889.         printf( "%d : %s\n", sym->id, sym->s );
  890.     printf( "------------------\n" );
  891. #endif
  892.  
  893.     rewind( stdin );
  894.  
  895.     /* pass 2 - read code */
  896.     getchar();
  897.     while( count = getword() ) 
  898.     {
  899.         count -= 2;
  900.         indent = getchar();
  901.         count--;
  902.         while( indent-- )
  903.             putchar( ' ' );
  904.         while( count )
  905.             count -= expand();
  906.     }
  907.     delete_sym_tab();
  908. }
  909.