tools.c

Go to the documentation of this file.

/*  *************************************************************************************
    Copyright (c) 2021, Lowell D. Thomas
    All rights reserved.
    
    This file is part of APG Version 7.0.
    APG Version 7.0 may be used under the terms of the BSD 2-Clause License.
    
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:
    
    1. Redistributions of source code must retain the above copyright notice, this
       list of conditions and the following disclaimer.
    
    2. Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.
    
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
*   *************************************************************************************/
#include "lib.h"
 
static char s_cPeriod = 46;
 
int iStriCmp(const char* cpLeft, const char* cpRight){
    if(cpLeft == NULL && cpRight == NULL){
        return 0;
    }
    if(cpLeft == NULL){
        return -1;
    }
    if(cpRight == NULL){
        return 1;
    }
    size_t uiLeftLen = strlen(cpLeft);
    size_t uiRightLen = strlen(cpRight);
    size_t uiLen = uiLeftLen < uiRightLen ? uiLeftLen : uiRightLen;
    size_t ui = 0;
    unsigned char ucL, ucR;
    for(; ui < uiLen; ui++){
        ucL = cpLeft[ui];
        ucR = cpRight[ui];
        if(ucL >= 65 && ucL <= 90){
            ucL += 32;
        }
        if(ucR >= 65 && ucR <= 90){
            ucR += 32;
        }
        if(ucL < ucR){
            return -1;
        }
        if(ucL > ucR){
            return 1;
        }
    }
    if(uiLeftLen < uiRightLen){
        return -1;
    }
    if(uiLeftLen > uiRightLen){
        return 1;
    }
    return 0;
}
 
abool bIsBigEndian(void){
    static union {
        uint32_t ui32;
        char caChar[4];
    } sIsBig = {0x01020304};
    return (abool)(sIsBig.caChar[0] == 1);
}
 
abool bMultiplyLong(luint luiL, luint luiR, luint* luipA){
    if(luiL == 0 || luiR == 0){
        *luipA = 0;
        return APG_SUCCESS;
    }
    luint luiTest = luiL * luiR;
    luint luiCheck = luiTest / luiR;
    if(luiCheck != luiL){
        *luipA = (luint)-1;
        return APG_FAILURE;
    }
    *luipA = luiTest;
    return APG_SUCCESS;
}
 
abool bSumLong(luint uiL, luint uiR, luint* uipA){
    luint uiTest = uiL + uiR;
    if(uiTest < uiR){
        return APG_FAILURE;
    }
    luint uiCheck = uiTest - uiR;
    if(uiCheck != uiL){
        return APG_FAILURE;
    }
    *uipA = uiTest;
    return APG_SUCCESS;
}
 
abool bMultiply32(uint32_t uiL, uint32_t uiR, uint32_t* uipA){
    if(uiL == 0 || uiR == 0){
        *uipA = 0;
        return APG_SUCCESS;
    }
    uint32_t uiTest = uiL * uiR;
    uint32_t uiCheck = uiTest / uiR;
    if(uiCheck != uiL){
        return APG_FAILURE;
    }
    *uipA = uiTest;
    return APG_SUCCESS;
}
 
abool bSum32(uint32_t uiL, uint32_t uiR, uint32_t* uipA){
    uint32_t uiTest = uiL + uiR;
    if(uiTest < uiR){
        return APG_FAILURE;
    }
    uint32_t uiCheck = uiTest - uiR;
    if(uiCheck != uiL){
        return APG_FAILURE;
    }
    *uipA = uiTest;
    return APG_SUCCESS;
}
 
abool bMultiply(aint uiL, aint uiR, aint* uipA){
    if(uiL == 0 || uiR == 0){
        *uipA = 0;
        return APG_SUCCESS;
    }
    aint uiTest = uiL * uiR;
    aint uiCheck = uiTest / uiR;
    if(uiCheck != uiL){
        return APG_FAILURE;
    }
    *uipA = uiTest;
    return APG_SUCCESS;
}
 
abool bSum(aint uiL, aint uiR, aint* uipA){
    aint uiTest = uiL + uiR;
    if(uiTest < uiR){
        return APG_FAILURE;
    }
    aint uiCheck = uiTest - uiR;
    if(uiCheck != uiL){
        return APG_FAILURE;
    }
    *uipA = uiTest;
    return APG_SUCCESS;
}
 
