lcl

folder lx01.platform

class System {
	MemoryBlock allocateMemoryBlock (int size) {
    	return allocate0(size).cast(MemoryBlock.class)
    }

    private native BridgeObject allocate0 (int size)

    abstract class MemoryBlock {
    	MemoryBlock new () {
        	return System.allocateMemoryBlock(getBlockSize())
        }

        abstract int getBlockSize()
    }
}

class Object extends System.MemoryBlock {
	Object new () {
    	return super.new().cast(Object.class)
    }

	int getBlockSize () {
    	define Variable[] vars(class.this().getVariables())
        define int size(0)
        for (i(vars.length))
        	define size(size + vars[i].getType().getFunction("getBlockSize").callWithResult())
        return size
    }
}

abstract class Reader extends Object {
	abstract Reader new ()

    Reader empty () {
    	return ReaderImpl.new()
    }

    abstract instance void close ()

    abstract instance char read ()

    instance string readAll () {
    	define char[] data(new char[])
        define char read(instance.read())
        while (read != Character.EOF) {
        	data.add(read)
            define read(instance.read())
        }
        return string.of(data)
    }

    abstract instance boolean readable ()

    abstract instance void reset ()

    abstract instance void skip (int amt)

    abstract instance int available ()

    instance void writeAll (Writer w) {
    	w.write(instance.readAll())
    }
}

hidden class ReaderImpl extends Reader {
	ReaderImpl new () {
    	return super.new().cast(ReaderImpl.class)
    }

    instance void close () {}

    instance char read () {
    	return Character.EOF
    }

    instance boolean readable () {
    	return false
    }

    instance void reset () {}

    instance void skip (int amt) {}

    instance int available () {
    	return 0;
    }

    instance void writeAll (Writer w) {
    	w.write(instance.readAll())
    }
}

class FileReader extends Reader {
	instance boolean closed(false)
    final instance File path

	FileReader new (File path) {
    	define FileReader inst(super.new().cast(FileReader.class))
        set inst.path(path)
        return inst
    }

    instance void close () {
    	set instance.path(null)
        set instance.closed(true)
    }

    instance char read () {
    	if (!instance.closed)
        	return read0(instance.path.getName(), instance.pointer)
    }

    private native char read0 (string name, int pointer)

    instance boolean readable () {
    	return !instance.closed
    }

    instance void reset () {
    	instance = FileReader.new(instance.path)
    }

    instance void skip (int skip) {
    	if (skip > instance.available()) throw new IndexBoundsError("Cannot skip more than is available")
    	set instance.pointer(instance.pointer + skip)
    }

    instance int available () {
    	return available0(instance.path.getName(), instance.pointer)
    }

    private native int available0 (string name, int pointer)
}

abstract class BufferedReader extends Reader {
	final instance string buffer
	instance int pointer(0)
	instance boolean closed(false)

	abstract BufferedReader new ()

    instance char read () {
    	if (!instance.closed) {
        	return instance.buffer.getChars()[instance.pointer]
            set instance.pointer(instance.pointer + 1)
        }
    }

    instance string readAll () {
    	set instance.pointer(instance.buffer.getLength())
    	return instance.buffer
    }

    instance boolean readable () {
    	return !instance.closed
    }

    instance void reset () {
    	instance = FileReader.new(instance.path)
    }

    instance void skip (int skip) {
    	if (skip > instance.available()) throw new IndexBoundsError("Cannot skip more than is available")
    	instance.pointer = instance.pointer + skip
    }

	instance int available () {
		return instance.buffer.getLength() - instance.pointer
    }
}

class BufferedFileReader extends BufferedReader {
	BufferedFileReader new (File path) {
    	define BufferedFileReader inst(super.new().cast(BufferedFileReader.class)
        define FileReader reader(FileReader.new(path))
        set inst.buffer(reader.readAll())
        return inst
    }
}