Revision 5:e2c275b33bbf, committed 2016-03-25

Comitter:

va009039

Date:

Fri Mar 25 06:08:40 2016 +0900

Parent:

4:05f33cc747fd

Commit message:

mystring class.

Changed in this revision

--- a/BaseEmuISP.cpp	Wed Mar 23 09:11:05 2016 +0900
+++ b/BaseEmuISP.cpp	Fri Mar 25 06:08:40 2016 +0900
@@ -1,4 +1,4 @@
-// BaseEmuISP.cpp 2016/3/23
+// BaseEmuISP.cpp 2016/3/24
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -27,11 +27,11 @@
             }
             break;
         case M_CMD:
-            if (line_proc()) {
-                result = cmd(line.C_str());
+            if (lineProc()) {
+                result = cmd(line.c_str());
                 snprintf(buf, sizeof(buf), "%d", result);
                 putln(buf);
-                line.Clear();
+                line.clear();
             }
             break;
         case M_CMD_W_DATA:
@@ -65,7 +65,7 @@
     }
     if (prev_mode != mode) {
         seq = 0;
-        line.Clear();
+        line.clear();
     }
 }
 
@@ -74,16 +74,16 @@
         case 0:
             if (Getch() == '?') {
                 putln("Synchronized");
-                line.Clear();
+                line.clear();
                 echoFlag = true;
                 seq++;
             }
             break;
         case 1:
