Skip to content

File wsh_shell_str.c

File List > src > wsh_shell_str.c

Go to the documentation of this file

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
#include "wsh_shell_str.h"

WshShell_Bool_t WshShellStr_IsPrintableAscii(WshShell_Char_t ch) {
    return (bool)(ch >= ' ' && ch <= '~');  // ASCII printable range
}

WshShell_Char_t* WshShellStr_TrimString(WshShell_Char_t* pString, WshShell_Size_t len) {
    WSH_SHELL_ASSERT(pString);
    if (!pString)
        return pString;

    WshShell_Char_t* pStrBegin = pString;
    while (((*pStrBegin == ' ') || (*pStrBegin == '\t')) && (pStrBegin < (pString + len))) {
        pStrBegin++;
    }

    WshShell_Char_t* pStrEnd = pString + len - 1;
    while ((pStrEnd >= pStrBegin) && (*pStrEnd == ' ' || *pStrEnd == '\t')) {
        *pStrEnd = 0;
        pStrEnd--;
    }

    return pStrBegin;
}

void WshShellStr_ParseToArgcArgv(WshShell_Char_t* pStr, WshShell_Size_t* pArgNum,
                                 const WshShell_Char_t* pArgBuff[], WshShell_Size_t maxArgNum) {
    WSH_SHELL_ASSERT(pStr && pArgNum && pArgBuff && maxArgNum > 0);
    if (!pStr || !pArgNum || !pArgBuff || maxArgNum == 0)
        return;

    *pArgNum                 = 0;
    WshShell_Bool_t inQuotes = false;
    WshShell_Size_t len      = WSH_SHELL_STRLEN(pStr);

    for (WshShell_Size_t idx = 0; idx < len; idx++) {
        if (pStr[idx] == '\"') {
            inQuotes  = !inQuotes;
            pStr[idx] = '\0';
        } else if (!inQuotes && pStr[idx] == ' ') {
            pStr[idx] = '\0';
        }
    }

    // Extract pointers to tokens
    for (WshShell_Size_t idx = 0; idx < len;) {
        if (pStr[idx] != '\0') {
            if (*pArgNum < maxArgNum) {
                pArgBuff[(*pArgNum)++] = &pStr[idx];
            }

            // Skip until next '\0'
            while (idx < len && pStr[idx] != '\0')
                idx++;
        } else {
            idx++;
        }
    }
}

void WshShellStr_IncrInterCnt(WshShell_Size_t* pInterCnt, WshShell_Size_t buffSize) {
    WSH_SHELL_ASSERT(pInterCnt && buffSize > 0);
    if (!pInterCnt || buffSize == 0)
        return;

    if (*pInterCnt < buffSize - 1)
        (*pInterCnt)++;
}

void WshShellStr_DecrInterCnt(WshShell_Size_t* pInterCnt) {
    WSH_SHELL_ASSERT(pInterCnt);
    if (!pInterCnt)
        return;

    if (*pInterCnt > 0)
        (*pInterCnt)--;
}

void WshShellStr_AccessBitsToStr(WshShell_Size_t access, WshShell_Char_t* pOutStr) {
    WSH_SHELL_ASSERT(pOutStr);
    if (!pOutStr)
        return;

    pOutStr[0] = (access & WSH_SHELL_OPT_ACCESS_READ) ? 'r' : '-';
    pOutStr[1] = (access & WSH_SHELL_OPT_ACCESS_WRITE) ? 'w' : '-';
    pOutStr[2] = (access & WSH_SHELL_OPT_ACCESS_EXECUTE) ? 'x' : '-';
    pOutStr[3] = (access == WSH_SHELL_OPT_ACCESS_ADMIN) ? 'A' : '-';
    pOutStr[4] = '\0';
}

void WshShellStr_GroupBitsToStr(WshShell_Size_t group, WshShell_Size_t groupMaxNum,
                                WshShell_Char_t* pOutStr) {
    WSH_SHELL_ASSERT(pOutStr);
    if (!pOutStr)
        return;

    for (WshShell_S32_t groupIdx = groupMaxNum - 1; groupIdx >= 0; --groupIdx) {
        *pOutStr++ = (group == WSH_SHELL_CMD_GROUP_ALL || (group & (1U << groupIdx))) ? '*' : '-';
    }
    *pOutStr = '\0';
}