string.cpc

FUNCTION Split(s : STRING, sep : STRING) RETURNS ARRAY
    DECLARE result : ARRAY[1:LENGTH(s)] OF STRING

    DECLARE from : INTEGER
    DECLARE item : INTEGER

    from <- 1
    item <- 1

    FOR i <- 1 TO LENGTH(s)
        IF MID(s, i, LENGTH(sep)) = sep THEN
            result[item] <- MID(s, from, i-from)
            item <- item + 1
            from <- i + 1
        ENDIF
    NEXT i

    result[item] <- MID(s, from, LENGTH(s)-from+1)

    DECLARE returnArr : ARRAY[1:item] OF STRING
    FOR i <- 1 TO item
        returnArr[i] <- result[i]
    NEXT i

    RETURN returnArr
ENDFUNCTION

FUNCTION TrimStart(s : STRING) RETURNS STRING
    DECLARE len : INTEGER
    len <- LENGTH(s)
    DECLARE result : STRING
    DECLARE c : STRING
    DECLARE flag : BOOLEAN

    // 从前往后查看
    flag <- TRUE
    FOR i <- 1 TO len
        c <- MID(s, i, 1)
        IF c = ' ' AND flag THEN
            PASS
        ELSE
            result <- result & c
            flag <- FALSE
        ENDIF
    NEXT i

    RETURN result
ENDFUNCTION

FUNCTION TrimEnd(s : STRING) RETURNS STRING
    DECLARE len : INTEGER
    len <- LENGTH(s)
    DECLARE result : STRING
    DECLARE c : STRING
    DECLARE flag : BOOLEAN

    // 从后往前查看
    flag <- TRUE
    FOR i <- len TO 1 STEP -1
        c <- MID(s, i, 1)
        IF c = ' ' AND flag THEN
            PASS
        ELSE
            result <- c & result
            flag <- FALSE
        ENDIF
    NEXT i

    RETURN result
ENDFUNCTION

FUNCTION Trim(s : STRING) RETURNS STRING
    RETURN TrimStart(TrimEnd(s))
ENDFUNCTION

FUNCTION ArrayFromString(s : STRING) RETURNS ARRAY
    DECLARE len : INTEGER
    len <- LENGTH(s)
    DECLARE arr : ARRAY[1:len] OF STRING

    FOR i <- 1 TO len
        arr[i] <- MID(s, i, 1)
    NEXT i

    RETURN arr
ENDFUNCTION

FUNCTION Contains(s : STRING, target : STRING) RETURNS BOOLEAN
    DECLARE targetLen : INTEGER
    targetLen <- LENGTH(target)

    FOR i <- 1 TO LENGTH(s) STEP targetLen
        IF MID(s, i, targetLen) = target THEN
            RETURN TRUE
        ENDIF
    NEXT i

    RETURN FALSE
ENDFUNCTION

FUNCTION Join(sep : STRING, BYREF list : ARRAY, start : INTEGER, end : INTEGER) RETURNS STRING
    DECLARE r : STRING

    FOR i <- start TO end
        IF i = end THEN
            r <- r & list[i]
        ELSE
            r <- r & list[i] & sep
        ENDIF
    NEXT i

    RETURN r
ENDFUNCTION

FUNCTION Reverse(s : STRING) RETURNS STRING
    DECLARE r : STRING

    FOR i <- LENGTH(s) TO 0 STEP -1
        r <- r & MID(s, i, 1)
    NEXT i

    RETURN r
ENDFUNCTION

FUNCTION Replace(s : STRING, from : STRING, to : STRING) RETURNS STRING
    CONSTANT arr = Split(s, from)
    RETURN Join(to, arr, 1, LENGTH(arr))
ENDFUNCTION

FUNCTION EndsWith(base : STRING, suffix : STRING) RETURNS BOOLEAN
    CONSTANT baseLen = LENGTH(base)
    CONSTANT suffixLen = LENGTH(suffix)

    IF baseLen < suffixLen THEN
        RETURN FALSE
    ENDIF

    RETURN MID(base, baseLen - suffixLen + 1, suffixLen) = suffix
ENDFUNCTION

FUNCTION StartsWith(base : STRING, prefix : STRING) RETURNS BOOLEAN
    CONSTANT baseLen = LENGTH(base)
    CONSTANT prefixLen = LENGTH(prefix)

    IF baseLen < prefixLen THEN
        RETURN FALSE
    ENDIF

    RETURN MID(base, 1, prefixLen) = prefix
ENDFUNCTION

FUNCTION STR_TO_NUM(s : STRING) RETURNS REAL
    RETURN REAL(s)
ENDFUNCTION

FUNCTION NUM_TO_STR(s : REAL) RETURNS STRING
    IF INT(s) = s THEN
        RETURN STRING(INT(s))
    ELSE
        RETURN STRING(s)
    ENDIF
ENDFUNCTION

FUNCTION CHR(n : INTEGER) RETURNS CHAR
    DECLARE r : STRING
    r <- PYTHON("_result=chr(n)", n)
    RETURN r
ENDFUNCTION

FUNCTION ORD(s : CHAR) RETURNS INTEGER
    DECLARE r : INTEGER
    r <- PYTHON("_result=ord(s)", s)
    RETURN r
ENDFUNCTION

FUNCTION ASCII(s : CHAR) RETURNS INTEGER
    RETURN ORD(s)
ENDFUNCTION

FUNCTION SUBSTRING(s : STRING, start : INTEGER, size : INTEGER) RETURNS STRING
    RETURN MID(s, start, size)
ENDFUNCTION