view emu52/mem.lst @ 42:792da050d8c4 tip

more dox

C51 COMPILER V9.02   MEM                                                                   04/17/2014 15:17:34 PAGE 1   


C51 COMPILER V9.02, COMPILATION OF MODULE MEM
OBJECT MODULE PLACED IN mem.obj
COMPILER INVOKED BY: C:\Keil\C51\BIN\C51.EXE src\mem.c OMF2 BROWSE DEBUG PRINT(.\mem.lst) OBJECT(mem.obj)

line level    source

   1          /* mem.c
   2           * functions for accessing emulator memory */
   3          #include "mem.h"
   4          
   5          /* get flag value
   6           * if invalid flag is requested value is 0 */
   7          BYTE
   8          get_flag(BYTE flag) {
   9   1          if (flag > 7) {
  10   2              return 0;
  11   2          }
  12   1          else {
  13   2              return GBIT(flags, flag);
  14   2          }
  15   1      }
  16          
  17          /*  set flag to 0 if on == 0
  18           *  otherwise set flag to 1 */
  19          void
  20          set_flag(BYTE flag, BYTE on) {
  21   1          if (flag <= 7) {
  22   2              if (on == 0x00) {
  23   3                  flags = CBIT(flags, flag);
  24   3              }
  25   2              else {
  26   3                  flags = SBIT(flags, flag);
  27   3              }
  28   2          }
  29   1      }
  30          
  31          /* sets zero and parity flags based on content of byte */
  32          void
  33          set_zp(BYTE val){
  34   1          if (val == 0) {
  35   2              set_flag(Z, 1);
  36   2              set_flag(P, 0);
  37   2          }
  38   1          else {
  39   2              /* check parity
  40   2               * think of this as folding */
  41   2              val ^= val >> 4;
  42   2              val ^= val >> 2;
  43   2              val ^= val >> 1;
  44   2              val &= 1;
  45   2              if (val == 0) {
  46   3                  set_flag(P, 1);
  47   3              }
  48   2              else {
  49   3                  set_flag(P, 0);
  50   3              }
  51   2          }
  52   1      }
  53          
  54          WIDE
  55          get_wide(BYTE reg) {
C51 COMPILER V9.02   MEM                                                                   04/17/2014 15:17:34 PAGE 2   

  56   1          /* high, low */
  57   1          return MWIDE(regs[reg + 4], regs[reg + 12]);
  58   1      }
  59          
  60          void
  61          set_wide(BYTE reg, WIDE val) {
  62   1          regs[reg + 4] = GHIGH(val); /* high */
  63   1          regs[reg + 12] = GLOW(val); /* low */
  64   1      }
  65          
  66          void 
  67          inc_pc(BYTE n) {
  68   1          if ((regs[PCL] + n) > 0xFF) {
  69   2              regs[PCH]++;
  70   2          }
  71   1          regs[PCL] += n;
  72   1      }
  73          
  74          BYTE 
  75          fetch(void) {
  76   1          BYTE val = mem[get_wide(PC)];
  77   1          inc_pc(1);
  78   1          return val;
  79   1      }
  80          
  81          WIDE
  82          fetch_wide(void) {
  83   1          WIDE val = MWIDE(mem[get_wide(PC)], mem[get_wide(PC) + 1]);
  84   1          inc_pc(2);
  85   1          return val;
  86   1      }
  87          
  88          /* 0b000 = R0
  89           * 0b001 = R1
  90           * 0b010 = R2
  91           * 0b011 = R3
  92           * 0b100 = DPH
  93           * 0b101 = DPL
  94           * 0b110 = SPH
  95           * 0b111 = SPL */
  96          BYTE 
  97          get_reg(BYTE reg) {
  98   1          if (reg < 4) {
  99   2              return regs[reg | (get_flag(BS) << 3)];
 100   2          }
 101   1          else {
 102   2              switch (reg) {
 103   3                  
 104   3                  case 4:
 105   3                      return regs[DPH];
 106   3                  case 5:
 107   3                      return regs[DPL];
 108   3                  case 6:
 109   3                      return regs[SPH];
 110   3                  case 7:
 111   3                      return regs[SPL];
 112   3                  default:
 113   3                      return 0;
 114   3              }
 115   2          }
 116   1      }
 117          
C51 COMPILER V9.02   MEM                                                                   04/17/2014 15:17:34 PAGE 3   

 118          void
 119          set_reg(BYTE reg, BYTE val) {
 120   1          if (reg < 4) {
 121   2              regs[reg | (get_flag(BS) << 3)] = val;
 122   2          }
 123   1          else {
 124   2              switch (reg) {
 125   3                  
 126   3                  case 4:
 127   3                      regs[DPH] = val;
 128   3                      break;
 129   3                  case 5:
 130   3                      regs[DPL] = val;
 131   3                      break;
 132   3                  case 6:
 133   3                      regs[SPH] = val;
 134   3                      break;
 135   3                  case 7:
 136   3                      regs[SPL] = val;
 137   3                      break;
 138   3                  default:
 139   3                      break;
 140   3              }
 141   2          }
 142   1      }


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    369    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
   EDATA SIZE       =   ----    ----
   HDATA SIZE       =   ----    ----
   XDATA CONST SIZE =   ----    ----
   FAR CONST SIZE   =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)