String.clcl

class PcreOVec
{
    include MObjectBase;

    start:int[];
    end:int[];

    def initialize() {}

    def initialize(max:int) {
        self.start = int[max]();
        self.end = int[max]();
    }

    def clone():PcreOVec {
        result := PcreOVec();

        if(self.start.identifyWith(null).negative()) {
            result.start = int[self.start.length];
            for(i:=0; i<self.start.length; i++) {
                result.start[i] = self.start[i];
            }
        }

        if(self.end.identifyWith(null).negative()) {
            result.end = int[self.end.length];
            for(i:=0; i<self.end.length; i++) {
                result.end[i] = self.end[i];
            }
        }

        return result;
    }
}

module MArray
{
    items:T[]?;

    def initialize() {
        self.items = null;
    }

    def initialize(items:T[]) {
        self.items = items;
    }

    def length():int {
        return self.items.length;
    }

    def items(index:int):T? {
        if(index < 0) {
            index += self.items.length;
        }

        if(index >= 0 && index < self.items.length) {
            return self.items[index];
        }
        else {
            return null;
        }
    }

    def put(index:int, item:T) {
        if(index < 0) {
            index += self.items.length;
        }

        if(index >= 0 && index < self.items.length) {
            self.items[index] = item;
        }
    }

    def each(block_:lambda(T)) {
        for(i := 0; i<self.items.length; i++) {
            try {
                block_(self.items[i]);
            } catch(e:Exception) {
                if(e.message.equals("break")) {
                    break;
                }
            }
        }
    }
}

class Array<T:Object>
{
    include MObjectBase;

    include MArray;
}

inherit System
{
    def pcre_exec(regex:regex, str:Buffer, offset:int, ovec_max:int, ovec:PcreOVec): native static int;
    def atoi(str:String):native static int;
    def atof(str:String):native static float;
    def strtod(str:String): native static double throws Exception;
    def strcmp(str1:String, str2:String): native static int;
    def strcasecmp(str1:String, str2:String): native static int;
    def strtol(str:String, base:int): native static long throws Exception;
    def strtoul(str:String, base:int): native static ulong throws Exception;
    def mbstowcs(src:pointer@utf8-string-buffer-null-terminated, size:size_t): static native char[] throws Exception;
        # always null-terminated char[] returns
    def wcstombs(src:char[]): static native byte[] throws Exception;
        # always null-terminated byte[] returns

    def memset(str:pointer, value:int, size:size_t): static native;

    MB_LEN_MAX:static int;

    def initialize_string_system(): static native;

    def initialize(): static {
        initialize_string_system();
    }
    def isalpha(c:char): native static bool;
    def isalnum(c:char): native static bool;
    def iscntrl(c:char): native static bool;
    def isdigit(c:char): native static bool;
    def isgraph(c:char): native static bool;
    def islower(c:char): native static bool;
    def isprint(c:char): native static bool;
    def ispunct(c:char): native static bool;
    def isspace(c:char): native static bool;
    def isupper(c:char): native static bool;
    def isxdigit(c:char): native static bool;
    def isascii(c:char): native static bool;
    def isblank(c:char): native static bool;
}

inherit Clover
{
    def test(msg: String, expression:bool):static {
        printToError(msg.append("..."));
        assert(expression);
        printlnToError("OK");
    }
}

inherit Global
{
    def print(str:String):static {
        System.print(str);
    }
    def printToError(str:String):static {
        System.printToError(str);
    }
    def println(str:String):static {
        System.println(str);
    }
    def printlnToError(str:String):static {
        System.printlnToError(str);
    }
    def printf(str:String): static {
        System.print(str);
    }
    def printf(str:String, params:Array<Object>): static {
        str2 := sprintf(str, params);
        System.print(str2);
    }
    def printfToError(str:String, params:Array<Object>): static {
        str2 := sprintf(str, params);
        System.printToError(str2);
    }
    def sprintf(str:String, params:Array<Object>): static String {
        return System.sprintf(str, params);
    }
}

inherit System
{
    def sprintf(format:String, prams:Array<Object>): native static String throws Exception;
}

