client/tag/0.6.1/anago/anago.c

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