Runtime.avt

/*
    Исходный код среды исполнения ПВТ-ОО.

    Этот исходный код является частью проекта ПВТ-ОО.

    Copyright © 2021 Малик Разработчик

    Это свободная программа: вы можете перераспространять её и/или
    изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
    в каком она была опубликована Фондом свободного программного обеспечения;
    либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.

    Эта программа распространяется в надежде, что она может быть полезна,
    но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
    или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
    общественной лицензии GNU.

    Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
    вместе с этой программой. Если это не так, см.
    <http://www.gnu.org/licenses/>.
*/

package avt.lang;

import platform.dependent.*;
import platform.independent.filesystem.*;

public abstract class Runtime(Object)
{
    private static Runtime instance;

    public static Runtime getInstance() { return instance; }

    /*<fold Runtime main constructor invocation>*/
        protected static native void invokeMainConstructor(Runtime instance);
    /*</fold>*/

    /*<fold routines of the collectGarbage method>*/
        protected static void invokeBeforeDestruction(long pointer) {
            try
            {
                Object instance = toInstance(pointer);
                if(!instance.getClass().isArray()) instance.beforeDestruction();
            } catch(Throwable e) {  }
        }

        protected static native void releaseRefsInInstance(long pointer);

        protected static native long refsFromInstance(long pointer, long target);

        protected static native long2 refsToInstance(long pointer);
    /*</fold>*/

    /*<fold routines of the allocateInstance method>*/
        protected static native Object initializeInstance(long pointer, Class type, long size, int length);
    /*</fold>*/

    /*<fold routines of the intern method>*/
        protected static native Class getInstanceClass(long pointer);

        protected static native Object toInstance(long pointer);
    /*</fold>*/

    /*<fold routines of the isProtectedMemory method>*/
        protected static boolean isIntersectRegion(long beginPointer1, long endPointer1, long beginPointer2, long endPointer2) {
            long beginPointer3 = beginPointer1 >= beginPointer2 ? beginPointer1 : beginPointer2;
            long endPointer3 = endPointer1 < endPointer2 ? endPointer1 : endPointer2;
            return beginPointer3 < endPointer3;
        }

        protected static native boolean isIntersectRegion(Object instance, long instanceSize, long beginPointer, long endPointer);
    /*</fold>*/

    package static void invokeAfterConstruction(Object instance) { instance.afterConstruction(); }

    private static native int getProcessorBrandString(byte[] dst);

    private static native long2 getProgrammeCodeRegion();

    private static native long2 getProgrammeDataRegion();


    private boolean fldMultiThreaded;
    private long fldCollectedBytes;
    private final Mutex fldSystemMutex;
    private final String fldProcessorBrandString;
    private final Object fldGarbageCollectorMonitor;

    protected () {
        if(instance != null)
        {
            throw new SecurityException("создание ещё одной среды исполнения невозможно");
        }
        instance = this;
        byte[] processorBrandStringBytes = new byte[48];
        int processorBrandStringLength = getProcessorBrandString(processorBrandStringBytes);
        char[] processorBrandStringChars = new char[processorBrandStringLength];
        for(int i = processorBrandStringLength; i-- > 0; ) processorBrandStringChars[i] = (char) (processorBrandStringBytes[i] & 0xffi);
        fldSystemMutex = new Mutex();
        fldProcessorBrandString = new String(processorBrandStringChars, 0, processorBrandStringLength);
        fldGarbageCollectorMonitor = new Object();
    }

    public abstract long freeMemory();

    public abstract long totalMemory();

    public void exit(int statusCode) { throw new SecurityException("выход с помощью Runtime.exit не поддерживается"); }

    public final void gc() { synchronized with(fldGarbageCollectorMonitor) { notify(); } }

    public final long collectedBytes() { return fldCollectedBytes; }

    protected abstract void collectGarbage();

    protected abstract Object allocateInstance(Class type, long size, int length, boolean executable);

    protected abstract String intern(String string);

    protected void nowMultiThreaded() {  }

    protected boolean isProtectedMemory(long beginPointer, long endPointer) {
        long2 codeRegion = getProgrammeCodeRegion();
        long2 dataRegion = getProgrammeDataRegion();
        return isIntersectRegion(beginPointer, endPointer, codeRegion[0], codeRegion[1]) || isIntersectRegion(beginPointer, endPointer, dataRegion[0], dataRegion[1]);
    }

    protected final void afterConstruction() {
        Thread.initialize();
        with((Thread) (new GarbageCollectorThread(fldGarbageCollectorMonitor)))
        {
            priority = MIN_PRIORITY;
            start();
        }
    }

    protected final void beforeDestruction() {  }

    protected final void modCollectedBytes(long delta) { fldCollectedBytes += delta; }

    protected abstract String operatingSystemName { read }

    protected abstract String operatingSystemVersion { read }

    protected abstract FileSystem localFileSystem { read }

    protected int processorCodeBits { read = 64 }

    protected int processorNumberOfCores { read = 1 }

    protected String lineSeparator { read = "\n" }

    protected final boolean multiThreaded { read = fldMultiThreaded }

    protected final String processorBrandString { read = fldProcessorBrandString }

    package final void setMultiThreaded() {
        if(!fldMultiThreaded)
        {
            fldMultiThreaded = true;
            nowMultiThreaded();
        }
    }

    package final Mutex systemMutex { read = fldSystemMutex }
}

final class GarbageCollectorThread(Thread)
{
    private boolean fldLaunched;
    private final Object fldGarbageCollectorMonitor;

    public (Object garbageCollectorMonitor) { fldGarbageCollectorMonitor = garbageCollectorMonitor; }

    public void run() {
        if(!fldLaunched)
        {
            fldLaunched = true;
            try
            {
                Runtime runtime = Runtime.getInstance();
                do
                {
                    Thread.clean();
                    runtime.collectGarbage();
                    pause();
                } while(true);
            }
            catch(Throwable e)
            {
                e.printStackTrace();
            }
        }
    }

    public void interruptio() { throw new SecurityException("невозможно прервать автоматический сбор мусора"); }

    private void pause() throws InterruptedException { synchronized with(fldGarbageCollectorMonitor) { wait(6000L); } }
}