Diff: BaseEmuISP.cpp

Revision:

2:e3c085ac77f1

Parent:

1:4ff199bddbc1

Child:

3:ccc673a10485

diff -r 4ff199bddbc1 -r e3c085ac77f1 BaseEmuISP.cpp
--- a/BaseEmuISP.cpp	Tue Mar 08 12:03:48 2016 +0900
+++ b/BaseEmuISP.cpp	Sat Mar 12 09:34:38 2016 +0900
@@ -1,4 +1,4 @@
-// BaseEmuISP.cpp 2016/3/7
+// BaseEmuISP.cpp 2016/3/10
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -10,7 +10,7 @@
 }
 
 void BaseEmuISP::Poll() {
-    int prev_mode = mode;
+    Mode_t prev_mode = mode;
     int result;
     int c;
     char buf[32];
@@ -57,10 +57,21 @@
             }
             break;
         case M_CMD_J:
-            snprintf(buf, sizeof(buf), "%d", Part());
+            snprintf(buf, sizeof(buf), "%d", PartID());
             putln(buf);
             mode = M_CMD;
             break;
+        case M_CMD_K:
+            putln("0");
+            putln("0");
+            mode = M_CMD;
+            break;
+        case M_CMD_N:
+            mode = M_CMD;
+            break;
+        case M_CMD_S:
+            mode = M_CMD;
+            break;
     }
     if (prev_mode != mode) {
         seq = 0;
@@ -110,101 +121,180 @@
     return param.size();
 }
 