inherit String
{
    def next(): String {
        result := self.subString(0, -2);
        try {
            result = result.add(self.chars(-1).next().toString());
        }
        catch(e:Exception) {
        }

        return result;
    }
    def prev(): String {
        result := self.subString(0, -2);
        try {
            result = result.add(self.chars(-1).prev().toString());
        }
        catch(e:Exception) {
        }

        return result;
    }
    def printf(format:String): {
        Global.printf(format, array { self });
    }
    def sprintf(format:String): String {
        return Global.sprintf(format, array { self });
    }

    def insert(index:int, str:String): String {
        if(index < 0) {
            index += self.len + 1;
        }
        if(index < 0) {
            index = 0;
        }
        if(index > len) {
            index = self.len;
        }

        len := str.length();

        if(self.len+len + 1 < self.size) {
            i:=0;
            for(i=self.len -1; i>=index; i--) {
                self.buffer[i+len] = self.buffer[i];
            }
            for(i = 0; i<len; i++) {
                self.buffer[index+i] = str.buffer[i];
            }
            self.buffer[self.len+len] = '\0';

            self.len += len;
        }
        else {
            new_size:int = (self.len + len + 1) * 2 + 1;
            new_buffer:char[] = char[new_size];

            i := 0;
            for(i=0; i<index; i++) {
                new_buffer[i] = self.buffer[i];
            }
            for(i=index; i<self.len; i++) {
                new_buffer[i+len] = self.buffer[i];
            }
            for(i=0; i<len; i++) {
                new_buffer[index+i] = str.buffer[i];
            }
            new_buffer[self.len+len] = '\0';

            self.buffer = new_buffer;
            self.size = new_size;

            self.len += len;
        }

        return self;
    }

    def insert(index:int, c:char): String {
        if(index < 0) {
            index += self.len + 1;
        }
        if(index < 0) {
            index = 0;
        }
        if(index > len) {
            index = self.len;
        }

        len := 1;

        if(self.len+len + 1 < self.size) {
            i:=0;
            for(i=self.len -1; i>=index; i--) {
                self.buffer[i+len] = self.buffer[i];
            }
            for(i = 0; i<len; i++) {
                self.buffer[index+i] = c;
            }
            self.buffer[self.len+len] = '\0';

            self.len += len;
        }
        else {
            new_size:int = (self.len + len + 1) * 2 + 1;
            new_buffer:char[] = char[new_size];

            i := 0;
            for(i=0; i<index; i++) {
                new_buffer[i] = self.buffer[i];
            }
            for(i=index; i<self.len; i++) {
                new_buffer[i+len] = self.buffer[i];
            }
            for(i=0; i<len; i++) {
                new_buffer[index+i] = c;
            }
            new_buffer[self.len+len] = '\0';

            self.buffer = new_buffer;
            self.size = new_size;

            self.len += len;
        }

        return self;
    }

    def delete(index:int): String {
        if(index < 0) {
            index += self.len + 1;
        }
        if(index < 0) {
            index = 0;
        }
        if(index >= self.len) {
            index = self.len-1;
        }

        if(index >= 0 && index < self.len) {
            i := 0;
            for(i=index; i<self.len-1; i++) {
                self.buffer[i] = self.buffer[i+1];
            }
            self.buffer[i] = '\0';

            self.len --;
        }

        return self;
    }
    def deleteAt(index:int): String {
        return delete(index);
    }

    def delete(index:int, index2:int): String {
        if(index < 0) {
            index += self.len + 1;
        }
        if(index < 0) {
            index = 0;
        }

        if(index2 < 0) {
            index2 += self.len + 1;
        }
        if(index2 < 0) {
            index2 = 0;
        }

        if(index2 >= self.len) {
            index2 = self.len;
        }

        if(index < index2 && index < self.len && index2 <= self.len) {
            i := 0;
            for(i=index; i<self.len-(index2-index); i++) {
                self.buffer[i] = self.buffer[i+index2-index];
            }
            self.buffer[i] = '\0';

            self.len -= index2-index;
        }

        return self;
    }
    def deleteWithRange(index:int, index2:int): String {
        return delete(index, index2);
    }

    def subString(start:int, end:int):  String {
        if(start < 0) {
            start += self.len;
        }
        if(end < 0) {
            end += self.len + 1;
        }

        if(start < 0) {
            start = 0;
        }
        if(end > self.len) {
            end = self.len;
        }

        if(start >= end || start >= self.len || end < 0) {
            return "";
        }

        result: String = String(end-start+1);

        i := 0;
        for(i=0; i<end-start; i++) {
            result.buffer[i] = self.chars(i+start);
        }
        result.buffer[i] = '\0';

        result.len = end-start;
        result.size = end-start+1;

        return result;
    }

    def equals(right:WildCard):bool {
        return true;
    }

    def getHashKey():  uint {
        key:uint = 0;
        for(i:int =1; i<self.len; i++) {
            key += self.buffer[i].to_uint;
        }

        return key;
    }

    def toString():  String {
        return self;
    }

    def to_regex(): regex {
        return /\{self}/;
    }

    def printf(format:String): {
        Global.printf(format, array { self });
    }

    def print(): {
        Global.print(self);
    }

    def println(): {
        Global.println(self);
    }
    def printlnWithoutNullString() {
        if(self.len != 0) {
            Global.println(self);
        }
    }
    def printlnForREPL() {
        if(self.len != 0) {
            Global.println(self.clone().insert(0, "=>"));
        }
    }

    def match(regex_:regex): bool {
        ovec_max:int = 16;
        ovec:PcreOVec = PcreOVec(ovec_max);

        buffer:Buffer = self.toBuffer();

        offset:int = 0;
        regex_result:int = pcre_exec(regex_, buffer, offset, ovec_max, ovec);

        return regex_result > 0;
    }

    def each(block_:lambda(char)): String {
        for(i:int = 0; i<self.len; i++) {
            block_(self.buffer[i]);
        }

        return self;
    }


    def indexOf(str:String, count:int): int throws Exception {
        result:int = -1;
        count2:int = 0;
        len:int = str.length();

        for(i:=0; i<self.len; i++) {
            j:=0;
            for(j=0; j<str.len; j++) {
                if(self.buffer[i+j] != str.buffer[j]) 
                {
                    break;
                }
            }
            if(j == str.len) {
                count2++;
                if(count2 == count) {
                    result = i;
                    break;
                }
            }
        }

        return result;
    }


    def rindexOf(str:String, count:int=1):int {
        result := -1;
        count2 := 0;
        len := str.length();

        for(i:=self.len-len; i>=0; i--) {
            j:=0;
            for(j=0; j<len; j++) {
                if(self.buffer[i+j] != str.buffer[j]) 
                {
                    break;
                }
            }
            if(j == len) {
                count2++;
                if(count2 == count) {
                    result = i;
                    break;
                }
            }
        }

        return result;
    }

    def indexOf(str:String):  int {
        return self.indexOf(str, 1);
    }

    def indexOf(regex_:regex, count:int): int throws Exception {
        result:int = -1;
        offset:int = 0;
        count2:int = 0;

        buffer:Buffer = self.toBuffer();
        ovec_max:int = 16;
        ovec:PcreOVec = PcreOVec(ovec_max);

        while(true) {
            regex_result:int = pcre_exec(regex_, buffer, offset, ovec_max, ovec);

            ### match ###
            if(regex_result > 0) {
                count2++;
                if(count2 == count) {
                    ovec_result:int = ovec.start[0];

                    if(ovec_result == 0) {
                        result = 0;
                    }
                    else {
                        utf32_offset:int = 0;

                        p:pointer = buffer.buffer;
                        while(p < buffer.buffer + buffer.len) {
                            c:ubyte = p->ubyte;

                            # utf8 character
                            if(c > 127uy) {
                                size:int = ((c & 0x80) >> 7) + ((c & 0x40) >> 6) + ((c & 0x20) >> 5) + ((c & 0x10) >> 4);
                                if(size > MB_LEN_MAX) {
                                    throw Exception("unexpected error at String.indexOf");
                                }
                                else {
                                    p += size;
                                }

                                utf32_offset++;
                            }
                            # ascii
                            else {
                                p++;
                                utf32_offset++;
                            }

                            if(p - buffer.buffer == ovec_result) {
                                break;
                            }
                        }

                        result = utf32_offset;
                    }
                    break;
                }

                if(offset == ovec.end[0]) {
                    offset++;
                }
                else {
                    offset = ovec.end[0];
                }
            }
            ### no match ###
            else {
                break;
            }
        }

        return result;
    }

    def indexOf(regex_:regex): int {
        return self.indexOf(regex_, 1);
    }

    def upperCase(): String {
        for(i:int = 0; i<self.len; i++) {
            self.buffer[i] = self.buffer[i].to_upper;
        }

        return self;
    }

    def lowerCase(): String {
        for(i:int = 0; i<self.len; i++) {
            self.buffer[i] = self.buffer[i].to_lower;
        }

        return self;
    }

    def to_int():  int {
        return atoi(self);
    }

    def to_float():  float {
        return atof(self);
    }

    def to_double():  double {
        return strtod(self);
    }

    def multiply(value:int):  String {
        result:String = String();

        for(i:int = 0; i<value; i++) {
            result.append(self);
        }

        return result;
    }

    def reverse(): String {
        result:String = String(self.size);

        i := 0;
        for(i=0; i<self.len; i++) {
            result.buffer[i] = self.buffer[self.len-i-1];
        }
        result.buffer[i] = '\0';

        result.len = self.len;

        return result;
    }

    # same: 0, self > str: > 0, self < str: < 0
    def compare(str:String):  int {
        return strcmp(self, str);
    }

    # same: 0, self > str: > 0, self < str: < 0
    def compareWithIgnoreCase(str:String):  int {
        return strcasecmp(self, str);
    }

    def hex():  int {
        if(self.chars(0) == '0' && self.chars(1) == 'x') {
            return strtol(self, 0).to_int;
        }
        else {
            str := self.clone();
            str.insert(0, "0x");

            return strtol(str, 0).to_int;
        }
    }

    def oct():  int {
        return strtol(self, 0).to_int;
    }

    def chomp():  String {
        result:String = "";

        if(self.length() >= 2) {
            if(self.chars(-2) == '\r' && self.chars(-1) == '\n') {
                result = self.subString(0,-3);
            }
            elif(self.chars(-1) == '\r' || self.chars(-1) == '\n') {
                result = self.subString(0,-2);
            }
            else {
                result = self;
            }
        }
        elif(self.length() >= 1) {
            if(self.chars(-1) == '\r' || self.chars(-1) == '\n') {
                result = self.subString(0,-2);
            }
            else {
                result = self;
            }
        }

        return result;
    }

    def toBuffer():  Buffer throws Exception {
        array_ := wcstombs(self.buffer);

        result:Buffer = Buffer(array_.length-1);
        for(i:int = 0; i<array_.length-1; i++) {
            result.append(array_[i]);
        }

        # no null-terminated Buffer will be returened

        return result;
    }
}

