parser.y

uboot在arm处理器s3c2410的移植代码

%{
#include <malloc.h>
#include <string.h>
#include "v86bios.h"
#include "pci.h"
    
#define YYSTYPE unsigned long
    
#define MAX_VAR 0x20

    CARD32 var[MAX_VAR];
    CARD32 var_mem;


i86biosRegs regs = { 00 };

enum mem_type { BYTE, WORD, LONG, STRING };
union mem_val {
   CARD32 integer;
   char *ptr;
} rec;

struct mem {
    enum mem_type type;
        union mem_val val;
    struct mem *next;
}; 

 
struct device Device = {FALSE,NONE,{0}};

extern void yyerror(char *s);
extern int yylex( void  );
 
static void boot(void);
static void dump_mem(CARD32 addr, int len);
static void exec_int(int num);
static void *add_to_list(enum mem_type type, union mem_val *rec, void *next);
static void do_list(struct mem *list, memType addr);
static char * normalize_string(char *ptr);
%}

%token TOK_NUM
%token TOK_REG_AX
%token TOK_REG_BX
%token TOK_REG_CX
%token TOK_REG_DX
%token TOK_REG_DI
%token TOK_REG_SI
%token TOK_SEG_DS
%token TOK_SEG_ES
%token TOK_SEP
%token TOK_VAR
%token TOK_VAR_MEM
%token TOK_COMMAND_BOOT
%token TOK_COMMAND_EXEC
%token TOK_SELECT
%token TOK_STRING
%token TOK_MODIFIER_BYTE
%token TOK_MODIFIER_WORD
%token TOK_MODIFIER_LONG
%token TOK_MODIFIER_MEMSET
%token TOK_COMMAND_MEMSET
%token TOK_COMMAND_MEMDUMP
%token TOK_COMMAND_QUIT
%token TOK_ERROR
%token TOK_END
%token TOK_ISA
%token TOK_PCI
%token TOK_BYTE
%token TOK_WORD
%token TOK_LONG
%token TOK_PRINT_PORT
%token TOK_IOSTAT
%token TOK_PRINT_IRQ
%token TOK_PPCI
%token TOK_PIP
%token TOK_TRACE
%token TOK_ON
%token TOK_OFF
%token TOK_VERBOSE
%token TOK_LOG
%token TOK_LOGOFF
%token TOK_CLSTAT
%token TOK_STDOUT
%token TOK_HLT
%token TOK_DEL
%token TOK_IOPERM
%token TOK_DUMP_PCI
%token TOK_BOOT_BIOS
%%
input:        | input line  
line:          end |  com_reg | com_var | com_select
              | com_boot | com_memset | com_memdump  | com_quit 
              | com_exec | hlp | config | verbose | logging | print | clstat 
              | com_hlt | ioperm | list_pci | boot_bios 
              | error end  { printf("unknown command\n"); }
;
end:           TOK_END
;
com_reg:        reg_off val end { *(CARD16*)$1 = $2 & 0xffff; }
              | reg_seg TOK_SEP reg_off val end {
                               *(CARD16*)$1 = ($4 & 0xf0000) >> 4;
                                       *(CARD16*)$3 = ($4 & 0x0ffff);
                                        }
              |  reg_off '?' end { printf("0x%x\n",*(CARD16*)$1);}
              |  reg_seg TOK_SEP reg_off '?' end
                                     { printf("0x%x:0x%x\n",*(CARD16*)$1,
                          *(CARD16*)$3); }
;
register_read:  reg_seg TOK_SEP reg_off { $$ = (((*(CARD16*)$1) << 4) 
                                                | ((*(CARD16*)$3) & 0xffff));
                                        }
              | reg_off          { $$ = ((*(CARD16*)$1) & 0xffff); }
;
reg_off:        TOK_REG_AX  { $$ = (unsigned long)&(regs.ax); }
              | TOK_REG_BX  { $$ = (unsigned long)&(regs.bx); }
              | TOK_REG_CX  { $$ = (unsigned long)&(regs.cx); }
              | TOK_REG_DX  { $$ = (unsigned long)&(regs.dx); }
              | TOK_REG_DI  { $$ = (unsigned long)&(regs.di); }
              | TOK_REG_SI  { $$ = (unsigned long)&(regs.si); }
;
reg_seg:        TOK_SEG_DS  { $$ = (unsigned long)&(regs.ds); }
              | TOK_SEG_ES  { $$ = (unsigned long)&(regs.es); }
;
com_var:        TOK_VAR_MEM '?' end { printf("var mem: 0x%x\n",var_mem); }
          | TOK_VAR '?' end { if ($1 < MAX_VAR)
          printf("var[%i]: 0x%x\n",(int)$1,var[$1]);
          else
          printf("var index %i out of range\n",(int)$1); }
          | TOK_VAR_MEM val end { var_mem = $2; }    
              | TOK_VAR val end    { if ($1 <= MAX_VAR)
                                 var[$1] = $2;
                              else 
                                     printf("var index %i out of range\n",(int)$1); }
              | TOK_VAR error  end { printf("$i val\n"); }
              | TOK_VAR_MEM error  end { printf("$i val\n"); }
;
com_boot:       TOK_COMMAND_BOOT  end { boot(); }
                TOK_COMMAND_BOOT error end { boot(); }
