Diff: string.cpp

Revision:

2:8788d711db7e

Child:

3:6fc7976cc5bf

diff -r 42a82d41947f -r 8788d711db7e string.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/string.cpp	Wed May 20 15:42:07 2020 +0000
@@ -0,0 +1,170 @@
+#include "string.h"
+
+
+struct Token asToken[MAX_TOKEN_NR];
+
+struct Keyword asKeywordList[MAX_KEYWORD_NR]= 
+{
+{CLB,"callib"},
+{GT, "goto" },
+};
+
+
+unsigned char ucTokenCnt;
+
+void CopyString(char pcSource[], char pcDestination[]){
+  
+    unsigned char ucCharCounter;
+  
+    for(ucCharCounter=0;pcSource[ucCharCounter]!='\0';ucCharCounter++){
+        pcDestination[ucCharCounter] = pcSource[ucCharCounter];
+    }
+    pcDestination[ucCharCounter] = '\0';
+}
+
+
+enum CompResult eCompareString(char pcStr1[], char pcStr2[]){
+    
+  unsigned char ucCharCounter;
+  
+    for(ucCharCounter=0;pcStr1[ucCharCounter] != '\0';ucCharCounter++){
+        if (pcStr1[ucCharCounter] != pcStr2[ucCharCounter]) return DIFFERENT;
+    }
+    return EQUAL;
+}
+
+
+void AppendString (char pcSourceStr[],char pcDestinationStr[]){
+  
+    unsigned char ucEndPointer;
+  
+    for(ucEndPointer=0;pcDestinationStr[ucEndPointer]!='\0';ucEndPointer++) {}
+    CopyString(pcSourceStr,pcDestinationStr+ucEndPointer);
+}
+
+
+void ReplaceCharactersInString(char pcString[],char cOldChar,char cNewChar){
+  
+    unsigned char ucCharCounter;
+  
+    for(ucCharCounter=0;pcString[ucCharCounter]!='\0';ucCharCounter++){
+        if(pcString[ucCharCounter] == cOldChar) pcString[ucCharCounter] = cNewChar;
+    }
+}
+
+
+void UIntToHexStr(unsigned int uiValue, char pcStr[]){
+  
+    unsigned char ucNibbleCounter;
+    unsigned char ucCurrentNibble;
+  
+    pcStr[0] = '0';
+    pcStr[1] = 'x';
+    for(ucNibbleCounter=0;ucNibbleCounter<4;ucNibbleCounter++){
+        ucCurrentNibble = ((uiValue >> ucNibbleCounter*4) & HEX_bm);
+        if(ucCurrentNibble>9) 
+            pcStr[5-ucNibbleCounter] = ucCurrentNibble - 10 + 'A';
+        else 
+            pcStr[5-ucNibbleCounter] = ucCurrentNibble + '0';
+    }
+    pcStr[6] = '\0';
+}
+
+
+enum Result eHexStringToUInt(char pcStr[],unsigned int *puiValue){
+  
+    unsigned char ucCharCounter;
+  
+    if((pcStr[0] != '0') | (pcStr[1] != 'x') | (pcStr[2] == '\0'))
+        return NOK;
+    *puiValue = 0;
+    for(ucCharCounter=2;ucCharCounter<7;ucCharCounter++){
+        if(pcStr[ucCharCounter] == '\0') 
+            return OK;
+      *puiValue = *puiValue << 4;
+        if(pcStr[ucCharCounter] >= 'A') 
+            *puiValue = *puiValue | (pcStr[ucCharCounter] - 'A' + 10); 
+        else 
+            *puiValue = *puiValue | (pcStr[ucCharCounter] - '0');
+    }
+    return OK;
+}
+
+void AppendUIntToString (unsigned int uiValue, char pcDestinationStr[]){
+  
+    unsigned char ucEndPointer;
+  
+    for(ucEndPointer=0;pcDestinationStr[ucEndPointer]!='\0';ucEndPointer++) {}
+    UIntToHexStr(uiValue,pcDestinationStr+ucEndPointer);
+}
+
+
+
+    
+unsigned char ucFindTokensInString(char *pcString){
+  
+    unsigned char ucTokenPointer;
+    unsigned char ucDelimiterCounter;
+    char cCurrentChar;
+    enum State {TOKEN, DELIMITER};
+    enum State eState = DELIMITER;
+    ucDelimiterCounter = 0;
+    
+    for(ucTokenPointer=0;;ucTokenPointer++){
+        cCurrentChar = pcString[ucTokenPointer];
+        switch(eState){
+            case DELIMITER:
+                if(cCurrentChar == '\0') 
+                    return ucDelimiterCounter;
+                else if(cCurrentChar == ' ') {}
+                else {
+                    eState = TOKEN;
+                    asToken[ucDelimiterCounter].uValue.pcString = pcString+ucTokenPointer;
+                    ucDelimiterCounter++;
+                }
+                break;
+            case TOKEN:
+                if(cCurrentChar == '\0') 
+                    return ucDelimiterCounter;
+                else if(ucDelimiterCounter == MAX_TOKEN_NR) 
+                    return ucDelimiterCounter;
+                else if(cCurrentChar != ' ') {}
+                else 
+                    eState = DELIMITER;
+                break;
+        }
+    }
+}
+
+enum Result eStringToKeyword (char pcStr[],enum KeywordCode *peKeywordCode){
+  
+    unsigned char ucTokenCounter;
+  
+    for(ucTokenCounter=0;ucTokenCounter<MAX_TOKEN_NR;ucTokenCounter++){
+        if (eCompareString(pcStr,asKeywordList[ucTokenCounter].cString) == EQUAL) {
+            *peKeywordCode = asKeywordList[ucTokenCounter].eCode;
+            return OK;
+        }
+    }
+    return NOK;
+}
+
+void DecodeTokens(unsigned char ucTokenCnt){
+  
+    unsigned char ucTokenCounter;
+    Token* tValue;
+  
+    for(ucTokenCounter=0;ucTokenCounter<ucTokenCnt;ucTokenCounter++){
+        tValue = &asToken[ucTokenCounter];
+        if (eStringToKeyword(tValue->uValue.pcString,&tValue->uValue.eKeyword) == OK) tValue->eType = KEYWORD;
+        else if (eHexStringToUInt(tValue->uValue.pcString,&tValue->uValue.uiNumber) == OK) tValue->eType = NUMBER;
+        else tValue->eType = STRING;
+    }
+}
+
+void DecodeMsg(char *pcString){
+  
+    ucTokenCnt = ucFindTokensInString(pcString);
+    ReplaceCharactersInString(pcString,' ','\0');
+    DecodeTokens(ucTokenCnt);
+}