apg_phrase* spStrToPhrase(const char* cpStr, apg_phrase* spPhrase){
    if(!spPhrase || !cpStr){
        return NULL;
    }
    aint uiStrLen = strlen(cpStr);
    aint uiBufLen = spPhrase->uiLength;
    aint uiLen = uiStrLen < uiBufLen ? uiStrLen : uiBufLen;
    aint ui = 0;
    achar* acpTmp = (achar*)spPhrase->acpPhrase;
    for(; ui < uiLen; ui++){
//        spPhrase->acpPhrase[ui] = (achar)((uint8_t)cpStr[ui]);
        acpTmp[ui] = (achar)((uint8_t)cpStr[ui]);
    }
    spPhrase->uiLength = uiStrLen;
    return spPhrase;
}
 
char* cpPhraseToStr(apg_phrase* spPhrase, char* cpStr){
    aint ui = 0;
    achar acChar;
    for(; ui < spPhrase->uiLength; ui++){
        acChar = spPhrase->acpPhrase[ui];
        if(acChar == 9 || acChar == 10 || acChar == 13 || (acChar >= 32 && acChar <= 126)){
            cpStr[ui] = (char)acChar;
        }else{
            cpStr[ui] = s_cPeriod;
        }
    }
    cpStr[ui] = (char)0;
    return cpStr;
}
 
abool bIsPhraseAscii(apg_phrase* spPhrase){
    aint ui = 0;
    achar acChar;
    if(!spPhrase || !spPhrase->acpPhrase || !spPhrase->uiLength){
        return APG_FALSE;
    }
    for(; ui < spPhrase->uiLength; ui++){
        acChar = spPhrase->acpPhrase[ui];
        if(!(acChar == 9 || acChar == 10 || acChar == 13 || (acChar >= 32 && acChar <= 126))){
            return APG_FALSE;
        }
    }
    return APG_TRUE;
}
 
uint32_t* uipStrToUint32(const char* cpStr, uint32_t* uipBuf, aint* uipLen){
    aint uiStrLen = strlen(cpStr);
    aint ui = 0;
    for(; ui < uiStrLen; ui++){
        uipBuf[ui] = (uint32_t)((uint8_t)cpStr[ui]);
    }
    if(uipLen){
        *uipLen = uiStrLen;
    }
    return uipBuf;
}
 
char* cpUint32ToStr(uint32_t* uipBuf, aint uiLen, char* cpStr){
    aint ui = 0;
    uint32_t uiChar;
    for(; ui < uiLen; ui++){
        uiChar = uipBuf[ui];
        if(uiChar == 9 || uiChar == 10 || uiChar == 13 || (uiChar >= 32 && uiChar <= 126)){
            cpStr[ui] = (char)uiChar;
        }else{
            cpStr[ui] = s_cPeriod;
        }
    }
    cpStr[ui] = (char)0;
    return cpStr;
}
 
u32_phrase sStrToPhrase32(const char* cpStr, uint32_t* uipBuf){
    u32_phrase sPhrase = {};
    aint uiStrLen = strlen(cpStr);
    aint ui = 0;
    for(; ui < uiStrLen; ui++){
        uipBuf[ui] = (uint32_t)((uint8_t)cpStr[ui]);
    }
    sPhrase.uipPhrase = uipBuf;
    sPhrase.uiLength = uiStrLen;
    return sPhrase;
}
 
char* cpPhrase32ToStr(u32_phrase* spPhrase, char* cpStr){
    aint ui = 0;
    uint32_t uiChar;
    for(; ui < spPhrase->uiLength; ui++){
        uiChar = spPhrase->uipPhrase[ui];
        if(uiChar == 9 || uiChar == 10 || uiChar == 13 || (uiChar >= 32 && uiChar <= 126)){
            cpStr[ui] = (char)uiChar;
        }else{
            cpStr[ui] = s_cPeriod;
        }
    }
    cpStr[ui] = (char)0;
    return cpStr;
}
 
abool bIsPhrase32Ascii(u32_phrase* spPhrase){
    aint ui = 0;
    uint32_t uiChar;
    for(; ui < spPhrase->uiLength; ui++){
        uiChar = spPhrase->uipPhrase[ui];
        if(!(uiChar == 9 || uiChar == 10 || uiChar == 13 || (uiChar >= 32 && uiChar <= 126))){
            return APG_FALSE;
        }
    }
    return APG_TRUE;
}