home *** CD-ROM | disk | FTP | other *** search
/ messroms.de / 2007-01-13_www.messroms.de.zip / VZ200 / TOOLS / AZ80.ZIP / az80.l < prev    next >
Text File  |  1999-12-27  |  8KB  |  309 lines
  1. %{
  2. #include <stdio.h>
  3. #include <stdarg.h>
  4. #include <string.h>
  5. #include "az80_tab.h"
  6.  
  7. extern    char    lstbuff[256];
  8. extern    char    * plst;
  9. extern    int    line_no;
  10. extern    int    pass_no;
  11. extern    FILE    * inpfile;
  12. extern    unsigned short PC;
  13.  
  14. int    aton(char * src, int base, char * valid, char end);
  15.  
  16. #define    TOKEN    if(plst) plst+=sprintf(plst,"%s",yytext)
  17.  
  18. %}
  19.  
  20. delim    [\t ,;()]
  21. bin    [0-1]
  22. oct    [0-7]
  23. dec    [0-9]
  24. hex    [0-9A-Fa-f]
  25. alnum    [0-9A-Za-z_]
  26.  
  27. %s    cc
  28.  
  29. %%
  30.  
  31. <cc>[Nn][Zz]        { TOKEN; return _cNZ; }
  32. <cc>[Zz]        { TOKEN; return _cZ; }
  33. <cc>[Nn][Cc]        { TOKEN; return _cNC; }
  34. <cc>[Cc]        { TOKEN; return _cC; }
  35. <cc>[Pp][Oo]        { TOKEN; return _cPO; }
  36. <cc>[Pp][Ee]        { TOKEN; return _cPE; }
  37. <cc>[Pp]        { TOKEN; return _cP; }
  38. <cc>[Mm]        { TOKEN; return _cM; }
  39.  
  40. [Bb][Cc]        { TOKEN; return _BC; }
  41. [Dd][Ee]        { TOKEN; return _DE; }
  42. [Hh][Ll]        { TOKEN; return _HL; }
  43. [Ss][Pp]        { TOKEN; return _SP; }
  44. [Aa][Ff]        { TOKEN; return _AF; }
  45.  
  46. [Ii][Xx]        { TOKEN; return _IX; }
  47. [Ii][Yy]        { TOKEN; return _IY; }
  48.  
  49. [Bb]            { TOKEN; return _B; }
  50. [Cc]            { TOKEN; return _C; }
  51. [Dd]            { TOKEN; return _D; }
  52. [Ee]            { TOKEN; return _E; }
  53. [Hh]            { TOKEN; return _H; }
  54. [Ll]            { TOKEN; return _L; }
  55. "("[Hh][Ll]")"        { TOKEN; return _M; }
  56. [Aa]            { TOKEN; return _A; }
  57. [Ff]            { TOKEN; return _F; }
  58. [Ii]            { TOKEN; return _I; }
  59. [Rr]            { TOKEN; return _R; }
  60.  
  61. "("[Ii][Xx][+-]{bin}+[Bb]")"    {
  62.                 TOKEN;
  63.                 yylval.i = aton(yytext+3,2,"01",'B');
  64.                 return    _MX;
  65.             }
  66.  
  67. "("[Ii][Xx][+-]{oct}+[Oo]")"    {
  68.                 TOKEN;
  69.                 yylval.i = aton(yytext+3,8,"01234567",'O');
  70.                 return    _MX;
  71.             }
  72.  
  73. "("[Ii][Xx][+-]{dec}+[Dd]?")"    {
  74.                 TOKEN;
  75.                 yylval.i = aton(yytext+3,10,"0123456789",'D');
  76.                 return    _MX;
  77.             }
  78.  
  79. "("[Ii][Xx][+-]{hex}+[Hh]")"    {
  80.                 TOKEN;
  81.                 yylval.i = aton(yytext+3,16,"0123456789ABCDEF",'H');
  82.                 return    _MX;
  83.             }
  84.  
  85. "("[Ii][Xx]")"        { TOKEN; yylval.i = 0; return _MX; }
  86.  
  87. "("[Ii][Yy][+-]{bin}+[Bb]")"    {
  88.                 TOKEN;
  89.                 yylval.i = aton(yytext+3,2,"01",'B');
  90.                 return    _MY;
  91.             }
  92.  
  93. "("[Ii][Yy][+-]{oct}+[Oo]")"    {
  94.                 TOKEN;
  95.                 yylval.i = aton(yytext+3,8,"01234567",'O');
  96.                 return    _MY;
  97.             }
  98.  
  99. "("[Ii][Yy][+-]{dec}+[Dd]?")"    {
  100.                 TOKEN;
  101.                 yylval.i = aton(yytext+3,10,"0123456789",'D');
  102.                 return    _MY;
  103.             }
  104.  
  105. "("[Ii][Yy][+-]{hex}+[Hh]")"    {
  106.                 TOKEN;
  107.                 yylval.i = aton(yytext+3,16,"0123456789ABCDEF",'H');
  108.                 return    _MY;
  109.             }
  110.  
  111. "("[Ii][Yy]")"          { TOKEN; yylval.i = 0; return _MY; }
  112.  
  113. "("[Cc]")"              { TOKEN; return _PORTC; }
  114.  
  115. [Aa][Dd][Cc]            { TOKEN; return _ADC; }
  116. [Aa][Dd][Dd]        { TOKEN; return _ADD; }
  117. [Aa][Nn][Dd]        { TOKEN; return _AND; }
  118. [Bb][Ii][Tt]        { TOKEN; return _BIT; }
  119. [Cc][Aa][Ll][Ll]    { TOKEN; BEGIN(cc); return _CALL; }
  120. [Cc][Cc][Ff]        { TOKEN; return _CCF; }
  121. [Cc][Pp]        { TOKEN; return _CP; }
  122. [Cc][Pp][Dd]        { TOKEN; return _CPD; }
  123. [Cc][Pp][Dd][Rr]    { TOKEN; return _CPDR; }
  124. [Cc][Pp][Ii]        { TOKEN; return _CPI; }
  125. [Cc][Pp][Ii][Rr]    { TOKEN; return _CPIR; }
  126. [Cc][Pp][Ll]        { TOKEN; return _CPL; }
  127. [Dd][Aa][Aa]        { TOKEN; return _DAA; }
  128. [Dd][Ee][Cc]        { TOKEN; return _DEC; }
  129. [Dd][Ii]        { TOKEN; return _DI; }
  130. [Dd][Jj][Nn][Zz]    { TOKEN; return _DJNZ; }
  131. [Ee][Ii]        { TOKEN; return _EI; }
  132. [Ee][Xx]        { TOKEN; return _EX; }
  133. [Ee][Xx][Xx]        { TOKEN; return _EXX; }
  134. [Hh][Aa][Ll][Tt]    { TOKEN; return _HALT; }
  135. [Ii][Mm]        { TOKEN; return _IM; }
  136. [Ii][Nn]        { TOKEN; return _IN; }
  137. [Ii][Nn][Cc]        { TOKEN; return _INC; }
  138. [Ii][Nn][Dd]        { TOKEN; return _IND; }
  139. [Ii][Nn][Dd][Rr]    { TOKEN; return _INDR; }
  140. [Ii][Nn][Ii]        { TOKEN; return _INI; }
  141. [Ii][Nn][Ii][Rr]    { TOKEN; return _INIR; }
  142. [Jj][Pp]        { TOKEN; BEGIN(cc); return _JP; }
  143. [Jj][Rr]        { TOKEN; BEGIN(cc); return _JR; }
  144. [Ll][Dd]        { TOKEN; return _LD; }
  145. [Ll][Dd][Dd]        { TOKEN; return _LDD; }
  146. [Ll][Dd][Dd][Rr]    { TOKEN; return _LDDR; }
  147. [Ll][Dd][Ii]        { TOKEN; return _LDI; }
  148. [Ll][Dd][Ii][Rr]    { TOKEN; return _LDIR; }
  149. [Nn][Ee][Gg]        { TOKEN; return _NEG; }
  150. [Nn][Oo][Pp]        { TOKEN; return _NOP; }
  151. [Oo][Rr]        { TOKEN; return _OR; }
  152. [Oo][Tt][Dd][Rr]    { TOKEN; return _OTDR; }
  153. [Oo][Tt][Ii][Rr]    { TOKEN; return _OTIR; }
  154. [Oo][Uu][Tt]        { TOKEN; return _OUT; }
  155. [Oo][Uu][Tt][Dd]    { TOKEN; return _OUTD; }
  156. [Oo][Uu][Tt][Ii]    { TOKEN; return _OUTI; }
  157. [Pp][Oo][Pp]        { TOKEN; return _POP; }
  158. [Pp][Uu][Ss][Hh]    { TOKEN; return _PUSH; }
  159. [Rr][Ee][Ss]        { TOKEN; return _RES; }
  160. [Rr][Ee][Tt]        { TOKEN; BEGIN(cc); return _RET; }
  161. [Rr][Ee][Tt][Ii]    { TOKEN; return _RETI; }
  162. [Rr][Ee][Tt][Nn]    { TOKEN; return _RETN; }
  163. [Rr][Ll]        { TOKEN; return _RL; }
  164. [Rr][Ll][Aa]        { TOKEN; return _RLA; }
  165. [Rr][Ll][Cc]        { TOKEN; return _RLC; }
  166. [Rr][Ll][Cc][Aa]    { TOKEN; return _RLCA; }
  167. [Rr][Ll][Dd]        { TOKEN; return _RLD; }
  168. [Rr][Rr]        { TOKEN; return _RR; }
  169. [Rr][Rr][Aa]        { TOKEN; return _RRA; }
  170. [Rr][Rr][Cc]        { TOKEN; return _RRC; }
  171. [Rr][Rr][Cc][Aa]    { TOKEN; return _RRCA; }
  172. [Rr][Rr][Dd]        { TOKEN; return _RRD; }
  173. [Rr][Ss][Tt]        { TOKEN; return _RST; }
  174. [Ss][Bb][Cc]        { TOKEN; return _SBC; }
  175. [Ss][Cc][Ff]        { TOKEN; return _SCF; }
  176. [Ss][Ee][Tt]        { TOKEN; return _SET; }
  177. [Ss][Ll][Aa]        { TOKEN; return _SLA; }
  178. [Ss][Rr][Aa]        { TOKEN; return _SRA; }
  179. [Ss][Ll][Ll]        { TOKEN; return _SLL; }
  180. [Ss][Rr][Ll]        { TOKEN; return _SRL; }
  181. [Ss][Uu][Bb]        { TOKEN; return _SUB; }
  182. [Xx][Oo][Rr]        { TOKEN; return _XOR; }
  183.  
  184. [Dd][Ee][Ff][Bb]    { TOKEN; return _DEFB; }
  185. [Dd][Ee][Ff][Ll]    { TOKEN; return _DEFL; }
  186. [Dd][Ee][Ff][Mm]    { TOKEN; return _DEFM; }
  187. [Dd][Ee][Ff][Ss]    { TOKEN; return _DEFS; }
  188. [Dd][Ee][Ff][Ww]    { TOKEN; return _DEFW; }
  189. [Ee][Nn][Dd]        { TOKEN; return _END; }
  190. [Ee][Qq][Uu]        { TOKEN; return _EQU; }
  191. [Oo][Rr][Gg]        { TOKEN; return _ORG; }
  192.  
  193. {bin}+[Bb]        {
  194.                 TOKEN;
  195.                 yylval.i = aton(yytext,2,"01",'B');
  196.                 return _VAL;
  197.             }
  198.  
  199. {dec}+[Dd]?        {
  200.                 TOKEN;
  201.                 yylval.i = aton(yytext,10,"0123456789",'D');
  202.                 return _VAL;
  203.             }
  204.  
  205. {hex}+[Hh]        {
  206.                 TOKEN;
  207.                 yylval.i = aton(yytext,16,"0123456789ABCDEF",'H');
  208.                 return _VAL;
  209.             }
  210.  
  211. "$"            { TOKEN; yylval.i = PC; return _VAL; }
  212. ","            { TOKEN; return COMMA; }
  213. ":"                     { TOKEN; return COLON; }
  214. "("            { TOKEN; return LPAREN; }
  215. ")"            { TOKEN; return RPAREN; }
  216. "+"            { TOKEN; return PLUS; }
  217. "-"            { TOKEN; return MINUS; }
  218. "*"            { TOKEN; return MUL; }
  219. "/"            { TOKEN; return DIV; }
  220. "<<"            { TOKEN; return SHL; }
  221. ">>"            { TOKEN; return SHR; }
  222. "&"                     { TOKEN; return AND; }
  223. "|"                     { TOKEN; return OR; }
  224. "^"                     { TOKEN; return XOR; }
  225. "~"                     { TOKEN; return NOT; }
  226. \"[^\"\n]+\"            {
  227.                 TOKEN;
  228.                 yylval.s = strdup(yytext + 1);
  229.                 yylval.s[strlen(yylval.s)-1] = '\0';
  230.                 return _STR;
  231.             }
  232. \'[^\'\n]+\'        {
  233.                 TOKEN;
  234.                 yylval.i = yytext[1];
  235.                 if (yyleng > 3)
  236.                     yylval.i += 256 * yytext[2];
  237.                 return _VAL;
  238.             }
  239. [A-Za-z_]{alnum}*    {
  240.                 TOKEN;
  241.                 yylval.s = strdup(yytext);
  242.                 return _SYM;
  243.             }
  244.  
  245. [\t ]            {
  246.                 TOKEN;
  247.             }
  248. ";"[^\n]*\n        |
  249. [\n]            {
  250.                 TOKEN;
  251.                 if (plst)
  252.                     plst = lstbuff;
  253.                 BEGIN(INITIAL);
  254.                 line_no++;
  255.                 return EOL;
  256.             }
  257.  
  258. %%
  259.  
  260. int aton(char * src, int base, char * valid, char end)
  261. {
  262.     int result = 0;
  263.     int sign = 1;
  264.     char * pos;
  265.  
  266.     while (*src && !strchr(valid, toupper(*src)) && (toupper(*src) != end))
  267.     {
  268.     if (*src == '+')
  269.         sign = +1;
  270.     if (*src == '-')
  271.         sign = -sign;
  272.     src++;
  273.     }
  274.     while (*src && ((pos = strchr(valid, toupper(*src))) != NULL))
  275.     {
  276.     result *= base;
  277.     if (pos)
  278.         result += (int)(pos - valid);
  279.     src++;
  280.     }
  281.     result *= sign;
  282.     return result;
  283. }
  284.  
  285. void yyerror(char * msg, ...)
  286. {
  287.     va_list arg;
  288.     fprintf(stderr, "line %d: ", line_no);
  289.     va_start(arg, msg);
  290.     fprintf(stderr, msg, arg);
  291.     va_end(arg);
  292.     fprintf(stderr, " at \"%s\"\n", yytext);
  293. }
  294.  
  295. int yywrap(void)
  296. {
  297.     if (pass_no < 2)
  298.     {
  299.     rewind(inpfile);
  300.     PC    = 0;
  301.     line_no = 1;
  302.     pass_no++;
  303.     printf("pass %d\n", pass_no);
  304.     return 0;
  305.     }
  306.     return 1;
  307. }
  308.  
  309.