git.oblomov.eu Git - wine/blob - debugger/debug.l

   1 /* Lexical scanner for command line parsing in the Wine debugger
   2  *
   3  * Version 1.0
   4  * Eric Youngdale
   5  * 9/93
   6  */
   7
   8 %{
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include "debugger.h"
  13 #include "xmalloc.h"
  14 #include "y.tab.h"
  15
  16 #ifdef USE_READLINE
  17 #undef YY_INPUT
  18 #define YY_INPUT(buf,result,max_size) \
  19         if ( (result = dbg_read((char *) buf, max_size )) < 0 ) \
  20             YY_FATAL_ERROR( "read() in flex scanner failed" );
  21 #endif
  22
  23 extern char * readline(char *);
  24 extern void add_history(char *);
  25 static int dbg_read(char * buf, int size);
  26 static char * make_symbol(char *);
  27 void flush_symbols();
  28 static int syntax_error;
  29 %}
  30
  31 DIGIT      [0-9]
  32 HEXDIGIT   [0-9a-fA-F]
  33 FORMAT     [bcdiswx]
  34 IDENTIFIER [_a-zA-Z\.~][_a-zA-Z0-9\.~]*
  35
  36 %%
  37
  38 \n              { syntax_error = 0; return tEOL; } /*Indicates end of command*/
  39
  40 "||"            { return OP_LOR; }
  41 "&&"            { return OP_LAND; }
  42 "=="            { return OP_EQ; }
  43 "!="            { return OP_NE; }
  44 "<="            { return OP_LE; }
  45 ">="            { return OP_GE; }
  46 "<<"            { return OP_SHL; }
  47 ">>"            { return OP_SHR; }
  48 [-+<=>|&^()*/%:!~]      { return *yytext; }
  49
  50 "0x"{HEXDIGIT}+      { sscanf(yytext, "%x", &yylval.integer); return tNUM; }
  51 {DIGIT}+             { sscanf(yytext, "%d", &yylval.integer); return tNUM; }
  52
  53 "/"{DIGIT}+{FORMAT}  { char * last;
  54                        yylval.integer = strtol( yytext+1, &last, NULL );
  55                        yylval.integer = (yylval.integer << 8) | *last;
  56                        return tFORMAT; }
  57 "/"{FORMAT}          { yylval.integer = (1 << 8) | yytext[1]; return tFORMAT; }
  58
  59 $pc     { yylval.reg = REG_EIP; return tREG; }
  60 $flags  { yylval.reg = REG_EFL; return tREG; }
  61 $eip    { yylval.reg = REG_EIP; return tREG; }
  62 $ip     { yylval.reg = REG_IP;  return tREG; }
  63 $esp    { yylval.reg = REG_ESP; return tREG; }
  64 $sp     { yylval.reg = REG_SP;  return tREG; }
  65 $eax    { yylval.reg = REG_EAX; return tREG; }
  66 $ebx    { yylval.reg = REG_EBX; return tREG; }
  67 $ecx    { yylval.reg = REG_ECX; return tREG; }
  68 $edx    { yylval.reg = REG_EDX; return tREG; }
  69 $esi    { yylval.reg = REG_ESI; return tREG; }
  70 $edi    { yylval.reg = REG_EDI; return tREG; }
  71 $ebp    { yylval.reg = REG_EBP; return tREG; }
  72 $ax     { yylval.reg = REG_AX;  return tREG; }
  73 $bx     { yylval.reg = REG_BX;  return tREG; }
  74 $cx     { yylval.reg = REG_CX;  return tREG; }
  75 $dx     { yylval.reg = REG_DX;  return tREG; }
  76 $si     { yylval.reg = REG_SI;  return tREG; }
  77 $di     { yylval.reg = REG_DI;  return tREG; }
  78 $bp     { yylval.reg = REG_BP;  return tREG; }
  79 $es     { yylval.reg = REG_ES;  return tREG; }
  80 $ds     { yylval.reg = REG_DS;  return tREG; }
  81 $cs     { yylval.reg = REG_CS;  return tREG; }
  82 $ss     { yylval.reg = REG_SS;  return tREG; }
  83
  84 info|inf|in                     { return tINFO; }
  85 show|sho|sh                     { return tINFO; }
  86 list|lis|li|l                   { return tLIST; }
  87 break|brea|bre|br|b             { return tBREAK; }
  88 enable|enabl|enab|ena           { return tENABLE;}
  89 disable|disabl|disab|disa|dis   { return tDISABLE; }
  90 delete|delet|dele|del           { return tDELETE; }
  91 quit|qui|qu|q                   { return tQUIT; }
  92 set|se                          { return tSET; }
  93 walk|w                          { return tWALK; }
  94 x                               { return tEXAM; }
  95
  96 class|clas|cla                  { return tCLASS; }
  97 module|modul|modu|mod           { return tMODULE; }
  98 queue|queu|que                  { return tQUEUE; }
  99 registers|regs|reg|re           { return tREGS; }
 100 segments|segment|segm|seg|se    { return tSEGMENTS; }
 101 stack|stac|sta|st               { return tSTACK; }
 102 window|windo|wind|win|wnd       { return tWND; }
 103
 104 help|hel|he|"?"                 { return tHELP; }
 105
 106 backtrace|bt                    { return tBACKTRACE; }
 107
 108 cont|con|co|c                   { return tCONT; }
 109 step|ste|st|s                   { return tSTEP; }
 110 next|nex|ne|n                   { return tNEXT; }
 111
 112 symbolfile|symbolfil|symbolfi|symbolf|symbol|symbo|symb { return tSYMBOLFILE; }
 113
 114 define|defin|defi|def|de        { return tDEFINE; }
 115 abort|abor|abo                  { return tABORT; }
 116 print|prin|pri|pr|p             { return tPRINT; }
 117
 118 mode                            { return tMODE; }
 119
 120 {IDENTIFIER}    { yylval.string = make_symbol(yytext); return tIDENTIFIER; }
 121
 122 [ \t]+        /* Eat up whitespace */
 123
 124 .               { if (syntax_error == 0)
 125                   {
 126                     syntax_error ++; fprintf(stderr, "Syntax Error\n");
 127                   }
 128                 }
 129
 130 %%
 131
 132 #ifndef yywrap
 133 int yywrap(void) { return 1; }
 134 #endif
 135
 136 #ifdef USE_READLINE
 137 #ifndef whitespace
 138 #define whitespace(c) (((c) == ' ') || ((c) == '\t'))
 139 #endif
 140
 141
 142 /* Strip whitespace from the start and end of STRING. */
 143 static void stripwhite (char *string)
 144 {
 145   register int i = 0;
 146
 147   while (whitespace (string[i]))
 148     i++;
 149
 150   if (i)
 151     strcpy (string, string + i);
 152
 153   i = strlen (string) - 1;
 154
 155   while (i > 0 && whitespace (string[i]))
 156     i--;
 157
 158   string[++i] = '\0';
 159 }
 160
 161 static int dbg_read(char * buf, int size)
 162 {
 163     static char last_line[256] = "";
 164     char * line;
 165     int len;
 166
 167     for (;;)
 168     {
 169         flush_symbols();
 170         line = readline ("Wine-dbg>");
 171         if (!line) exit(0);
 172
 173         /* Remove leading and trailing whitespace from the line */
 174
 175         stripwhite (line);
 176
 177         /* If there is anything left, add it to the history list
 178            and execute it. Otherwise, re-execute last command. */
 179
 180         if (*line)
 181         {
 182             add_history( line );
 183             strncpy( last_line, line, 255 );
 184             last_line[255] = '\0';
 185        }
 186
 187         free( line );
 188         line = last_line;
 189
 190         if ((len = strlen(line)) > 0)
 191         {
 192             if (size < len + 1)
 193             {
 194                 fprintf(stderr,"Fatal readline goof.\n");
 195                 exit(0);
 196             }
 197             strcpy(buf, line);
 198             buf[len] = '\n';
 199             buf[len+1] = 0;
 200             return len + 1;
 201         }
 202     }
 203 }
 204
 205 static char *local_symbols[10];
 206 static int next_symbol;
 207
 208 char * make_symbol(char * symbol){
 209         return local_symbols[next_symbol++] = xstrdup(symbol);
 210 }
 211
 212 void
 213 flush_symbols(){
 214         while(--next_symbol>= 0) free(local_symbols[next_symbol]);
 215         next_symbol = 0;
 216 }
 217
 218 #endif