inherit Buffer 
{
    def append(data: char) throws Exception {
        append(data.toString().toBuffer());
    }

    def toString():String throws Exception {
        wcs:char[] = mbstowcs(self.buffer, self.len);
        result:String = String(wcs);
        return result;
    }

    def toStringFromPointedPoint(): String {
        wcs:char[] = mbstowcs(self.p, self.len - (self.p - self.buffer));
        result:String = String(wcs);
        return result;
    }

    # same: 0, self > str: > 0, self < str: < 0
    def compare(str:Buffer):  int {
        return memcmp(self.head(), str.head(), self.len);
    }

    def add(right:Buffer): Buffer {
        result := Buffer();
        result.append(self);
        result.append(right);
        return result;
    }

    def clear(): Buffer {
        self.len = 0;
        memset(self.buffer, 0, self.size);

        return self;
    }
}

module MPrintOutObject
{
    def printf(format:String) {
        Global.printf(format, array { self });
    }
    def sprintf(format:String):String {
        return Global.sprintf(format, array { self });
    }
    def print() {
        Global.print(self.toString());
    }
    def println() {
        Global.println(self.toString());
    }
}

inherit Byte 
{
    include MPrintOutObject;
}

inherit UByte 
{
    include MPrintOutObject;
}

inherit Short 
{
    include MPrintOutObject;
}