;
com_select:     TOK_SELECT TOK_ISA end { Device.booted = FALSE;
                                         Device.type = ISA;
                     CurrentPci = NULL; }   
              | TOK_SELECT TOK_PCI val TOK_SEP val TOK_SEP val end
                                    { Device.booted = FALSE;
                      Device.type = PCI; 
                                      Device.loc.pci.bus = $3;
                                      Device.loc.pci.dev = $5; 
                                      Device.loc.pci.func = $7; }
              | TOK_SELECT '?' end
                                   { switch (Device.type) {
                                     case ISA:
                                       printf("isa\n");
                                       break;
                                     case PCI:
                                      printf("pci: %x:%x:%x\n",Device.loc.pci.bus,
                                              Device.loc.pci.dev,
                          Device.loc.pci.func);
                                      break;
                                 default:
                                      printf("no device selected\n");
                                      break;
                                     }
                                    }
              | TOK_SELECT error end { printf("select ? | isa "
                                         "| pci:bus:dev:func\n"); }
;
com_quit:       TOK_COMMAND_QUIT end { return 0; }
              | TOK_COMMAND_QUIT error end { logoff(); return 0; }
;
com_exec:       TOK_COMMAND_EXEC end { exec_int(0x10); }
          | TOK_COMMAND_EXEC val end { exec_int($2); }
          | TOK_COMMAND_EXEC error end { exec_int(0x10); }
;
com_memdump:    TOK_COMMAND_MEMDUMP val val end { dump_mem($2,$3); }
              | TOK_COMMAND_MEMDUMP  error  end { printf("memdump start len\n"); }

    
;
com_memset:     TOK_COMMAND_MEMSET val list end { do_list((struct mem*)$3,$2);}
              | TOK_COMMAND_MEMSET error end { printf("setmem addr [byte val] "
                                                   "[word val] [long val] "
                                                   "[\"string\"]\n"); }
;
list:                              { $$ = 0; } 
              | TOK_BYTE val list { rec.integer = $2;
          $$ = (unsigned long)add_to_list(BYTE,&rec,(void*)$3); }
              | TOK_WORD val list { rec.integer = $2; 
          $$ = (unsigned long) add_to_list(WORD,&rec,(void*)$3); }
              | TOK_LONG val list { rec.integer = $2; 
          $$ = (unsigned long) add_to_list(LONG,&rec,(void*)$3); }
              | TOK_STRING list { rec.ptr = (void*)$1; 
          $$ = (unsigned long) add_to_list(STRING,&rec,(void*)$2); }
;
val:            TOK_VAR  {  if ($1 > MAX_VAR) {
                             printf("variable index out of range\n");
                             $$=0;
                             } else 
                            $$ = var[$1]; } 
              | TOK_NUM  {  $$ = $1; }
              | register_read
; 
bool:           TOK_ON   {  $$ = 1; }
              | TOK_OFF  {  $$ = 0; }
;
config:         TOK_PRINT_PORT bool end { Config.PrintPort = $2; } 
              | TOK_PRINT_PORT '?' end  { printf("print port %s\n",
                                      Config.PrintPort?"on":"off"); }
          | TOK_PRINT_PORT error end { printf("pport on | off | ?\n") } 
              | TOK_PRINT_IRQ bool end  { Config.PrintIrq = $2; } 
              | TOK_PRINT_IRQ '?' end   { printf("print irq %s\n",  
                                          Config.PrintIrq?"on":"off"); } 
          | TOK_PRINT_IRQ error end { printf("pirq on | off | ?\n") } 
              | TOK_PPCI bool end       { Config.PrintPci = $2; } 
              | TOK_PPCI '?' end        { printf("print PCI %s\n",
                                          Config.PrintPci?"on":"off"); } 
          | TOK_PPCI error end      { printf("ppci on | off | ?\n") } 
              | TOK_PIP bool end        { Config.PrintIp = $2; } 
              | TOK_PIP '?' end         { printf("printip %s\n",
                                      Config.PrintIp?"on":"off"); } 
          | TOK_PIP error end       { printf("pip on | off | ?\n") } 
              | TOK_IOSTAT bool end     { Config.IoStatistics = $2; } 
              | TOK_IOSTAT '?' end      { printf("io statistics %s\n",
                                      Config.IoStatistics?"on":"off"); } 
          | TOK_IOSTAT error end    { printf("iostat on | off | ?\n") } 
              | TOK_TRACE bool end      { Config.Trace = $2; } 
              | TOK_TRACE '?' end       { printf("trace %s\n",
                                      Config.Trace ?"on":"off"); } 
          | TOK_TRACE error end { printf("trace on | off | ?\n") } 
;
verbose:        TOK_VERBOSE val end     { Config.Verbose = $2; }
          | TOK_VERBOSE '?' end     { printf("verbose: %i\n",
                            Config.Verbose); }
          | TOK_VERBOSE error end   { printf("verbose val | ?\n"); }
;
logging:        TOK_LOG TOK_STRING end  { logon(normalize_string((char*)$2)); }
          | TOK_LOG '?' end         { if (logging) printf("logfile: %s\n",
                            logfile);
                      else printf("no logging\n?"); }
          | TOK_LOG TOK_OFF end          { logoff(); }
          | TOK_LOG error end       { printf("log \"<filename>\" | ? |"
                         " off\n"); }
;
clstat:         TOK_CLSTAT end          { clear_stat(); }
          | TOK_CLSTAT error end    { printf("clstat\n"); } 
;
print:          TOK_STDOUT bool end     { nostdout = !$2; }
                  | TOK_STDOUT '?' end      { printf("print %s\n",nostdout ?
                        "no":"yes"); }