-            if (line_proc()) {
+            if (lineProc()) {
                 if (line == "Synchronized") {
                     putln("OK");
-                    line.Clear();
+                    line.clear();
                     seq++;
                 } else {
                     seq = 0;
@@ -91,8 +91,8 @@
             }
             break;
         case 2:
-            if (line_proc()) {
-                freq = atoi(line.C_str());
+            if (lineProc()) {
+                freq = atoi(line.c_str());
                 putln("OK");
                 return true;
             }
@@ -101,7 +101,7 @@
     return false;
 }
 
-static int split(myvector<char*> &param, char *buf, const char* delimiters = " ") {
+static int split(vec_charPtr_t &param, char *buf, const char* delimiters = " ") {
     param.clear();
     char* p = strtok(buf, delimiters);
     while(p != NULL) {
@@ -118,7 +118,7 @@
     if (split(p, buf) == 0) {
         return INVALID_COMMAND;
     }
-    vint_t param;
+    vec_int_t param;
     param.push_back(p[0][0]);
     for(size_t i = 1; i < p.size(); i++) {
         param.push_back(atoi(p[i]));
@@ -140,7 +140,7 @@
     }
 }
 
-ReturnCode_t BaseEmuISP::cmd_a(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_a(vec_int_t &param) {
     if (param.size() > 1) {
         if (param[1] == 0 || param[1] == 1) {
             echoFlag = (param[1] == 1) ? true : false;
@@ -150,7 +150,7 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_u(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_u(vec_int_t &param) {
     if (param.size() > 1) {
         if (param[1] == 23130) {
             lockFlag = false;
@@ -160,7 +160,7 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_w(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_w(vec_int_t &param) {
     if (param.size() > 2) {
         if (param[1] % 4 != 0) {
             return ADDR_ERROR;
@@ -169,14 +169,14 @@
             return COUNT_ERROR;
         }
         addr = param[1];
-        dataCount = param[2];
+        data.Count = param[2];
         mode = M_CMD_W_DATA;
         return CMD_SUCCESS;
     }
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_r(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_r(vec_int_t &param) {
     if (param.size() > 2) {
         if (param[1] % 4 != 0) {
             return ADDR_ERROR;
@@ -185,14 +185,14 @@
             return COUNT_ERROR;
         }
         addr = param[1];
-        dataCount = param[2];
+        data.Count = param[2];
         mode = M_CMD_R_DATA;
         return CMD_SUCCESS;
     }
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_p(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_p(vec_int_t &param) {
     if (param.size() > 2) {
         for(int sector = param[1]; sector <= param[2]; sector++) {
             if (!Prepare(sector)) {
@@ -204,7 +204,7 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_c(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_c(vec_int_t &param) {
     if (lockFlag) {
         return CMD_LOCKED;
     }
@@ -225,7 +225,7 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_e(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_e(vec_int_t &param) {
     if (lockFlag) {
         return CMD_LOCKED;
     }
@@ -240,7 +240,7 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_i(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_i(vec_int_t &param) {
     if (param.size() > 2) {
         for(int sector = param[1]; sector <= param[2]; sector++) {
             if (!Blank(sector)) {
@@ -252,17 +252,17 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_j(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_j(vec_int_t &param) {
     mode = M_CMD_J;
     return CMD_SUCCESS;
 }
 
-ReturnCode_t BaseEmuISP::cmd_k(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_k(vec_int_t &param) {
     mode = M_CMD_K;
     return CMD_SUCCESS;
 }
 
-ReturnCode_t BaseEmuISP::cmd_m(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_m(vec_int_t &param) {
     if (param.size() > 3) {
         if (param[1] % 4 != 0 || param[2] % 4 != 0) {
             return ADDR_ERROR;
@@ -278,17 +278,17 @@
     return PARAM_ERROR;
 }
 
-ReturnCode_t BaseEmuISP::cmd_n(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_n(vec_int_t &param) {
     mode = M_CMD_N;
     return CMD_SUCCESS;
 }
 
-ReturnCode_t BaseEmuISP::cmd_s(vint_t &param) {
+ReturnCode_t BaseEmuISP::cmd_s(vec_int_t &param) {
     mode = M_CMD_S;
     return CMD_SUCCESS;
 }
 
-void uudecode(vbyte_t &dst, const char* src) {
+void uudecode(vec_byte_t &dst, const char* src) {
     dst.clear();
     int len = strlen(src);
     if (len > 0) {
@@ -317,7 +317,7 @@
     int c;
     switch(seq) {
         case 0:
-            dataCurrent = 0;
+            data.Current = 0;
             if (UuencodeMode()) {
                 seq = 2;
             } else {
@@ -325,7 +325,7 @@
             }
             break;
         case 1: // binary mode
-            if (dataCurrent >= dataCount) {
+            if (data.Current >= data.Count) {
                 return true;
             }
             c = Getch();
@@ -334,37 +334,36 @@
                     Putch(c);
                 }
                 WriteData(addr++, c);
-                dataCurrent++;
+                data.Current++;
             }
             break;
         case 2: // uuencode mode
-            dataLine = 0;
-            dataCksum = 0;
-            line.Clear();
+            data.Line = 0;
+            data.Cksum = 0;
+            line.clear();
             seq++;
             break;
         case 3: // uu data start
-            if (line_proc()) {
-                vbyte_t data;
-                uudecode(data, line.C_str());
-                for(size_t i = 0; i < data.size(); i++) {
-                    int c = data[i];
+            if (lineProc()) {
+                uudecode(data.Buf, line.c_str());
+                for(size_t i = 0; i < data.Buf.size(); i++) {
+                    int c = data.Buf[i];
                     WriteData(addr++, c);
-                    dataCksum += c;
-                    dataCurrent++;
+                    data.Cksum += c;
+                    data.Current++;
                 }
-                dataLine++;
-                if (dataLine >= 20 || dataCurrent>= dataCount) {
+                data.Line++;
+                if (data.Line >= 20 || data.Current>= data.Count) {
                     seq++;
                 }
-                line.Clear();
+                line.clear();
             }
             break;
         case 4: // check sum
-            if (line_proc()) {
-                if (line == dataCksum) {
+            if (lineProc()) {
+                if (atoi(line.c_str()) == data.Cksum) {
                     putln("OK");
-                    if (dataCurrent >= dataCount) {
+                    if (data.Current >= data.Count) {
                         mode = M_CMD;
                     } else {
                         seq = 2;
@@ -383,23 +382,23 @@
     int c;
     switch(seq) {
         case 0:
-            dataCurrent = 0;
+            data.Current = 0;
             if (UuencodeMode()) {
-                dataLine = 0;
-                dataCksum = 0;
-                line.Clear();
+                data.Line = 0;
+                data.Cksum = 0;
+                line.clear();
                 seq = 2;
             } else {
                 seq = 1;
             }
             break;
         case 1: // binary mode
-            if (dataCurrent >= dataCount) {
+            if (data.Current >= data.Count) {
                 return true;
             }
             c = ReadData(addr++);
             Putch(c);
-            dataCurrent++;
+            data.Current++;
             break;
         case 2:
             break;
@@ -417,7 +416,7 @@
     Putch('\n');
 }
 
-bool BaseEmuISP::line_proc() {
+bool BaseEmuISP::lineProc() {
     int c = Getch();
     if (c != (-1)) {
         if (echoFlag) {
@@ -431,7 +430,7 @@
         } else if (c == '\r') {
             debugPrintf("<CR>");
         } else {
-            if (line.Size() == 0) {
+            if (line.size() == 0) {
                 debugPrintf("recv: ");
             }
             debugPrintf("%c", c);

--- a/BaseEmuISP.h	Wed Mar 23 09:11:05 2016 +0900
+++ b/BaseEmuISP.h	Fri Mar 25 06:08:40 2016 +0900
@@ -1,10 +1,13 @@
-// BaseEmuISP.h 2016/3/23
+// BaseEmuISP.h 2016/3/25
 #pragma once
 #include <stdint.h>
 #include "myvector.h"
+#include "mystring.h"
 
-typedef myvector<int> vint_t;
-typedef myvector<uint8_t> vbyte_t;
+typedef myvector<char*> vec_charPtr_t;
+typedef myvector<int> vec_int_t;
+typedef myvector<uint8_t> vec_byte_t;
+typedef mystring string_t;
 
 enum Mode_t {
     M_RESET = 0,
@@ -64,21 +67,21 @@
 private:
     bool sync();
     ReturnCode_t cmd(const char* s);
-    ReturnCode_t cmd_u(vint_t &param);
-    ReturnCode_t cmd_b(vint_t &param);
-    ReturnCode_t cmd_a(vint_t &param);
-    ReturnCode_t cmd_w(vint_t &param);
-    ReturnCode_t cmd_r(vint_t &param);
-    ReturnCode_t cmd_p(vint_t &param);
-    ReturnCode_t cmd_c(vint_t &param);
-    ReturnCode_t cmd_g(vint_t &param);
-    ReturnCode_t cmd_e(vint_t &param);
-    ReturnCode_t cmd_i(vint_t &param);
-    ReturnCode_t cmd_j(vint_t &param);
-    ReturnCode_t cmd_k(vint_t &param);
-    ReturnCode_t cmd_m(vint_t &param);
-    ReturnCode_t cmd_n(vint_t &param);
-    ReturnCode_t cmd_s(vint_t &param);
+    ReturnCode_t cmd_u(vec_int_t &param);
+    ReturnCode_t cmd_b(vec_int_t &param);
+    ReturnCode_t cmd_a(vec_int_t &param);
+    ReturnCode_t cmd_w(vec_int_t &param);
+    ReturnCode_t cmd_r(vec_int_t &param);
+    ReturnCode_t cmd_p(vec_int_t &param);
+    ReturnCode_t cmd_c(vec_int_t &param);
+    ReturnCode_t cmd_g(vec_int_t &param);
+    ReturnCode_t cmd_e(vec_int_t &param);
+    ReturnCode_t cmd_i(vec_int_t &param);
+    ReturnCode_t cmd_j(vec_int_t &param);
+    ReturnCode_t cmd_k(vec_int_t &param);
+    ReturnCode_t cmd_m(vec_int_t &param);
+    ReturnCode_t cmd_n(vec_int_t &param);
+    ReturnCode_t cmd_s(vec_int_t &param);
     bool cmd_w_data();
     bool cmd_r_data();
     void putln(const char *s);
@@ -87,23 +90,17 @@
     int seq;
     bool echoFlag;
     bool lockFlag;
-    bool line_proc();
-    struct {
-        void Clear() { pos = 0; }
-        size_t Size() { return pos; }
-        const char *C_str() {return buf; }
-        void operator +=(int c) { if (pos < sizeof(buf)-2) buf[pos++] = c; buf[pos] = '\0'; }
-        bool operator ==(const char* s) { return strcmp(buf, s) == 0; }
-        bool operator ==(int n) { return atoi(buf) == n; }
-        size_t pos;
-        char buf[64];
-    } line;
+    string_t line;
+    bool lineProc();
     int freq;
     int addr;
-    int dataLine;
-    int dataCount;
-    int dataCurrent;
-    int dataCksum;
+    struct {
+        vec_byte_t Buf;
+        int Line;
+        int Count;
+        int Current;
+        int Cksum;
+    } data;
     struct {
         uint8_t Major;
         uint8_t Minor;

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mystring.h	Fri Mar 25 06:08:40 2016 +0900
@@ -0,0 +1,46 @@
+// mystring.h 2016/3/24
+#pragma once
+class mystring {
+public:
+    mystring() {
+        m_cap = 4;
+        m_buf = new char[m_cap];
+        m_size = 0;
+        m_buf[m_size] = '\0';
+    }
+    ~mystring() {
+        delete[] m_buf;
+    }
+    const char *c_str() const {return m_buf; }
+    void clear() {
+        delete[] m_buf;
+        m_cap = 4;
+        m_buf = new char[m_cap];
+        m_size = 0;
+        m_buf[m_size] = '\0';
+    }
+    void operator +=(char c) { push_back(c); }
+    bool operator ==(const char* s) const { return strcmp(m_buf, s) == 0; }
+    void push_back(char c) {
+        if (m_size+1 < m_cap) {
+            m_cap += 4;
+            char* new_buf = new char[m_cap];
+            for(int i = 0; i < m_size; i++) {
+                new_buf[i] = m_buf[i];
+            }
+            delete[] m_buf;
+            m_buf = new_buf;
+        }
+        m_buf[m_size++] = c;
+        m_buf[m_size] = '\0';
+    }
+    char& operator[](size_t pos) const { return at(pos); }
+    char& at(size_t pos) const { return m_buf[pos]; }
+    size_t size() const { return m_size; }
+
+private:
+    size_t m_size;
+    size_t m_cap;
+    char *m_buf;
+};
+