inherit UShort 
{
    include MPrintOutObject;
}

inherit Integer 
{
    include MPrintOutObject;
}

inherit UInteger 
{
    include MPrintOutObject;
}

inherit Long 
{
    include MPrintOutObject;
}

inherit ULong 
{
    include MPrintOutObject;
}

inherit Float 
{
    include MPrintOutObject;
}

inherit Double
{
    include MPrintOutObject;
}

inherit Pointer
{
    include MPrintOutObject;
}

inherit Char
{
    include MPrintOutObject;
}

inherit Bool
{
    include MPrintOutObject;
}

inherit Char
{
    def isalpha(): bool {
        return System.isalpha(self);
    }
    def isalnum(): bool {
        return System.isalnum(self);
    }
    def iscntrl(): bool {
        return System.iscntrl(self);
    }
    def isdigit(): bool {
        return System.isdigit(self);
    }
    def isgraph(): bool {
        return System.isgraph(self);
    }
    def islower(): bool {
        return System.islower(self);
    }
    def isprint(): bool {
        return System.isprint(self);
    }
    def ispunct(): bool {
        return System.ispunct(self);
    }
    def isspace(): bool {
        return System.isspace(self);
    }
    def isupper(): bool {
        return System.isupper(self);
    }
    def isxdigit(): bool {
        return System.isxdigit(self);
    }
    def isascii(): bool {
        return System.isascii(self);
    }
    def isblank(): bool {
        return System.isblank(self);
    }
}

inherit timespec
{
    def toString():String {
        return sprintf("%lu.%09lu sec", array { self.tv_sec.toULong, self.tv_nsec.toULong });
    }
}