mikehearn

// A couple of inlined utility functions: the first is just a syntax convenience, the second lets us use
// Kotlin's string interpolation efficiently: the message is never calculated/concatenated together unless
// logging at that level is enabled.
inline fun <reified T : Any> loggerFor(): org.slf4j.Logger = LoggerFactory.getLogger(T::class.java)
inline fun org.slf4j.Logger.trace(msg: () -> String) {
    if (isTraceEnabled) trace(msg())
}

/**
 * A Java logging formatter that writes more compact output than the default.

mikehearn

Here are some rough notes on things observed in the codebase - not by the Espresso authors so may all be totally wrong.

Native components

Espresso is mostly written in Java but has some C components as well. These serve two purposes:

1. The espresso engine can be compiled with native-image down to a shared library so it no longer needs hotspot and runs AOT. This is called “libespresso”
2. Native code components from OpenJDK that use internal HotSpot APIs can be loaded. This allows a high degree of code re-use and means that unlike most JVM implementations, this one doesn’t need to implement the JDK class library, not even tricky parts in java.base or internal modules - in fact the classes you’d find in the java.base module in a regular OpenJDK should work as long as it’s of the right versions.

OpenJDK native code components include libjava, libjimage etc. These can be loaded as genuinely native components and also (it appears) via Sulong, which on GraalVM EE would give you sandboxing of these compon

mikehearn

package hydraulic.utils.config

import com.natpryce.hamkrest.assertion.assertThat
import com.natpryce.hamkrest.containsSubstring
import com.typesafe.config.Config
import com.typesafe.config.ConfigException
import com.typesafe.config.ConfigFactory
import com.typesafe.config.ConfigValueFactory
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull

mikehearn

package hydraulic.utils.config

import com.natpryce.hamkrest.isBlank
import com.typesafe.config.*
import com.typesafe.config.ConfigException.BadValue
import hydraulic.kotlin.utils.text.camelToKebabCase
import hydraulic.utils.app.UserInput
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type
import java.lang.reflect.WildcardType

mikehearn

#!/usr/bin/env bash

#
# To use, unpack a regular JDK somewhere and set JDK_HOME to point to it. The default here expects a JDK 15 early access
# in the same directory but you can set JDK_HOME to anything.
#

JDK_HOME=${JDK_HOME:-$PWD/jdk-15.jdk/Contents/Home}

# 

mikehearn

// Contact: hearn@vinumeris.com

package lighthouse.threading;

import com.google.common.util.concurrent.Uninterruptibles;
import javafx.application.Platform;
import lighthouse.protocol.LHUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

mikehearn

// This is a class that attempts to stop you accessing variables outside a lock.
//
// It does not do a perfect job, but can catch some common kinds of mistake, in
// particular when you accidentally try to work with objects inside closures that
// end up running later, outside the locked region (or in a different thread).

// EXAMPLE

val bank = ThreadBox(object {
    val accounts by arrayListOf(10, 0, 0, 0).guard()

mikehearn

import net.plan99.nodejs.NodeJS;

public class Demo {
    public static void main(String[] args) {
        int result = NodeJS.runJS(() ->
            NodeJS.eval("return 2 + 3 + 4").asInt()
        );
        System.out.println(result);
    }
}

mikehearn

typealias WSTR = CPointer<ShortVar>

private fun WSTR.toKString(): String = memScoped {
    // Figure out how much memory we need after UTF-8 conversion.
    val sz = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, this@toKString, -1, null, 0, null, null)
    // Now convert to UTF-8 and from there, a String.
    val utf8 = allocArray<ByteVar>(sz)
    val r = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, this@toKString, -1, utf8, sz, null, null)
    if (r == 0) throw RuntimeException("Could not convert to UTF-8")
    utf8.toKString()

mikehearn

enum tinyram_opcode {
    tinyram_opcode_AND    = 0b00000,
    tinyram_opcode_OR     = 0b00001,
    tinyram_opcode_XOR    = 0b00010,
    tinyram_opcode_NOT    = 0b00011,
    tinyram_opcode_ADD    = 0b00100,
    tinyram_opcode_SUB    = 0b00101,
    
    // Multiplications
    tinyram_opcode_MULL   = 0b00110,