定数展開の仕様を変更, ROM の前詰め、後詰めを設定可能

git-svn-id: svn+ssh://svn.osdn.net/svnroot/unagi@273 24ea1065-a21e-4ca1-99c9-f5125deb0858

diff --git a/client/trunk/config.h b/client/trunk/config.h
index a987f91..a6123b2 100644 (file)
--- a/client/trunk/config.h
+++ b/client/trunk/config.h
@@ -18,6 +18,7 @@ struct st_config{
        const struct flash_driver *cpu_flash_driver, *ppu_flash_driver;
        //data mode
        int mode, syntaxtest;
+       long transtype_cpu, transtype_ppu;
        //debug member
        long write_wait;
        char flash_test_device[CONFIG_STR_LENGTH];

diff --git a/client/trunk/header.c b/client/trunk/header.c
index 2f93362..3b2b354 100644 (file)
--- a/client/trunk/header.c
+++ b/client/trunk/header.c
@@ -167,26 +167,6 @@ void backupram_create(const struct memory *r, const char *ramfilename)
        buf_save(r->data, ramfilename, r->size);
 }
 
-static int nesfile_size_check(const char *errorprefix, const struct memory *m, long size)
-{
-       if(size < m->size){
-               while(size == m->size){
-                       if(size < 0){
-                               printf("%s NES header %s romsize alignment error\n", errorprefix, m->name);
-                               return NG;
-                       }
-                       size -= m->size;
-               }
-               return NG;
-       }
-       //
-       else if(size > m->size){
-               printf("%s NES header cpuromsize too large\n", errorprefix);
-               return NG;
-       }
-       return OK;
-}
-
 /*
 memory size ¤Ï 2¾è¤µ¤ì¤Æ¤¤¤¯Ãͤ¬Àµ¾ïÃÍ.
 ¤¿¤À¤·¡¢region ¤ÎºÇ¾®Ãͤè¤ê¾®¤µ¤¤¾ì¹ç¤Ï test ÍѤȤ·¤ÆÀµ¾ï¤Ë¤¹¤ë
@@ -279,20 +259,10 @@ int nesfile_load(const char *errorprefix, const char *file, struct romimage *r)
                cpusize = ((long) buf[4]) * PROGRAM_ROM_MIN;
                offset += cpusize;
                r->cpu_rom.size = cpusize;
-               /*if(nesfile_size_check(errorprefix, &r->cpu_rom, cpusize) == NG){
-                       free(buf);
-                       return NG;
-               }*/
                //PPU
                ppusize = ((long) buf[5]) * CHARCTER_ROM_MIN;
                offset += ppusize;
                r->ppu_rom.size = ppusize;