-int BaseEmuISP::cmd(const char *str) {
+ReturnCode_t BaseEmuISP::cmd(const char *str) {
     char buf[strlen(str) + 1];
     strcpy(buf, str);
     std::vector<char*> p;
-    int arg = split(p, buf);
-    if (arg == 0) {
+    if (split(p, buf) == 0) {
         return INVALID_COMMAND;
     }
-    std::vector<int> param;
+    vint_t param;
     param.push_back(p[0][0]);
-    for(int i = 1; i < p.size(); i++) {
-        param.push_back(atoi(p[i]));    
+    for(size_t i = 1; i < p.size(); i++) {
+        param.push_back(atoi(p[i]));
     }
     switch(param[0]) {
-        case 'U': return cmd_u(arg, param[1]);
-        case 'A': return cmd_a(arg, param[1]);
-        case 'W': return cmd_w(arg, param[1], param[2]);
-        case 'R': return cmd_r(arg, param[1], param[2]);
-        case 'P': return cmd_p(arg, param[1], param[2]);
-        case 'C': return cmd_c(arg, param[1], param[2], param[3]);
-        case 'E': return cmd_e(arg, param[1], param[2]);
-        case 'J': return cmd_j(arg);
+        case 'U': return cmd_u(param);
+        case 'A': return cmd_a(param);
+        case 'W': return cmd_w(param);
+        case 'R': return cmd_r(param);
+        case 'P': return cmd_p(param);
+        case 'C': return cmd_c(param);
+        case 'E': return cmd_e(param);
+        case 'I': return cmd_i(param);
+        case 'J': return cmd_j(param);
+        case 'K': return cmd_k(param);
+        case 'N': return cmd_n(param);
+        case 'S': return cmd_s(param);
         default: return INVALID_COMMAND;
     }
 }
 
-int BaseEmuISP::cmd_a(int arg, int p1) {
-    if (p1 == 0 || p1 == 1) {
-        echoFlag = (p1 == 1) ? true : false;
+ReturnCode_t BaseEmuISP::cmd_a(vint_t &param) {
+    if (param.size() > 1) {
+        if (param[1] == 0 || param[1] == 1) {
+            echoFlag = (param[1] == 1) ? true : false;
+            return CMD_SUCCESS;
+        }
+    }
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_u(vint_t &param) {
+    if (param.size() > 1) {
+        if (param[1] == 23130) {
+            lockFlag = false;
+            return CMD_SUCCESS;
+        }
+    }
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_w(vint_t &param) {
+    if (param.size() > 2) {
+        if (param[1] % 4 != 0) {
+            return ADDR_ERROR;
+        }
+        if (param[2] % 4 != 0) {
+            return COUNT_ERROR;
+        }
+        addr = param[1];
+        count = param[2];
+        mode = M_CMD_W_DATA;
         return CMD_SUCCESS;
     }
     return PARAM_ERROR;
 }
 
-int BaseEmuISP::cmd_u(int arg, int p1) {
-    if (p1 == 23130) {
-        lockFlag = false;
+ReturnCode_t BaseEmuISP::cmd_r(vint_t &param) {
+    if (param.size() > 2) {
+        if (param[1] % 4 != 0) {
+            return ADDR_ERROR;
+        }
+        if (param[2] % 4 != 0) {
+            return COUNT_ERROR;
+        }
+        addr = param[1];
+        count = param[2];
+        mode = M_CMD_R_DATA;
         return CMD_SUCCESS;
     }
     return PARAM_ERROR;
 }
 
-int BaseEmuISP::cmd_w(int arg, int p1, int p2) {
-    if (p1 % 4 != 0) {
-        return ADDR_ERROR;
+ReturnCode_t BaseEmuISP::cmd_p(vint_t &param) {
+    if (param.size() > 2) {
+        for(int sector = param[1]; sector <= param[2]; sector++) {
+            if (!Prepare(sector)) {
+                return INVALID_SECTOR;
+            }
+        }
+        return CMD_SUCCESS;
     }
-    if (p2 % 4 != 0) {
-        return COUNT_ERROR;
-    }
-    addr = p1;
-    count = p2;
-    mode = M_CMD_W_DATA;
-    return CMD_SUCCESS;
+    return PARAM_ERROR;
 }
 
-int BaseEmuISP::cmd_r(int arg, int p1, int p2) {
-    if (p1 % 4 != 0) {
-        return ADDR_ERROR;
+ReturnCode_t BaseEmuISP::cmd_c(vint_t &param) {
+    if (lockFlag) {
+        return CMD_LOCKED;
+    }
+    if (param.size() > 3) {
+        if (param[1] % 4 != 0) {
+            return DST_ADDR_ERROR;
+        }
+        if (param[2] % 4 != 0) {
+            return SRC_ADDR_ERROR;
+        }
+        if (param[3] != 64 && param[3] != 128 && param[3] != 256 &&
+            param[3] != 512 && param[3] != 1024) {
+            return COUNT_ERROR;
+        }
+        CopyData(param[1], param[2], param[3]);
+        return CMD_SUCCESS;
+    }
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_e(vint_t &param) {
+    if (lockFlag) {
+        return CMD_LOCKED;
     }
-    if (p2 % 4 != 0) {
-        return COUNT_ERROR;
+    if (param.size() > 2) {
+        for(int sector = param[1]; sector <= param[2]; sector++) {
+            if (!Erase(sector)) {
+                return INVALID_SECTOR;
+            }
+        }
+        return CMD_SUCCESS;
     }
-    addr = p1;
-    count = p2;
-    mode = M_CMD_R_DATA;
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_i(vint_t &param) {
+    if (param.size() > 2) {
+        for(int sector = param[1]; sector <= param[2]; sector++) {
+            if (!Blank(sector)) {
+                return SECTOR_NOT_BLANK;
+            }
+        }
+        return CMD_SUCCESS;
+    }
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_j(vint_t &param) {
+    mode = M_CMD_J;
     return CMD_SUCCESS;
 }
 
-int BaseEmuISP::cmd_p(int arg, int p1, int p2) {
+ReturnCode_t BaseEmuISP::cmd_k(vint_t &param) {
+    mode = M_CMD_K;
     return CMD_SUCCESS;
 }
 
-int BaseEmuISP::cmd_c(int arg, int p1, int p2, int p3) {
-    if (p1 % 4 != 0) {
-        return DST_ADDR_ERROR;
+ReturnCode_t BaseEmuISP::cmd_m(vint_t &param) {
+    if (param.size() > 3) {
+        if (param[1] % 4 != 0 || param[2] % 4 != 0) {
+            return ADDR_ERROR;
+        }
+        if (param[3] % 4 != 0) {
+            return COUNT_ERROR;
+        }
+        if (!Compare(param[1], param[2], param[3])) {
+            return COMPARE_ERROR;
+        }
+        return CMD_SUCCESS;
     }
-    if (p2 % 4 != 0) {
-        return SRC_ADDR_ERROR;
-    }
-    if (p3 != 64 && p3 != 128 && p3 != 256 && p3 != 512 && p3 != 1024) {
-        return COUNT_ERROR;
-    }
-    CopyData(p1, p2, p3);
+    return PARAM_ERROR;
+}
+
+ReturnCode_t BaseEmuISP::cmd_n(vint_t &param) {
+    mode = M_CMD_N;
     return CMD_SUCCESS;
 }
 
-int BaseEmuISP::cmd_e(int arg, int p1, int p2) {
-    if (SectorExist(p1) == false || SectorExist(p2) == false) {
-        return INVALID_SECTOR;
-    }
-    return CMD_SUCCESS;
-}
-
-int BaseEmuISP::cmd_j(int arg) {
-    mode = M_CMD_J;
+ReturnCode_t BaseEmuISP::cmd_s(vint_t &param) {
+    mode = M_CMD_S;
     return CMD_SUCCESS;
 }
 
@@ -235,7 +325,7 @@
             debugPrintf("%c", c);
             line += c;
         }
-    }    
+    }
     return false;
 }