Fundamental.clcl

module MObjectBase 
{
    def map(block_:lambda(SELF):Anonymous?): Anonymous? {
        return block_(self);
    }
    def filter(block_:lambda(SELF):SELF): SELF {
        return block_(self);
    }
    def nothing(): SELF {
        return self;
    }
    def noException(block_:lambda(SELF):SELF): SELF? {
        result:SELF? = null;
        try {
            result = block_(self);
        }
        catch(e:Exception) {
        }

        return result;
    }
}

class System
{
    typedef size_t ulong;
    typedef ssize_t ulong;
    typedef time_t ulong;

    def initialize() {}

    def assert(exp:bool): native static throws Exception;
    def exit(num:int): native static;
    def sleep(time:int): native static uint;

    def malloc(size:size_t): native static pointer@alloc;
    def calloc(number: int, size: size_t): native static pointer@alloc;
    def realloc(ptr:pointer, size: size_t): native static pointer@alloc;
    def strdup(str:pointer): native static pointer@alloc;
    def free(ptr:pointer): native static;
    def GC_malloc(size:size_t):native static GCMemory;

    def strlen(ptr:pointer): native static int;
    def strlen(array:byte[]): native static int;
    def strcpy(str1:pointer, str2:pointer): native static pointer;
    def strncpy(str1:pointer, str2:pointer, size:size_t): native static pointer;
    def memcpy(str1:pointer, str2:pointer, size:size_t): native static pointer;
    def memcmp(str1:pointer, str2:pointer, size:size_t): native static int;

    def srand(value:uint): static native;
    def rand(): static native int;
    def time(): static native time_t throws Exception;

    def getenv(name:String): static native String?;
    def setenv(name:String, value:String, overwrite:int = 1): static native throws Exception;
    def unsetenv(name:String): static native throws Exception;

    def print(str:String): native static;
    def println(str:String): native static;
    def printToError(str:String): native static;
    def printlnToError(str:String): native static;
}

class GCMemory
{
    memory:pointer;
    size:size_t;
}

class Global
{
    def initialize() {}
}

class String
{
    include MObjectBase;

    buffer: char[];
    size:int;
    len:int;

    def initialize() {
        self.buffer = char[128]();
        self.buffer[0] = '\0';

        self.size = 128;
        self.len = 0;
    }

    def initialize(size:int) {
        self.buffer = char[size+1]();
        self.buffer[0] = '\0';

        self.size = size + 1;
        self.len = 0;
    }

    def initialize(buffer:char[]) {
        setValue(buffer);
    }

    def initialize(str:String) {
        setValue(str);
    }

    def clone():String {
        result := "";
        result.setValue(self);
        return result;
    }

    def setValue(str: String) {
        len := str.length();
        size := len * 2 + 1;

        self.buffer = char[size]();

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

        self.len = len;
        self.size = size;
    }

    def setValue(buffer:char[]) {
        self.buffer = buffer;
        self.len = buffer.length-1;
        self.size = buffer.length;
    }

    def chars(index:int):char throws Exception {
        if(index < 0) {
            index += self.len;
        }

        if(index < 0) {
            index = 0;
        }
        if(index >= self.len) {
            index = self.len -1;
        }

        if(index >= 0 && index < self.len) {
            return self.buffer[index].toChar;
        }
        else {
            throw Exception("Out of range in String.char");
        }
    }

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

    def add(str:String): String {
        result := self.clone();
        result.append(str);
        return result;
    }

    def append(str: String):  String {
        len := str.length();

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

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

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

            self.buffer = new_buffer;
            self.len += len;
            self.size = new_size;
        }

        return self;
    }

    def append(c:char):  String {
        len := 1;

        if(self.len+len+1 < self.size) {
            self.buffer[self.len] = c;
            self.buffer[self.len+1] = '\0';

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

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

            self.buffer = new_buffer;
            self.len += len;
            self.size = new_size;
        }

        return self;
    }

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

        if(index < 0) {
            index = 0;
        }
        if(index >= self.len) {
            index = self.len -1;
        }

        self.buffer[index] = c;
    }

    def equals(str: String):  bool {
        if(str.is("WildCard")) {
            return true;
        }
        else {
            if(self.len == str.length()) {
                for(i := 0; i<self.len; i++) {
                    if(self.buffer[i] != str.buffer[i]) {
                        return false;
                    }
                }

                return true;
            }
            else {
                return false;
            }
        }
    }
}

class Buffer
{
    include MObjectBase;

    buffer:pointer;
    len:size_t;
    size:size_t;

    p:pointer;

    appendable:bool;