-               if(0 && ppusize != 0){
-                       if(nesfile_size_check(errorprefix, &r->ppu_rom, ppusize) == NG){
-                               free(buf);
-                               return NG;
-                       }
-               }
                //NESfilesize
                if(offset != imagesize){
                        printf("%s NES header filesize error\n", errorprefix);

diff --git a/client/trunk/header.h b/client/trunk/header.h
index f2c198f..493fa22 100644 (file)
--- a/client/trunk/header.h
+++ b/client/trunk/header.h
@@ -4,6 +4,7 @@
 struct memory{
        const char *name;
        int size, offset, attribute;
+       long transtype;
        u8 *data;
 };
 /*
@@ -41,7 +42,12 @@ enum{
        MEMORY_AREA_CPU_RAM, MEMORY_AREA_CPU_ROM, MEMORY_AREA_PPU,
        MEMORY_ATTR_READ, MEMORY_ATTR_WRITE, MEMORY_ATTR_NOTUSE
 };
-
+enum{
+       TRANSTYPE_EMPTY,
+       TRANSTYPE_TOP,
+       TRANSTYPE_BOTTOM,
+       TRANSTYPE_FULL,
+};
 #ifdef HEADEROUT
 void nesheader_set(const struct romimage *r, u8 *header);
 #endif

diff --git a/client/trunk/script.c b/client/trunk/script.c
index d04aee7..c783f53 100644 (file)
--- a/client/trunk/script.c
+++ b/client/trunk/script.c
@@ -71,27 +71,6 @@ static const struct variable_manage VARIABLE_INIT = {
 };
 static struct variable_manage variable_bank[VARIABLE_MAX];
 static int variable_num = 0;
-/*
-CPU_ROMSIZE, PPU_ROMSIZE ¦¤ÇÄêµÁ¤µ¤ì¤ëÄê¿ô̾¤Ï¤½¤ì¤¾¤ì C, P
-*/
-enum{
-       STEP_CONST_CPUAREA = 'C',
-       STEP_CONST_PPUAREA = 'P',
-       STEP_CONST_UNDEF = 0x4649
-};
-static long step_const_cpuarea = STEP_CONST_UNDEF;
-static long step_const_ppuarea = STEP_CONST_UNDEF;
-
-static long constant_get(char v)
-{
-       switch(v){
-       case STEP_CONST_CPUAREA:
-               return step_const_cpuarea;
-       case STEP_CONST_PPUAREA:
-               return step_const_ppuarea;
-       }
-       return STEP_CONST_UNDEF;
-}
 
 static void variable_init_single(int num)
 {
@@ -248,6 +227,20 @@ static int syntax_check_expression(char **word, int word_num, struct st_expressi
        return OK;
 }
 
+static int strto_enum(const char **t, const char *word, int start, long *val)
+{
+       long i = start;
+       while(*t != NULL){
+               if(strcmp(*t, word) == 0){
+                       *val = i;
+                       return OK;
+               }
+               i++;
+               t++;
+       }
+       return NG;
+}
+
 static const char SYNTAX_ERROR_PREFIX[] = "syntax error:";
 
 /*
@@ -338,17 +331,21 @@ static int syntax_check_phase(char **word, int word_num, struct script *s, const
                                        }
                                        }break;
                                case SYNTAX_ARGVTYPE_CONSTANT:{
-                                       const char v = word[j][0];
                                        if(value_get(word[j], &(s->value[j])) == OK){
                                                break;
-                                       }else if(v == STEP_CONST_CPUAREA || v == STEP_CONST_PPUAREA){
-                                               s->value[j] = VALUE_CONSTANT;
-                                               s->constant = v;
+                                       }else if(strto_enum(STR_CONSTANTNAME, word[j], VALUE_CONTANT_CPU_STEP_START, &(s->value[j])) == OK){
+                                               break;
                                        }else{
                                                printf("%d:%s constant error %s %s\n", s->line, SYNTAX_ERROR_PREFIX, opword, word[j]);
                                                return 1;
                                        }
                                        }break;
+                               case SYNTAX_ARGVTYPE_TRANSTYPE:{
+                                       if(strto_enum(STR_TRANSTYPE, word[j], VALUE_TRANSTYPE_EMPTY, &(s->value[j])) == NG){
+                                               printf("%d:%s unknown trans type %s\n", s->line, SYNTAX_ERROR_PREFIX, word[j]);
+                                               return 1;
+                                       }
+                                       }break;
                                default:
                                        s->value[j] = VALUE_UNDEF;
                                        break;
@@ -393,21 +390,22 @@ logical_check() 
 static const char LOGICAL_ERROR_PREFIX[] = "logical error:";
 enum{
        SCRIPT_PPUSIZE_0 = 0,
-       SCRIPT_MEMORYSIZE = 4,
+       SCRIPT_MEMORYSIZE = 10,
 };
 struct logical_romsize{
-       const struct script *data[SCRIPT_MEMORYSIZE];
+       const struct script *data[SCRIPT_MEMORYSIZE], *constant;
        int count;
 };
-static int logical_romsize_set(int region, long size, struct logical_romsize *l, const struct script *s)
+static int logical_flashsize_set(int region, struct logical_romsize *l, const struct script *s)
 {
        //PPU Íѥǡ¼¥¿¤Î 0 ¤Ï size 0, Äê¿ô 0 ¤È¤·¤ÆͽÌ󤵤ì¤Æ¤ª¤ê¡¢0¤Î¾ì¹ç¤Ï¤³¤³¤ò¾å½ñ¤­¤¹¤ë
-       if((region == MEMORY_AREA_PPU) && (size == 0)){
+       if((region == MEMORY_AREA_PPU) && (s->value[0] == 0)){
                l->data[SCRIPT_PPUSIZE_0] = s;
                return OK;
        }
        if(l->count >= SCRIPT_MEMORYSIZE){
                const char *opstr;
+               opstr = OPSTR_CPU_ROMSIZE; //warning Âкö
                switch(region){
                case MEMORY_AREA_CPU_ROM:
                        opstr = OPSTR_CPU_ROMSIZE;
@@ -426,18 +424,41 @@ static int logical_romsize_set(int region, long size, struct logical_romsize *l,
        return OK;
 }
 
-static long logical_romsize_get(long size, const struct logical_romsize *l)
+static int logical_flashsize_get(long transtype, long size, struct logical_romsize *l)
 {
        int i;
        for(i = 0; i < l->count; i++){
                const struct script *s;
                s = l->data[i];
-               if(s->value[0] == size){
-                       return s->value[1];
+               if((s->value[0] == size) && (
+                       (s->value[1] == transtype) || 
+                       (s->value[1] == VALUE_TRANSTYPE_FULL)
+               )){
+                       l->constant = s;
+                       return OK;
+               }else if((s->value[0] == size) && (s->value[1] == VALUE_TRANSTYPE_EMPTY)){
+                       l->constant = s;
+                       return OK;
                }
        }
-       printf("%s romsize error\n", LOGICAL_ERROR_PREFIX);
-       return STEP_CONST_UNDEF;
+       printf("%s flashsize not found\n", LOGICAL_ERROR_PREFIX);
+       return NG;
+}
+
+static long constant_get(long val, const struct script *cpu, const struct script *ppu)
+{
+       switch(val){
+       case VALUE_CONTANT_CPU_STEP_START:
+               return cpu->value[2];
+       case VALUE_CONTANT_CPU_STEP_END:
+               return cpu->value[3];
+       case VALUE_CONTANT_PPU_STEP_START:
+               return ppu->value[2];
+       case VALUE_CONTANT_PPU_STEP_END:
+               return ppu->value[3];
+       }
+       assert(0);
+       return -1;
 }
 
 static void logical_print_capacityerror(int line, const char *area)
@@ -582,9 +603,8 @@ enum{
 static const struct script SCRIPT_PPU_ROMSIZE_0 = {
        .opcode = SCRIPT_OPCODE_PPU_ROMSIZE,
        .line = -1,
-       .value = {0, 0, 0, 0},
+       .value = {0, VALUE_TRANSTYPE_EMPTY, 0, 0},
        //.expression, .variable ̤ÄêµÁ
-       .constant = 0
 };
 
 static int logical_check(const struct script *s, const struct st_config *c, struct romimage *r)
@@ -596,14 +616,15 @@ static int logical_check(const struct script *s, const struct st_config *c, stru
        int imagesize = 0; //for write or program mode
        int status = SETTING;
        //override (CPU|PPU)_ROMSIZE pointer. Program mode only
-       struct logical_romsize script_cpu_romsize = {
-               .data = {NULL, NULL, NULL, NULL},
+       struct logical_romsize script_cpu_flashsize = {
+               .constant = NULL,
                .count = 0
        };
-       struct logical_romsize script_ppu_romsize = {
-               .data = {&SCRIPT_PPU_ROMSIZE_0, NULL, NULL, NULL},
+       struct logical_romsize script_ppu_flashsize = {
+               .constant = NULL,
                .count = 1
        };
+       script_ppu_flashsize.data[0] = &SCRIPT_PPU_ROMSIZE_0;
        //logical error count. Ìá¤êÃÍ
        int error = 0;
        
@@ -639,15 +660,22 @@ static int logical_check(const struct script *s, const struct st_config *c, stru
                                if(nesfile_load(LOGICAL_ERROR_PREFIX, c->romimage, r)== NG){
                                        error += 1;
                                }
-                               step_const_cpuarea = logical_romsize_get(r->cpu_rom.size, &script_cpu_romsize);
                                //Äê¿ôÀë¸À¥¨¥é¡¼¤Ï̵¸Â¥ë¡¼¥×¤Î²ÄǽÀ­¤¬¤¢¤ë¤Î¤Ç¥¹¥¯¥ê¥×¥ÈÆâÉô¥Á¥§¥Ã¥¯¤ò¤»¤º¤Ë»ß¤á¤ë
-                               if(step_const_cpuarea == STEP_CONST_UNDEF){
+                               if(logical_flashsize_get(c->transtype_cpu, r->cpu_rom.size, &script_cpu_flashsize) == NG){
                                        return error + 1;
                                }
-                               step_const_ppuarea = logical_romsize_get(r->ppu_rom.size, &script_ppu_romsize);
-                               if(step_const_ppuarea == STEP_CONST_UNDEF){
+                               if(logical_flashsize_get(c->transtype_ppu, r->ppu_rom.size, &script_ppu_flashsize) == NG){
                                        return error + 1;
                                }
+                               //flash memory capacity check
+                               if(r->cpu_rom.size > c->cpu_flash_driver->capacity){
+                                       logical_print_capacityerror(s->line, r->cpu_rom.name);
+                                       error += 1;
+                               }
+                               if((r->ppu_rom.size != 0) && (r->ppu_rom.size > c->ppu_flash_driver->capacity)){
+                                       logical_print_capacityerror(s->line, r->ppu_rom.name);
+                                       error += 1;
+                               }
                                imagesize = -1;
                                break;
                        default: 
@@ -667,22 +695,15 @@ static int logical_check(const struct script *s, const struct st_config *c, stru
                        break;
                case SCRIPT_OPCODE_CPU_ROMSIZE:{
                        const long size = s->value[0];
-                       if(c->mode == MODE_ROM_PROGRAM){
-                               if(logical_romsize_set(MEMORY_AREA_CPU_ROM, size, &script_cpu_romsize, s) == NG){
-                                       error += 1;
-                               }
-                       }else{
-                               r->cpu_rom.size = size;
-                       }
+                       r->cpu_rom.size = size;
                        if(memorysize_check(size, MEMORY_AREA_CPU_ROM)){
                                printf("%s %s length error\n", LOGICAL_ERROR_PREFIX, OPSTR_CPU_ROMSIZE);
                                error += 1;
                        }
-                       //flash memory capacity check
-                       else if((c->mode == MODE_ROM_PROGRAM) && (size > c->cpu_flash_driver->capacity)){
-                               logical_print_capacityerror(s->line, r->cpu_rom.name);
+                       }break;
+               case SCRIPT_OPCODE_CPU_FLASHSIZE:
+                       if(logical_flashsize_set(MEMORY_AREA_CPU_ROM, &script_cpu_flashsize, s) == NG){
                                error += 1;
-                       }
                        }break;
                case SCRIPT_OPCODE_CPU_RAMSIZE:
                        //memory size ¤Ï̤³ÎÄêÍ×ÁǤ¬Â¿¤¤¤Î¤Ç check ¤òÈ´¤¯
@@ -695,22 +716,16 @@ static int logical_check(const struct script *s, const struct st_config *c, stru
                        break;
                case SCRIPT_OPCODE_PPU_ROMSIZE:{
                        const long size = s->value[0];
-                       if(c->mode == MODE_ROM_PROGRAM){
-                               if(logical_romsize_set(MEMORY_AREA_PPU, size, &script_ppu_romsize, s) == NG){
-                                       error += 1;
-                               }
-                       }else{
-                               r->ppu_rom.size = size;
-                       }
+                       r->ppu_rom.size = size;
                        if(memorysize_check(size, MEMORY_AREA_PPU)){
                                printf("%s %s length error\n", LOGICAL_ERROR_PREFIX, OPSTR_PPU_ROMSIZE);
                                error += 1;
                        }
-                       else if((c->mode == MODE_ROM_PROGRAM) && (size > c->ppu_flash_driver->capacity)){
-                               logical_print_capacityerror(s->line, r->ppu_rom.name);
+                       }break;
+               case SCRIPT_OPCODE_PPU_FLASHSIZE:
+                       if(logical_flashsize_set(MEMORY_AREA_PPU, &script_ppu_flashsize, s) == NG){
                                error += 1;
                        }
-                       }
                        break;
                case SCRIPT_OPCODE_PPU_COMMAND:
                        if(command_mask(MEMORY_AREA_PPU, s->value[0], s->value[1], s->value[2], &(r->ppu_flash)) == NG){
@@ -897,37 +912,37 @@ static int logical_check(const struct script *s, const struct st_config *c, stru
                        }
                        break;
                case SCRIPT_OPCODE_STEP_START:{
-                       const struct {
+                       const struct step_syntax{
                                long start, end;
                                int constant;
+                               const char *name;
                        } RANGE[STEP_NUM] = {
-                               {.start = 0, .end = 0, .constant = NG},
-                               {.start = 0, .end = 0xff, .constant = OK},
-                               {.start = 0, .end = 0x100, .constant = OK},
-                               {.start = 1, .end = 0x100, .constant = NG}
+                               {.start = 0, .end = 0, .constant = NG, .name = "variable"},
+                               {.start = 0, .end = 0xff, .constant = OK, .name = "start"},
+                               {.start = 0, .end = 0x100, .constant = OK, .name = "end"},
+                               {.start = 1, .end = 0x100, .constant = NG, .name = "next"}
                        };
-                       const char *NAME[STEP_NUM] = {
-                               "variable", "start", "end", "next"
-                       };
-                       long val[STEP_NUM];
                        int i;
                        for(i = STEP_START; i < STEP_NUM; i++){
-                               long v = s->value[i];
-                               if((RANGE[i].constant == OK) && (v == VALUE_CONSTANT)){
-                                       v = constant_get(s->constant);
+                               const struct step_syntax *ss;
+                               ss = &RANGE[i];
+                               //Äê¿ôobject ¤ò¼Â¿ô¤ËÊÑ´¹¤¹¤ë¤¿¤á¡¢const ¤ò³°¤·¤Æ½ñ¤­´¹¤¨¤ë
+                               long *v;
+                               v = (long *) &s->value[i];
+                               if((ss->constant == OK) && (is_range(*v, VALUE_CONTANT_CPU_STEP_START, VALUE_CONTANT_PPU_STEP_END))){
+                                       *v = constant_get(*v, script_cpu_flashsize.constant, script_ppu_flashsize.constant);
                                }
-                               if(!is_range(v, RANGE[i].start, RANGE[i].end)){
-                                       printf("%d:%s step %s must %d-0x%x 0x%x\n", s->line, NAME[i], LOGICAL_ERROR_PREFIX, (int) RANGE[i].start, (int) RANGE[i].end, (int) v);
+                               if(!is_range(*v, ss->start, ss->end)){
+                                       printf("%d:%s step %s must %d-0x%x 0x%x\n", s->line, ss->name, LOGICAL_ERROR_PREFIX, (int) ss->start, (int) ss->end, (int) *v);
                                        error += 1;
                                }
-                               val[i] = v;
                        }
                        //PPU RAM ¤ÎÍÍ¤Ë step ÆâÉô¤ò¹Ô¤ï¤Ê¤¤¾ì¹ç¤Îscript¾õÂÖ¤ÎÊѹ¹
-                       if(val[STEP_START] >= val[STEP_END]){
+                       if(s->value[STEP_START] >= s->value[STEP_END]){
                                status = STEP_THOUGH;
                        }
                        //¥ë¡¼¥×¤ÎÌá¤êÀè¤Ï¤³¤ÎÌ¿Îá¤Î¼¡¤Ê¤Î¤Ç s[1]
-                       else if(step_new(s->variable, val[STEP_START], val[STEP_END], val[STEP_NEXT], &s[1]) == NG){
+                       else if(step_new(s->variable, s->value[STEP_START], s->value[STEP_END], s->value[STEP_NEXT], &s[1]) == NG){
                                printf("%d:%s step loop too much\n", s->line, LOGICAL_ERROR_PREFIX);
                                error += 1;
                                return error;
@@ -1175,12 +1190,10 @@ static void read_result_print(const struct memory *m, long length)
        fflush(stdout);
 }
 
-static void execute_program_begin(const struct memory *m)
+static void execute_program_begin(const struct memory *m, const long length)
 {
-       if(0){ //DEBUG==1){
-               return;
-       }
-       printf("writing %s area 0x%06x ... ", m->name, m->offset);
+       int tail = m->offset + (int) length - 1;
+       printf("writing %s area 0x%06x-0x%06x ... ", m->name, m->offset, tail);
        fflush(stdout);
 }
 
@@ -1315,7 +1328,7 @@ static int execute(const struct script *s, const struct st_config *c, struct rom
                        }
                        const long address = s->value[0];
                        const long length = s->value[1];
-                       execute_program_begin(&cpu_rom);
+                       execute_program_begin(&cpu_rom, length);
                        c->cpu_flash_driver->write(
                                &(r->cpu_flash),
                                address, length,
@@ -1389,7 +1402,7 @@ static int execute(const struct script *s, const struct st_config *c, struct rom
                        }
                        const long address = s->value[0];
                        const long length = s->value[1];
-                       execute_program_begin(&ppu_rom);
+                       execute_program_begin(&ppu_rom, length);
                        c->ppu_flash_driver->write(
                                &(r->ppu_flash),
                                address, length,
@@ -1407,21 +1420,11 @@ static int execute(const struct script *s, const struct st_config *c, struct rom
                        }
                        break;
                case SCRIPT_OPCODE_STEP_START:{
-                       long val[STEP_NUM];
-                       int i;
-                       //start ¤È end ¤ÎÄê¿ôŸ³«¤ò¹Ô¤¦
-                       for(i=STEP_START; i<STEP_NEXT; i++){
-                               val[i] = s->value[i];
-                               if(val[i] == VALUE_CONSTANT){
-                                       val[i] = constant_get(s->constant);
-                               }
-                       }
-                       
-                       if(val[STEP_START] >= val[STEP_END]){
+                       if(s->value[STEP_START] >= s->value[STEP_END]){
                                status = STEP_THOUGH;
                        }else{
                                //¥ë¡¼¥×¤ÎÌá¤êÀè¤Ï¤³¤ÎÌ¿Îá¤Î¼¡¤Ê¤Î¤Ç &s[1]
-                               step_new(s->variable, val[STEP_START], val[STEP_END], s->value[STEP_NEXT], &s[1]);
+                               step_new(s->variable, s->value[STEP_START], s->value[STEP_END], s->value[STEP_NEXT], &s[1]);
                        }
                        }break;
                case SCRIPT_OPCODE_DUMP_END:

diff --git a/client/trunk/script.h b/client/trunk/script.h
index afe04fe..2568a77 100644 (file)
--- a/client/trunk/script.h
+++ b/client/trunk/script.h
@@ -19,13 +19,20 @@ struct script{
        int line;
        long value[4];
        struct st_expression expression;
-       char variable, constant;
+       char variable;
 };
 
 enum{
        VALUE_EXPRESSION = 0x1000000,
        VALUE_VARIABLE,
-       VALUE_CONSTANT,
+       VALUE_CONTANT_CPU_STEP_START,
+       VALUE_CONTANT_CPU_STEP_END,
+       VALUE_CONTANT_PPU_STEP_START,
+       VALUE_CONTANT_PPU_STEP_END,
+       VALUE_TRANSTYPE_EMPTY,
+       VALUE_TRANSTYPE_TOP,
+       VALUE_TRANSTYPE_BOTTOM,
+       VALUE_TRANSTYPE_FULL,
        VALUE_UNDEF
 };
 enum{

diff --git a/client/trunk/syntax.h b/client/trunk/syntax.h
index 0e22ddf..047952b 100644 (file)
--- a/client/trunk/syntax.h
+++ b/client/trunk/syntax.h
@@ -12,7 +12,8 @@ enum{
        SYNTAX_ARGVTYPE_HV,
        SYNTAX_ARGVTYPE_EXPRESSION,
        SYNTAX_ARGVTYPE_VARIABLE,
-       SYNTAX_ARGVTYPE_CONSTANT
+       SYNTAX_ARGVTYPE_CONSTANT,
+       SYNTAX_ARGVTYPE_TRANSTYPE
 };
 enum{
        SYNTAX_COMPARE_EQ,
@@ -26,7 +27,9 @@ enum{
        SCRIPT_OPCODE_MIRROR,
        SCRIPT_OPCODE_CPU_ROMSIZE,
        SCRIPT_OPCODE_CPU_RAMSIZE,
+       SCRIPT_OPCODE_CPU_FLASHSIZE,
        SCRIPT_OPCODE_PPU_ROMSIZE,
+       SCRIPT_OPCODE_PPU_FLASHSIZE,
        SCRIPT_OPCODE_DUMP_START,
        SCRIPT_OPCODE_CPU_COMMAND,
        SCRIPT_OPCODE_CPU_READ,
@@ -55,7 +58,9 @@ enum{
 };
 static const char OPSTR_CPU_ROMSIZE[] = "CPU_ROMSIZE";
 static const char OPSTR_CPU_RAMSIZE[] = "CPU_RAMSIZE";
+static const char OPSTR_CPU_FLASHSIZE[] = "CPU_FLASHSIZE";
 static const char OPSTR_PPU_ROMSIZE[] = "PPU_ROMSIZE";
+static const char OPSTR_PPU_FLASHSIZE[] = "PPU_FLASHSIZE";
 static const char OPSTR_CPU_RAMRW[] = "CPU_RAMRW";
 static const int ARGV_TYPE_VALUE_ONLY[SYNTAX_ARGV_TYPE_NUM] = {
        SYNTAX_ARGVTYPE_VALUE, SYNTAX_ARGVTYPE_NULL,
@@ -85,6 +90,10 @@ static const int ARGV_TYPE_ADDRESS_COMMAND[SYNTAX_ARGV_TYPE_NUM] = {
        SYNTAX_ARGVTYPE_VALUE, SYNTAX_ARGVTYPE_VALUE,
        SYNTAX_ARGVTYPE_VALUE, SYNTAX_ARGVTYPE_NULL
 };
+static const int ARGV_TYPE_FLASHSIZE[SYNTAX_ARGV_TYPE_NUM] = {
+       SYNTAX_ARGVTYPE_VALUE, SYNTAX_ARGVTYPE_TRANSTYPE,
+       SYNTAX_ARGVTYPE_VALUE, SYNTAX_ARGVTYPE_VALUE
+};
 static const struct script_syntax SCRIPT_SYNTAX[] = {
        {
                name: "MAPPER",
@@ -101,9 +110,9 @@ static const struct script_syntax SCRIPT_SYNTAX[] = {
        },{
                name: OPSTR_CPU_ROMSIZE,
                script_opcode: SCRIPT_OPCODE_CPU_ROMSIZE,
-               permittion: PERMITTION_ROM_DUMP | PERMITTION_ROM_PROGRAM,
-               argc: 1, compare: SYNTAX_COMPARE_GT,
-               argv_type: ARGV_TYPE_ADDRESS_LENGTH
+               permittion: PERMITTION_ROM_DUMP,
+               argc: 1, compare: SYNTAX_COMPARE_EQ,
+               argv_type: ARGV_TYPE_VALUE_ONLY
        },{
                name: OPSTR_CPU_RAMSIZE,
                script_opcode: SCRIPT_OPCODE_CPU_RAMSIZE,
@@ -111,11 +120,23 @@ static const struct script_syntax SCRIPT_SYNTAX[] = {
                argc: 1, compare: SYNTAX_COMPARE_EQ,
                argv_type: ARGV_TYPE_VALUE_ONLY
        },{
+               name: OPSTR_CPU_FLASHSIZE,
+               script_opcode: SCRIPT_OPCODE_CPU_FLASHSIZE,
+               permittion: PERMITTION_ROM_PROGRAM,
+               argc: 4, compare: SYNTAX_COMPARE_EQ,
+               argv_type: ARGV_TYPE_FLASHSIZE
+       },{
                name: OPSTR_PPU_ROMSIZE,
                script_opcode: SCRIPT_OPCODE_PPU_ROMSIZE,
-               permittion: PERMITTION_ROM_DUMP | PERMITTION_ROM_PROGRAM,
-               argc: 1, compare: SYNTAX_COMPARE_GT,
-               argv_type: ARGV_TYPE_ADDRESS_LENGTH
+               permittion: PERMITTION_ROM_DUMP,
+               argc: 1, compare: SYNTAX_COMPARE_EQ,
+               argv_type: ARGV_TYPE_VALUE_ONLY
+       },{
+               name: OPSTR_PPU_FLASHSIZE,
+               script_opcode: SCRIPT_OPCODE_PPU_FLASHSIZE,
+               permittion: PERMITTION_ROM_PROGRAM,
+               argc: 4, compare: SYNTAX_COMPARE_EQ,
+               argv_type: ARGV_TYPE_FLASHSIZE
        },{
                name: "CPU_COMMAND",
                script_opcode: SCRIPT_OPCODE_CPU_COMMAND,
@@ -224,3 +245,11 @@ static const struct script_syntax SCRIPT_SYNTAX[] = {
        }
 };
 
+static const char *STR_TRANSTYPE[] = {
+       "EMPTY", "TOP", "BOTTOM", "FULL", NULL
+};
+
+static const char *STR_CONSTANTNAME[] = {
+       "C_START", "C_END",
+       "P_START", "P_END", NULL
+};

diff --git a/client/trunk/unagi.c b/client/trunk/unagi.c
index 4a964bf..763ffd7 100644 (file)
--- a/client/trunk/unagi.c
+++ b/client/trunk/unagi.c
@@ -196,6 +196,37 @@ static int config_init(const int argc, const char **argv, struct st_config *c)
        case 'f':
                c->mode = MODE_ROM_PROGRAM;
                c->romimage = argv[ARGC_PROGRAM_IN_NESFILE];
+               //ÍÆÎ̤¬¾¯¤Ê¤¤ ROM ¤ÎµÍ¤áÊý¤Î¥«¥¹¥¿¥Þ¥¤¥º
+               switch(argv[ARGC_MODE][1]){
+               case '\0':
+                       c->transtype_cpu = VALUE_TRANSTYPE_TOP;
+                       c->transtype_ppu = VALUE_TRANSTYPE_TOP;
+                       break;
+               case 't':
+                       c->transtype_cpu = VALUE_TRANSTYPE_TOP;
+                       break;
+               case 'b':
+                       c->transtype_cpu = VALUE_TRANSTYPE_BOTTOM;
+                       break;
+               default:
+                       printf("%s unkown flash trans mode cpu %c\n", PREFIX_CONFIG_ERROR, argv[ARGC_MODE][1]);
+                       return NG;
+               }
+               if(argv[ARGC_MODE][1] == '\0'){
+                       break;
+               }
+               switch(argv[ARGC_MODE][2]){
+               case '\0':
+               case 't':
+                       c->transtype_ppu = VALUE_TRANSTYPE_TOP;
+                       break;
+               case 'b':
+                       c->transtype_ppu = VALUE_TRANSTYPE_BOTTOM;
+                       break;
+               default:
+                       printf("%s unkown flash trans mode ppu %c\n", PREFIX_CONFIG_ERROR, argv[ARGC_MODE][2]);
+                       return NG;
+               }
                break;
        case 't':
                if(DEBUG == 1){

diff --git a/client/trunk/version.h b/client/trunk/version.h
index b6a71ec..c043ea2 100644 (file)
--- a/client/trunk/version.h
+++ b/client/trunk/version.h
@@ -1,5 +1,5 @@
 //include from unagi.c only
-static const char STR_VERSION[] = "0.5.3 "
+static const char STR_VERSION[] = "0.5.4 "
 #if DEBUG==1
 "debug "
 #else