File content as of revision 2:8788d711db7e:

#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);
}