    def initialize() {
        self.size = 64;
        self.buffer = malloc(self.size);
        self.len = 0;
        self.appendable = true;

        self.p = self.buffer;
    }
    def initialize(buf:pointer, size:size_t, appendable:bool=true) {
        if(appendable) {
            self.buffer = malloc(size);
            memcpy(self.buffer, buf, size);
            self.len = size;
            self.size = size;
            self.appendable = true;
            self.p = self.buffer;
        }
        else {
            self.buffer = buf;
            self.len = size;
            self.size = size;
            self.appendable = false;
            self.p = buf;
        }
    }
    def initialize(size:size_t) {
        self.size = size;
        self.buffer = malloc(self.size);
        self.len = 0;
        self.appendable = true;

        self.p = self.buffer;
    }
    def finalize() {
        if(self.appendable) {
            free(self.buffer);
        }
    }

    def alignment() {
        self.len = (self.len +3) & ~3;
    }

    def append(buf:Buffer) throws Exception {
        if(!self.appendable) {
            throw Exception("This memory is not appendable");
        }

        len: size_t = buf.len;

        if(self.len + len >= self.size) {
            offset := self.p - self.buffer;

            new_size:size_t = (self.len+len+1) * 2;
            self.buffer = realloc(self.buffer, new_size);
            self.size = new_size;

            self.p = self.buffer + offset;
        }

        memcpy(self.buffer + self.len, buf.buffer, len);
        self.len += len;
    }

    def append(data:byte) throws Exception {
        if(!self.appendable) {
            throw Exception("This memory is not appendable");
        }

        len: size_t = 1.to_ulong;

        if(self.len + len >= self.size) {
            offset := self.p - self.buffer;

            new_size:size_t = (self.len+len+1) * 2;
            self.buffer = realloc(self.buffer, new_size);
            self.size = new_size;

            self.p = self.buffer + offset;
        }

        (self.buffer + self.len)->byte = data;
        self.len += len;
    }

    def chars(index:int):byte throws Exception {
        if(index < 0) {
            index += self.len;
        }
        if(index < 0) {
            index = 0;
        }
        if(index >= self.len) {
            index = self.len -1;
        }

        if(index >= 0 && index < self.len) {
            return((self.buffer + index.to_ulong)->byte);
        }
        else {
            throw Exception("Invalid range on Buffer.chars");
        }
    }

    def chars(index:ulong):byte throws Exception {
        if(index >= 0 && index < self.len) {
            return((self.buffer + index)->byte);
        }
        else {
            throw Exception("Invalid range on Buffer.char");
        }
    }

    def equals(buf:Buffer):bool {
        if(buf.is("WildCard")) {
            return true;
        }
        else {
            if(self.len != buf.len) {
                return false;
            }

            for(i:size_t = 0; i<self.len; i++) {
                if(self.chars(i) != buf.chars(i)) {
                    return false;
                }
            }

            return true;
        }
    }

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

    def clone():Buffer {
        if(appendable) {
            result := Buffer(self.size);

            memcpy(result.buffer, self.buffer, self.size);
            result.len = self.len;
            result.size = self.size;
            result.appendable = true;
            result.p = result.p;

            return result;
        }
        else {
            result := Buffer(self.buffer, self.size, false);

            result.buffer = self.buffer;
            result.len = self.len;
            result.size = self.size;
            result.appendable = false;
            result.p = self.p;

            return result;
        }
    }

    def head():pointer {
        return self.buffer;
    }

    def tail():pointer {
        return self.buffer + self.len;
    }

    def toPointer():pointer {
        return self.buffer;
    }

    def toPointerAtPoitedPoint():pointer {
        return self.p;
    }

    def subBuffer(start:int, end:int): Buffer {
        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 B"";
        }

        result: Buffer = Buffer(end.to_ulong-start.to_ulong);

        memcpy(result.buffer, self.buffer + start.to_ulong, (end-start).to_ulong);

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

        # no null-terminated buffer will be returned

        return result;
    }

    def length(): size_t {
        return self.len;
    }

    def next(): Buffer {
        result := self.clone();
        result++;
        return result;
    }

    def prev(): Buffer {
        result := self.clone();
        result--;
        return result;
    }
}

class Exception
{
#    include MObjectBase;

    message:String;

    def initialize() { 
        self.message = "";
    }

    def initialize(message:String) {
        self.message = message;
    }
    def clone(): Exception {
        if(message.identifyWith(null)) {
            return Exception("");
        }
        else {
            return Exception(message.clone());
        }
    }
}

interface Object
{
}

class Clover
{
    ARGC:static int;
    ARGV:static String[];
    VERSION:static String;

    CLOVER2_OBJECT_HEADER_SIZE:static ulong;
    CLOVER2_OBJECT_FIELD_SIZE:static ulong;

    def initialize() {}

    def initialize_lang(): static native;

