client/trunk/anago/anago.c

   1 #include <stdio.h>
   2 #include <stdbool.h>
   3 #include <stdlib.h> //atoi()
   4 #include "memory_manage.h"
   5 #include "type.h"
   6 #include "flash_device.h"
   7 #include "header.h"
   8 #include "reader_master.h"
   9 #include "reader_kazzo.h"
  10 //#include "reader_dummy.h"
  11 //#include "script_program.h"
  12 #include "script_dump.h"
  13
  14 #if 0
  15 static bool transtype_flash_set(char mode, struct memory *t)
  16 {
  17         switch(mode){
  18         case 't':
  19                 t->transtype = TRANSTYPE_TOP;
  20                 break;
  21         case 'e':
  22                 t->transtype = TRANSTYPE_EMPTY;
  23                 break;
  24         case 'b':
  25                 t->transtype = TRANSTYPE_BOTTOM;
  26                 break;
  27         case 'f':
  28                 t->transtype = TRANSTYPE_FULL;
  29                 break;
  30         default:
  31                 return false;
  32         }
  33         return true;
  34 }
  35 static bool transtype_set(const char *mode, struct romimage *t)
  36 {
  37         switch(mode[0]){
  38         case 'a': case 'f': case 'F':
  39                 if(mode[1] == '\0'){
  40                         t->cpu_rom.transtype = TRANSTYPE_FULL;
  41                         t->ppu_rom.transtype = TRANSTYPE_FULL;
  42                         return true;
  43                 }
  44                 if(transtype_flash_set(mode[1], &t->cpu_rom) == false){
  45                         return false;
  46                 }
  47                 if(mode[2] == '\0'){
  48                         t->ppu_rom.transtype = TRANSTYPE_FULL;
  49                         return true;
  50                 }
  51                 if(transtype_flash_set(mode[2], &t->ppu_rom) == false){
  52                         return false;
  53                 }
  54                 return true;
  55         }
  56         return false;
  57 }
  58 static bool config_parse(const char *romimage, const char *device_cpu, const char *device_ppu, struct config_flash *c)
  59 {
  60         c->target = romimage;
  61         if(nesfile_load(__FUNCTION__, romimage, &c->rom) == false){
  62                 return false;
  63         }
  64         c->rom.cpu_rom.offset = 0;
  65         c->rom.ppu_rom.offset = 0;
  66         if(flash_device_get(device_cpu, &c->flash_cpu) == false){
  67                 printf("unkown flash memory device %s\n", device_cpu);
  68                 return false;
  69         }
  70         if(flash_device_get(device_ppu, &c->flash_ppu) == false){
  71                 printf("unkown flash memory device %s\n", device_ppu);
  72                 return false;
  73         }
  74         if(c->flash_cpu.id_device == FLASH_ID_DEVICE_DUMMY){
  75                 c->rom.cpu_rom.transtype = TRANSTYPE_EMPTY;
  76         }else if(c->flash_cpu.capacity < c->rom.cpu_rom.size){
  77                 puts("cpu area ROM image size is larger than target device");
  78                 return false;
  79         }
  80         if(
  81                 (c->flash_ppu.id_device == FLASH_ID_DEVICE_DUMMY) ||
  82                 (c->rom.ppu_rom.size == 0)
  83         ){
  84                 c->rom.ppu_rom.transtype = TRANSTYPE_EMPTY;
  85         }else if(c->flash_ppu.capacity < c->rom.ppu_rom.size){
  86                 puts("ppu area ROM image size is larger than target device");
  87                 return false;
  88         }
  89         return true;
  90 }
  91 static void program(int c, char **v)
  92 {
  93         struct config_flash config;
  94         config.rom.cpu_rom.data = NULL;
  95         config.rom.ppu_rom.data = NULL;
  96         config.script = v[2];
  97         config.reader = &DRIVER_KAZZO;
  98         config.compare = false;
  99         config.testrun = false;
 100         switch(v[1][0]){
 101         case 'a':
 102                 config.reader = &DRIVER_DUMMY;
 103                 config.testrun = true;
 104                 break;
 105         case 'F':
 106                 config.compare = true;
 107                 break;
 108         }
 109         if(transtype_set(v[1], &config.rom) == false){
 110                 puts("mode argument error");
 111                 return;
 112         }
 113         switch(c){
 114         case 5: //mode script target cpu_flash_device
 115                 if(config_parse(v[3], v[4], "dummy", &config) == false){
 116                         nesbuffer_free(&config.rom, 0);
 117                         return;
 118                 }
 119                 break;
 120         case 6: //mode script target cpu_flash_device ppu_flash_device
 121                 if(config_parse(v[3], v[4], v[5], &config) == false){
 122                         nesbuffer_free(&config.rom, 0);
 123                         return;
 124                 }
 125                 break;
 126         default:
 127                 puts("mode script target cpu_flash_device ppu_flash_device");
 128                 return;
 129         }
 130         if(config.reader->open_or_close(READER_OPEN) == NG){
 131                 puts("reader open error");
 132                 nesbuffer_free(&config.rom, 0);
 133                 return;
 134         }
 135         config.reader->init();
 136         script_flash_execute(&config);
 137         nesbuffer_free(&config.rom, 0);
 138         config.reader->open_or_close(READER_CLOSE);
 139 }
 140 #endif
 141
 142 static void dump(int c, char **v)
 143 {
 144         struct dump_config config;
 145         if(c < 4){
 146                 puts("argument error");
 147                 return;
 148         }
 149         config.increase.cpu = 1;
 150         config.increase.ppu = 1;
 151         config.progress = true;
 152         switch(v[1][0]){
 153         case 'D':
 154                 config.progress = false;
 155                 break;
 156         }
 157         switch(v[1][1]){
 158         case '2':
 159                 config.increase.cpu = 2;
 160                 break;
 161         case '4':
 162                 config.increase.cpu = 4;
 163                 break;
 164         }
 165         if(v[1][1] != '\0'){
 166                 switch(v[1][2]){
 167                 case '2':
 168                         config.increase.ppu = 2;
 169                         break;
 170                 case '4':
 171                         config.increase.ppu = 4;
 172                         break;
 173                 }
 174         }
 175         config.script = v[2];
 176         config.target = v[3];
 177         config.reader = &DRIVER_KAZZO;
 178         config.mappernum = -1;
 179         if(c == 5){
 180                 config.mappernum = atoi(v[4]);
 181         }
 182         if(config.reader->open_or_close(READER_OPEN) == NG){
 183                 puts("reader open error");
 184                 return;
 185         }
 186         config.reader->init();
 187         script_dump_execute(&config);
 188         config.reader->open_or_close(READER_CLOSE);
 189 }
 190 static void usage(const char *v)
 191 {
 192         puts("famicom bus simluator 'anago'");
 193         printf("%s [mode] [script] [target] ....\n", v);
 194 }
 195 int main(int c, char **v)
 196 {
 197         mm_init();
 198         if(c >= 2){
 199                 switch(v[1][0]){
 200                 case 'a': case 'f': case 'F':
 201                         program(c, v);
 202                         break;
 203                 case 'd': case 'D':
 204                         dump(c,v);
 205                         break;
 206                 default:
 207                         usage(v[0]);
 208                         puts("mode are a, d, D, f, g");
 209                         break;
 210                 }
 211         }else{
 212                 usage(v[0]);
 213         }
 214         mm_end();
 215         return 0;
 216 }