    def initialize():static {
        initialize_lang();
        srand(System.time().to_uint);
    }

    def onException(message:String, in_try:bool):static {
        if(!in_try) {
            System.printlnToError(message);
        }
    }

    def gc():static native;
    def compaction():static native;

    def load(class_name:String, js:bool=false): native throws Exception;
}

module MWrapperClassBase 
{
    def toByte(): Byte {
        return self.value.toByte;
    }

    def toUByte(): UByte {
        return self.value.toUByte;
    }

    def toShort(): Short {
        return self.value.toShort;
    }

    def toUShort(): UShort {
        return self.value.toUShort;
    }

    def toInteger(): Integer {
        return self.value.toInteger;
    }

    def toUInteger(): UInteger {
        return self.value.toUInteger;
    }

    def toLong(): Long {
        return self.value.toLong;
    }

    def toULong(): ULong {
        return self.value.toULong;
    }

    def toChar(): Char {
        return self.value.toChar;
    }

    def toBool(): Bool {
        return self.value.toBool;
    }

    def toString(): String {
        return self.value.toString;
    }

    def equals(right:SELF): bool {
        if(right.is("WildCard")) {
            return true;
        }
        else {
            return self.value == right.value;
        }
    }

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

    def compare(right:SELF):  int {
        if(self.value < right.value) {
            return -1;
        }
        elif(self.value == right.value) {
            return 0;
        }
        else {
            return 1;
        }
    }

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

        result.value = self.value;

        return result;
    }
}

module MOperand
{
    def add(right:SELF): SELF {
        return self + right;
    }

    def sub(right:SELF): SELF {
        return self - right;
    }

    def multiply(right:SELF): SELF {
        return self * right;
    }

    def divide(right:SELF): SELF {
        return self / right;
    }

    def mod(right:SELF): SELF {
        return self % right;
    }

    def lshift(right:SELF): SELF {
        return self << right;
    }

    def rshift(right:SELF): SELF {
        return self >> right;
    }

    def and(right:SELF): SELF {
        return self & right;
    }

    def xor(right:SELF): SELF {
        return self ^ right;
    }

    def or(right:SELF): SELF {
        return self | right;
    }

    def next(): SELF {
        result := self.clone();
        result.value++;
        return result;
    }

    def prev(): SELF {
        result := self.clone();
        result.value--;
        return result;
    }
}

module MOperandFloat
{
    def add(right:SELF): SELF {
        return self + right;
    }

    def sub(right:SELF): SELF {
        return self - right;
    }

    def multiply(right:SELF): SELF {
        return self * right;
    }

    def divide(right:SELF): SELF {
        return self / right;
    }

    def next(): SELF {
        result := self.clone();
        result.value = result.value + 1;
        return result;
    }

    def prev(): SELF {
        result := self.clone();
        result.value = result.value - 1;
        return result;
    }
}

class Byte : unboxing byte
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:byte;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:byte) {
        self.value = value;
    }

    def getValue(): byte {
        return self.value;
    }

    def setValue(value:byte) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class UByte : unboxing ubyte
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:ubyte;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:ubyte) {
        self.value = value;
    }

    def getValue(): ubyte {
        return self.value;
    }

    def setValue(value:ubyte) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class Short : unboxing short
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:short;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:short) {
        self.value = value;
    }

    def getValue(): short {
        return self.value;
    }

    def setValue(value:short) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class UShort : unboxing ushort
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:ushort;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:ushort) {
        self.value = value;
    }

    def getValue(): ushort {
        return self.value;
    }

    def setValue(value:ushort) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class Integer : unboxing int
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:int;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:int) {
        self.value = value;
    }

    def getValue(): int {
        return self.value;
    }

    def setValue(value:int) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }

    def times(block_:lambda()) {
        for(i:int = 0; i<self.value; i++) {
            try {
                block_();
            } catch(e:Exception) {
                if(e.message.equals("break")) {
                    break;
                }
            }
        }
    }
}

class UInteger : unboxing uint
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value: uint;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:uint) {
        self.value = value;
    }

    def getValue(): uint {
        return self.value;
    }

    def setValue(value:uint) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class Long : unboxing long
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value:long;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:long) {
        self.value = value;
    }

    def getValue(): long {
        return self.value;
    }

    def setValue(value:long) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class ULong : unboxing ulong
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperand;

    value: ulong;

    def initialize() {
        self.value = 0;
    }

    def initialize(value:ulong) {
        self.value = value;
    }

    def getValue(): long {
        return self.value;
    }

    def setValue(value:long) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class Float : unboxing float
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperandFloat;

    value: float;

    def initialize() {
        self.value = 0.0f;
    }

    def initialize(value:float) {
        self.value = value;
    }

    def getValue(): float {
        return self.value;
    }

    def setValue(value:float) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }
}

class Double : unboxing double
{
    include MObjectBase;
    include MWrapperClassBase;
    include MOperandFloat;

    value: double;

    def initialize() {
        self.value = 0.0;
    }

    def initialize(value:double) {
        self.value = value;
    }

    def getValue(): double {
        return self.value;
    }

    def setValue(value:double) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble;
    }
}

class Pointer : unboxing pointer
{
    include MObjectBase;
    include MWrapperClassBase;

    value: pointer;

    def initialize() {
        self.value = 0.to_pointer;
    }

    def initialize(value:pointer) {
        self.value = value;
    }

    def initialize(value:int) {
        self.value = value.to_pointer;
    }

    def getValue(): pointer {
        return self.value;
    }

    def setValue(value:pointer) {
        self.value = value;
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }
}

class Char : unboxing char
{
    include MObjectBase;
    include MWrapperClassBase;

    value: char;

    def initialize() {
        self.value = 0.to_char;
    }

    def initialize(value:char) {
        self.value = value;
    }

    def initialize(value:int) {
        self.value = value.to_char;
    }

    def getValue(): char {
        return self.value;
    }

    def setValue(value:char) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }

    def toLowerCase():Char {
        if(self.value >= 'A' && self.value <= 'Z') {
            return self.value - 'A' + 'a';
        }
        else {
            return self.value;
        }
    }

    def toUpperCase():Char {
        if(self.value >= 'a' && self.value <= 'z') {
            return self.value - 'a' + 'A';
        }
        else {
            return self.value;
        }
    }

    def multiply(n:int):String {
        result := "";

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

    def prev():Char {
        result := self.clone();
        result.value--;
        return result;
    }

    def next():Char {
        result := self.clone();
        result.value++;
        return result;
    }
}

class Bool : unboxing bool
{
    include MObjectBase;
    value: bool;

    def initialize() {
        self.value = false;
    }

    def initialize(value:bool) {
        self.value = value;
    }

    def initialize(value:int) {
        self.value = value.to_bool;
    }

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

        result.value = self.value;

        return result;
    }

    def getValue(): bool {
        return self.value;
    }

    def setValue(value:bool) {
        self.value = value;
    }

    def toFloat():Float {
        return self.value.toFloat;
    }

    def toDouble():Double {
        return self.value.toDouble
    }

    def toPointer():Pointer {
        return self.value.toPointer;
    }

    def toByte():Byte {
        return self.value.toByte;
    }

    def toUByte():UByte {
        return self.value.toUByte;
    }

    def toShort():Short {
        return self.value.toShort;
    }

    def toUShort():UShort {
        return self.value.toUShort;
    }

    def toInteger():Integer {
        return self.value.toInteger;
    }

    def toUInteger():UInteger {
        return self.value.toUInteger;
    }

    def toLong():Long {
        return self.value.toLong;
    }

    def toULong():ULong {
        return self.value.toULong;
    }

    def toChar():Char {
        return self.value.toChar;
    }

    def toBool():Bool {
        return self.value.toBool;
    }

    def toString():String {
        return self.value.toString;
    }

    def equals(right:Bool):bool {
        if(right.is("WildCard")) {
            return true;
        }
        else {
            return self.value == right.value;
        }
    }

    def equals(right:WildCard):bool {
        return true;
    }
    
    def and(right:Bool):Bool {
        return self && right;
    }
    
    def or(right:Bool) : Bool {
        return self || right;
    }

    def negative(): bool {
        return !self.value;
    }

    def if(false_value:Anonymous?, block_:lambda():Anonymous?):Anonymous? {
        if(self.value) {
            result := false_value;
            try {
                result = block_();
            }
            catch(e:Exception) {
                result = false_value
            }

            return result;
        }

        return false_value;
    }

    def if(block_:lambda():Anonymous?):Anonymous? { 
        self.if(null, block_); 
    }

    def ifWithException(block_:lambda()):Anonymous? throws Exception {
        if(self.value) {
            return block_();
        }

        throw Exception("ifWithException is faield");

        null;
    }
    def cond(false_value:Anonymous?, block_:lambda():Anonymous?):Anonymous? {
        if(self.value) {
            return block_();
        }

        return false_value;
    }

    def cond(block_:lambda():Anonymous?):Anonymous? { 
        self.cond(null, block_); 
    }
}

class Null
{
    def toString():String {
        return ""
    }
    def to_bool():bool {
        return false;
    }
/*
    def equals(right:Null): bool {
        return true;
    }
    def compare(right:Null): bool {
        return true;
    }
    def clone(): Null? {
    }
    def getHashKey(): uint {
        return 0;
    }
    def add(right:Null): Null {
    }
*/
}