Check-in [7e48f725c8]

            mkdir -p ~/test-results/junit/
            find . -type f -regex '.*/build/test-results/.*xml' -exec cp {} ~/test-results/junit/ \;
          when: always
      - store_test_results:
          path: ~/test-results
      - store_artifacts:
          path: ~/test-results/junit
  construct_testjars:
    executor: buildenv
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: Constuct Test JARs
          command: ./gradlew testJar --continue --parallel
      - persist_to_workspace:
          root: .
          paths:
            - '.gradle/*'
            - 'build/*'
            - 'buildSrc/.gradle/*'
            - 'buildSrc/build/*'
            - 'emulators/build/*'
            - 'emulators/*/build/*'
            - 'modules/build/*'
            - 'modules/*/build/*'
            - 'tools/build/*'
            - 'tools/*/build/*'
  test_springcoat:
    executor: buildenv
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: SpringCoat Tests

          command: timeout --foreground 15m ./gradlew testSpringCoat --console plain --continue --parallel



          no_output_timeout: 15m
      - run:
          name: Save test results
          command: |
            mkdir -p ~/test-results/junit/
            find . -type f -regex '.*/springcoat/junit-reports/.*xml' -exec cp {} ~/test-results/junit/ \;
          when: always
      - run:
          name: Save snapshots
          command: |
            mkdir -p ~/test-results/nps/
            find . -type f -regex '.*/springcoat/nps/.*nps' -exec cp {} ~/test-results/nps/ \;
          when: always
      - store_test_results:
          path: ~/test-results
      - store_artifacts:
          path: ~/test-results/junit
      - store_artifacts:
          path: ~/test-results/nps
  test_summercoat:
    executor: buildenv
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: SummerCoat Tests
          command: |
            if ! timeout --foreground 1s ./gradlew testSummerCoat --console plain --continue --parallel
            then
              echo "SummerCoat testing failed, ignoring..." 1>&2
            fi
          no_output_timeout: 1m
      - run:
          name: Save test results
          command: |
            mkdir -p ~/test-results/junit/
            find . -type f -regex '.*/summercoat/junit-reports/.*xml' -exec cp {} ~/test-results/junit/ \;
          when: always
      - run:
          name: Save snapshots
          command: |
            mkdir -p ~/test-results/nps/
            find . -type f -regex '.*/summercoat/nps/.*nps' -exec cp {} ~/test-results/nps/ \;
          when: always
      - store_test_results:
          path: ~/test-results
      - store_artifacts:
          path: ~/test-results/junit
      - store_artifacts:
          path: ~/test-results/nps

workflows:
  version: 2
  tests:
    jobs:
      - build_windows
      - build_linux
      - build_macosx
      - construct_testjars:
          requires:
            - build_linux
      - test_springcoat:
          requires:
            - construct_testjars
      - test_summercoat:
          requires:
            - construct_testjars

*.diff
*.gdiff
*.patch
*.rej
*.bun
*.bundle

# Crash logs
*.log

<component name="ProjectCodeStyleConfiguration">
  <code_scheme name="Project" version="173">
    <option name="OTHER_INDENT_OPTIONS">
      <value>
        <option name="USE_TAB_CHARACTER" value="true" />
      </value>
    </option>
    <option name="LINE_SEPARATOR" value="&#10;" />
    <option name="RIGHT_MARGIN" value="79" />
    <option name="SOFT_MARGINS" value="79" />
    <DBN-PSQL>
      <case-options enabled="true">
        <option name="KEYWORD_CASE" value="lower" />
        <option name="FUNCTION_CASE" value="lower" />
        <option name="PARAMETER_CASE" value="lower" />
        <option name="DATATYPE_CASE" value="lower" />
        <option name="OBJECT_CASE" value="preserve" />

<component name="ProjectDictionaryState">
  <dictionary name="xer">
    <words>
      <w>accel</w>
      <w>backlight</w>
      <w>baos</w>
      <w>bootram</w>
      <w>cldc</w>
      <w>compactified</w>
      <w>cpibm</w>
      <w>csascii</w>
      <w>csibm</w>
      <w>csisolatin</w>
      <w>ebcdic</w>
      <w>endianess</w>
      <w>fprintf</w>
      <w>gawroriski</w>
      <w>ioob</w>
      <w>jarray</w>
      <w>jboolean</w>
      <w>jbyte</w>

      <w>jniexport</w>
      <w>jobject</w>
      <w>jshort</w>
      <w>jstring</w>
      <w>jthrowable</w>
      <w>jvalue</w>
      <w>jweak</w>
      <w>ljava</w>
      <w>microedition</w>
      <w>multiphasicapps</w>
      <w>narg</w>
      <w>noassert</w>
      <w>nsee</w>
      <w>phasic</w>
      <w>roro</w>
      <w>siii</w>
      <w>siiii</w>
      <w>siiiii</w>
      <w>siiiiii</w>
      <w>siiiiiii</w>
      <w>siiiiiiii</w>
      <w>springcoat</w>
      <w>squirreljme</w>
      <w>stdint</w>
      <w>summercoat</w>
      <w>targetting</w>
      <w>vmtypes</w>
      <w>vtable</w>
    </words>
  </dictionary>
</component>

#parse("CPP Header.h")

#ifndef __HEADER_H__
\#define __HEADER_H__

#endif /* __HEADER_H__ */

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="GradleMigrationSettings" migrationVersion="1" />
  <component name="GradleSettings">
    <option name="linkedExternalProjectsSettings">
      <GradleProjectSettings>
        <option name="delegatedBuild" value="true" />
        <option name="testRunner" value="GRADLE" />

        <option name="distributionType" value="DEFAULT_WRAPPED" />
        <option name="externalProjectPath" value="$PROJECT_DIR$" />
        <option name="gradleJvm" value="1.8" />
        <option name="modules">
          <set>
            <option value="$PROJECT_DIR$" />
            <option value="$PROJECT_DIR$/buildSrc" />

      <option name="m_limit" value="1" />
    </inspection_tool>
    <inspection_tool class="AnonymousHasLambdaAlternative" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="AnonymousInnerClass" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="ArrayLengthInLoopCondition" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="AssertEqualsBetweenInconvertibleTypes" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="AssignmentUsedAsCondition" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="AutoCloseableResource" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,cc.squirreljme.vm.springcoat.NativeHLEHandler,__fdOutput" />
    </inspection_tool>
    <inspection_tool class="BeforeClassOrAfterClassIsPublicStaticVoidNoArg" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="BeforeOrAfterIsPublicVoidNoArg" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="BooleanMethodNameMustStartWithQuestion" enabled="false" level="WEAK WARNING" enabled_by_default="false">
      <option name="ignoreBooleanMethods" value="false" />
      <option name="ignoreInAnnotationInterface" value="true" />
      <option name="onlyWarnOnBaseMethods" value="true" />
      <option name="questionString" value="add,are,can,check,contains,could,endsWith,equals,has,is,matches,must,put,remove,shall,should,startsWith,was,were,will,would" />
    </inspection_tool>
    <inspection_tool class="CharsetObjectCanBeUsed" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="CheckForOutOfMemoryOnLargeArrayAllocation" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_limit" value="64" />
    </inspection_tool>
    <inspection_tool class="ClassComplexity" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_limit" value="80" />
    </inspection_tool>
    <inspection_tool class="ClassCoupling" enabled="true" level="WARNING" enabled_by_default="true">

      <option name="commentsAreContent" value="true" />
    </inspection_tool>
    <inspection_tool class="EnhancedSwitchBackwardMigration" enabled="false" level="INFORMATION" enabled_by_default="false" />
    <inspection_tool class="EnhancedSwitchMigration" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="ExceptionNameDoesntEndWithException" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
    <inspection_tool class="ExplicitArgumentCanBeLambda" enabled="false" level="INFORMATION" enabled_by_default="false" />
    <inspection_tool class="ExtendsUtilityClass" enabled="true" level="WARNING" enabled_by_default="true" />



    <inspection_tool class="FieldNamingConvention" enabled="true" level="WEAK WARNING" enabled_by_default="true">
      <extension name="ConstantNamingConvention" enabled="true">
        <option name="m_regex" value="_?[a-zA-Z][A-Za-z_\d]*" />
        <option name="m_minLength" value="2" />
        <option name="m_maxLength" value="32" />
      </extension>
      <extension name="ConstantWithMutableFieldTypeNamingConvention" enabled="true">
        <option name="m_regex" value="_?[a-zA-Z][A-Za-z_\d]*" />
        <option name="m_minLength" value="2" />
        <option name="m_maxLength" value="32" />
      </extension>
      <extension name="EnumeratedConstantNamingConvention" enabled="true">
        <option name="m_regex" value="[A-Z][A-Z_\d]*" />
        <option name="m_minLength" value="2" />
        <option name="m_maxLength" value="40" />
      </extension>
      <extension name="InstanceVariableNamingConvention" enabled="true">
        <option name="m_regex" value="_?[a-z][a-zA-z_]*" />
        <option name="m_minLength" value="2" />
        <option name="m_maxLength" value="32" />
      </extension>
      <extension name="StaticVariableNamingConvention" enabled="true">
        <option name="m_regex" value="_?[a-zA-Z][A-Za-z_\d]*" />
        <option name="m_minLength" value="2" />
        <option name="m_maxLength" value="32" />
      </extension>
    </inspection_tool>
    <inspection_tool class="Finalize" enabled="true" level="ERROR" enabled_by_default="true">
      <option name="ignoreTrivialFinalizers" value="false" />
    </inspection_tool>

      <option name="m_ignoreForLoopParameters" value="true" />
      <option name="m_ignoreCatchParameters" value="true" />
      <option name="m_regex" value="(__)?[a-z][A-Za-z\d]*" />
      <option name="m_minLength" value="1" />
      <option name="m_maxLength" value="20" />
    </inspection_tool>
    <inspection_tool class="LongLine" enabled="true" level="TYPO" enabled_by_default="true" />
    <inspection_tool class="MagicNumber" enabled="true" level="WEAK WARNING" enabled_by_default="true">
      <scope name="Tests" level="WEAK WARNING" enabled="false" />
    </inspection_tool>
    <inspection_tool class="MethodNameSameAsClassName" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
    <inspection_tool class="MethodNameSameAsParentName" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
    <inspection_tool class="MethodRefCanBeReplacedWithLambda" enabled="false" level="INFORMATION" enabled_by_default="false" />
    <inspection_tool class="MissingOverrideAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
      <option name="ignoreObjectMethods" value="false" />
      <option name="ignoreAnonymousClassMethods" value="false" />
    </inspection_tool>

      <option name="ignoreInconvertibleTypes" value="true" />
    </inspection_tool>
    <inspection_tool class="OverloadedVarargsMethod" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
    <inspection_tool class="OverlyLargePrimitiveArrayInitializer" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_limit" value="64" />
    </inspection_tool>
    <inspection_tool class="PackageInfoWithoutPackage" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="PackageNamingConvention" enabled="false" level="WEAK WARNING" enabled_by_default="false">
      <option name="m_regex" value="[a-z]*" />
      <option name="m_minLength" value="2" />
      <option name="m_maxLength" value="16" />
    </inspection_tool>
    <inspection_tool class="ParameterNameDiffersFromOverriddenParameter" enabled="false" level="WEAK WARNING" enabled_by_default="false">
      <option name="m_ignoreSingleCharacterNames" value="false" />
      <option name="m_ignoreOverridesOfLibraryMethods" value="false" />

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ExternalStorageConfigurationManager" enabled="true" />
  <component name="JavaScriptSettings">
    <option name="languageLevel" value="ES6" />
  </component>
  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
</project>

/**
 * This is used to get the error lists from a project.
 *
 * @since 2020/02/22
 */
public final class ErrorListManager
{

	/** The project to manage the list for. */
	protected final Project project;
	
	/** The listed errors. */
	private final Map<Integer, SourceError> _errors =
		new TreeMap<>();
	

		// Store body in
		this.body = body.toString();
		
		// Parameter list?
		List<String> parameters = new ArrayList<String>();
		if ("(".equals(queue.peekFirst()))
		{
			// Remove the starting parenthesis so it is not added
			queue.removeFirst();
			
			// Process queue
			StringBuilder buffer = new StringBuilder();
			while (!queue.isEmpty())
			{
				String item = queue.peekFirst();
				
				// End parameter or next?

	 * @return The translated string to index.
	 * @since 2020/02/22
	 */
	public static String indexToString(int __index)
	{
		StringBuilder sb = new StringBuilder();
		
		sb.append(Character.toLowerCase(Character.forDigit(
			__index / Character.MAX_RADIX, Character.MAX_RADIX)));
		sb.append(Character.toLowerCase(Character.forDigit(
			__index % Character.MAX_RADIX, Character.MAX_RADIX)));
		
		return sb.toString();
	}
	
	/**
	 * Returns the index for the given string.

	 * {@inheritDoc}
	 * @since 2020/02/15
	 */
	@Override
	public void apply(Project __project)
	{
		// Add configuration for SquirrelJME
		SquirrelJMEPluginConfiguration config = __project
			.getExtensions().<SquirrelJMEPluginConfiguration>create(
			"squirreljme", SquirrelJMEPluginConfiguration.class,
			this, __project);
		
		// Build task
		__project.getTasks().getByName("build");
		
		// Class generation

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

/**
 * This contains the base plugin code to support SquirrelJME.
 *
 * @since 2020/06/13
 */

package cc.squirreljme.plugin;

import cc.squirreljme.plugin.SquirrelJMEPluginConfiguration;
import cc.squirreljme.plugin.swm.JavaMEMidlet;
import cc.squirreljme.plugin.swm.JavaMEMidletType;
import cc.squirreljme.plugin.tasks.test.EmulatedTestUtilities;
import java.io.File;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.Callable;
import org.gradle.api.Action;
import org.gradle.api.DefaultTask;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.Dependency;

	
	/**
	 * Returns the run class path.
	 *
	 * @return The run class path.
	 * @since 2020/02/29
	 */

	Iterable<Path> __runClassPath()
	{
		Collection<Path> result = new LinkedHashSet<>();
		
		Deque<Project> projects = new LinkedList<>();
		Set<Project> didProjects = new TreeSet<>();
		
		this.__recursiveDependencies(result, this.getProject());
		
		return result;
	}
	
	/**
	 * Recursively scans and obtains dependencies.
	 *
	 * @param __out The output collection.
	 * @param __at The current project currently at.
	 * @since 2020/02/29
	 */
	@Deprecated
	private void __recursiveDependencies(Collection<Path> __out, Project __at)
	{
		this.__recursiveDependencies(__out, __at, new HashSet<>());
	}
	
	/**
	 * Recursively scans and obtains dependencies.
	 *

package cc.squirreljme.plugin.tasks;

import cc.squirreljme.plugin.tasks.test.EmulatedTestExecutionSpec;
import cc.squirreljme.plugin.tasks.test.EmulatedTestExecutor;
import java.io.File;
import java.nio.file.Path;

import java.util.Objects;
import java.util.concurrent.Callable;
import javax.inject.Inject;
import org.gradle.api.internal.provider.DefaultProvider;
import org.gradle.api.tasks.testing.AbstractTestTask;
import org.gradle.api.tasks.testing.Test;
import org.gradle.jvm.tasks.Jar;

/**
 * Tests in virtual machine, this uses an abstract test tasks which implement
 * all of the needed classes for test.
 *
 * Required properties:
 *  - binaryResultsDirectory
 *  - reports.enabledReports.html.outputLocation
 *  - reports.enabledReports.junitXml.outputLocation
 *
 * Gradle Test task {@link Test}.
 *
 * @since 2020/03/06
 */
@Deprecated
public class TestInVMTask
	extends AbstractTestTask
{
	/** The binary results directory. */
	private static final String _BINARY_RESULTS_DIRECTORY =
		"binaryResultsDirectory";
	

	 * Initializes the task.
	 *
	 * @param __jar The JAR sources.
	 * @param __vm The virtual machine to run.
	 * @since 2020/03/06
	 */
	@Inject
	@Deprecated
	public TestInVMTask(Jar __jar, String __vm)
	{
		// We need these for tasks and such
		this.emulator = __vm;
		this.jar = __jar;
		
		// Set description
		this.setGroup("squirreljme");
		this.setDescription("Tests inside of " + __vm + ".");
		
		// Depend on the JAR task
		this.dependsOn(__jar);
		
		// The input file for our tests is the JAR we want to look at!
		this.getInputs().file(__jar.getArchiveFile());
		
		// Where binary results are going to be stored, these both have to
		// be set otherwise the test build will fail
		this.setProperty(TestInVMTask._BINARY_RESULTS_DIRECTORY,
			this.getProject().getObjects().directoryProperty()
			.dir(new DefaultProvider<>(this::__binResultPath)));
		this.setBinResultsDir(new File(this.__binResultPath().toString()));

		
		// Generate HTML reports because they are useful
		this.getReports().getHtml().setDestination(
			this.__tempRoot().resolve("html-reports").toFile());
		
		// Generate JUnit XML, these will be uploaded to CICD
		this.getReports().getJunitXml().setDestination(

		// have when running the VMs especially when not fully stable
		this.testLogging(__settings ->
			{
				__settings.setShowCauses(true);
				__settings.setShowStandardStreams(true);
				__settings.setShowStackTraces(true);
			});
		
		// Make sure that both report types are enabled!
		this.reports(__reports ->
			{
				__reports.getJunitXml().setEnabled(true);
				__reports.getHtml().setEnabled(true);
			});
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/03/06
	 */
	@Override
	@Deprecated
	protected EmulatedTestExecutor createTestExecuter()
	{
		return new EmulatedTestExecutor(this);
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/03/06
	 */
	@Override
	@Deprecated
	protected EmulatedTestExecutionSpec createTestExecutionSpec()
	{
		return new EmulatedTestExecutionSpec(this.emulator, this.jar);
	}
	
	/**
	 * Returns the binary results path.
	 * 
	 * @return The binary results path.
	 * @since 2020/06/22
	 */
	@Deprecated
	CharSequence __binResultPath()
	{
		return this.__tempRoot().resolve("bin-results")
			.toAbsolutePath().toString();
	}
	
	/**
	 * Finds the emulator JAR task.
	 *
	 * @return The emulator JAR task.
	 * @since 2020/02/29
	 */
	@Deprecated
	Jar __findEmulatorBaseJarTask()
	{
		return (Jar)Objects.requireNonNull(this.getProject().getRootProject().
			findProject(":emulators:emulator-base"),
			"No emulator base?").getTasks().getByName("jar");
	}
	
	/**
	 * Locates the emulator package to base on.
	 *
	 * @return The emulator base.
	 * @since 2020/02/29
	 */
	@Deprecated
	Jar __findEmulatorJarTask()
	{
		return (Jar)Objects.requireNonNull(this.getProject().getRootProject().
			findProject(":emulators:" + this.emulator + "-vm"),
			"No emulator?").getTasks().getByName("jar");
	}
	
	/**
	 * Returns the temporary file root base.
	 *
	 * @return The temporary root.
	 * @since 2020/03/06
	 */
	@Deprecated
	public final Path __tempRoot()
	{
		return this.getProject().getBuildDir().toPath().resolve("vm-test").
			resolve(this.emulator);
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.plugin.tasks.test;

import org.gradle.api.internal.tasks.testing.TestResultProcessor;
import org.gradle.api.tasks.testing.TestOutputEvent;

/**
 * This indicates a line that happened on the consoles.
 *
 * @since 2020/06/22
 */
public final class ConsoleLine
{
	/** Is this to standard error?. */
	public final boolean stdErr;
	
	/** When did this happen? */
	public final long timeMillis;
	
	/** The text that was printed to the console. */
	public final String text;
	
	/**
	 * Initializes the console line.
	 * 
	 * @param __stdErr Is this standard error?
	 * @param __timeMillis When this message appeared.
	 * @param __text The text for the message.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public ConsoleLine(boolean __stdErr, long __timeMillis, String __text)
		throws NullPointerException
	{
		if (__text == null)
			throw new NullPointerException("NARG");
		
		this.stdErr = __stdErr;
		this.timeMillis = __timeMillis;
		this.text = __text;
	}
	
	/**
	 * Reports the line.
	 * 
	 * @param __results The test results output.
	 * @param __method The method to report to.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public void report(TestResultProcessor __results,
		EmulatedTestMethodDescriptor __method)
		throws NullPointerException
	{
		// Where is this going?
		TestOutputEvent.Destination destination = (this.stdErr ?
				TestOutputEvent.Destination.StdErr :
				TestOutputEvent.Destination.StdOut);
		
		// Print output
		__results.output(__method.getId(),
			EmulatedTestUtilities.output(destination,
				this.text + System.getProperty("line.separator")));
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.plugin.tasks.test;

import cc.squirreljme.plugin.tasks.TestInVMTask;



import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicInteger;
import org.gradle.api.Project;
import org.gradle.api.internal.tasks.testing.TestExecuter;
import org.gradle.api.internal.tasks.testing.TestResultProcessor;

import org.gradle.process.ExecResult;

/**
 * This is the executor for tests.
 *
 * @since 2020/03/06
 */
public final class EmulatedTestExecutor
	implements TestExecuter<EmulatedTestExecutionSpec>
{




	/** The service resource file. */
	public static final String SERVICE_RESOURCE =
		"META-INF/services/net.multiphasicapps.tac.TestInterface";
	
	/** The test task. */
	private final TestInVMTask _testInVMTask;
	
	/** Emulator classpath. */
	private final Map<String, Iterable<Object>> _emuClassPathCache =
		new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
	
	/** Should this test be stopped? */
	private volatile boolean _stopRunning =
		false;
	
	/**
	 * Initializes the task executor.
	 *

	@Override
	public void execute(EmulatedTestExecutionSpec __spec,
		TestResultProcessor __results)
	{
		// We need the project to access details
		Project project = this._testInVMTask.getProject();
		
		// Initialize the classpath for our emulator!
		// Otherwise the Gradle build will fail since it tries to get the
		// classpath outside of this
		this.emulatorClassPath(project, __spec.emulator);
		
		// Run for this suite/project
		EmulatedTestSuiteDescriptor suite =
			new EmulatedTestSuiteDescriptor(project);
		



		// Perform testing logic
		boolean allPassed;
		try
		{
			// Load tests to run
			Collection<String> classes = EmulatedTestUtilities.readJarServices(
				__spec.jar.getArchiveFile().get().getAsFile().toPath());
			
			// Report on the found test size (debugging)
			project.getLogger().lifecycle(String.format(
				"Found %d tests...%n", classes.size()));
			
			// Indicate that the suite has started execution
			__results.started(suite, EmulatedTestUtilities.startNow());
			
			// Execute test classes (find them and run them)
			allPassed = this.__executeClasses(__spec, __results, suite,
				classes);
			
			// Did all tests pass?
			__results.completed(suite.getId(),
				EmulatedTestUtilities.passOrFailNow(allPassed));
		}
		
		// Something went wrong it seems
		catch (Throwable t)
		{
			project.getLogger().error("Throwable caught during testing.", t);
			
			throw new RuntimeException("Caught throwable during testing.", t);


		}
		
		// Did not pass, so cause the task to fail
		if (!allPassed)
		{
			// Throw a blank failure exception
			RuntimeException toss = new RuntimeException("Failed tests.");
			toss.setStackTrace(new StackTraceElement[0]);
			
			throw toss;
		}
	}
	
	/**
	 * Executes the test class.
	 * 
	 * @param __spec The specification.
	 * @param __suite The suite to run.
	 * @param __testClass The test class.
	 * @return If this test passed.
	 * @since 2020/06/21
	 */
	private EmulatedTestResult __executeClass(EmulatedTestExecutionSpec __spec,
		EmulatedTestSuiteDescriptor __suite, String __testClass)
	{
		// Setup result
		EmulatedTestResult result = new EmulatedTestResult(
			__suite, __testClass);
		
		// Signal as started
		result.testStart();
		
		// Execute each class alone
		try
		{
			// Execute individual test
			int exitCode = this.__executeClassVm(__spec, result);
			
			// Finish the test with the result code
			result.testFinish(exitCode, null);
		}
		catch (Throwable t)
		{
			// Just mark failure
			result.testFinish(ExitValueConstants.FAILURE, t);
			
			// Print the trace since this was outside of the VM
			synchronized (System.err)
			{
				t.printStackTrace(System.err);
			}
		}
		
		return result;
	}
	
	/**
	 * Goes through and executes the single test class.
	 *
	 * @param __spec The specification.
	 * @param __result The output result.

	 * @return The exit value of the test.
	 * @since 2020/03/06
	 */
	@SuppressWarnings("resource")
	private int __executeClassVm(EmulatedTestExecutionSpec __spec,
		EmulatedTestResult __result)
	{
		Project project = this._testInVMTask.getProject();
		
		// Setup test standard output and error streams
		OutputStream stdOut = __result.stdOut();
		OutputStream stdErr = __result.stdErr();
		
		// For some reason test reports do not run if there is no output for
		// them, so this for the most part forces console output to happen
		// which makes tests happen
		String withinClass = __result.className;
		try
		{
			stdErr.write(String.format("Starting VM for %s...", withinClass)
				.getBytes());
		}
		catch (IOException ignored)
		{
		}
		
		// Execute the test Java program

		ExecResult result = project.javaexec(__javaExecSpec ->
			{
				Collection<String> args = new LinkedList<>();
				





				// Add emulator
				args.add("-Xemulator:" + __spec.emulator);
				
				// Add snapshot path
				args.add("-Xsnapshot:" + EmulatedTestExecutor.this
					._testInVMTask.__tempRoot().resolve("nps")
					.resolve(withinClass + ".nps").toAbsolutePath());
				
				// Classpath of the target JAR
				args.add("-classpath");
				args.add(EmulatedTestUtilities.classpathString(project,
					true));
				
				// Only run a single test
				args.add("net.multiphasicapps.tac.MainSingleRunner");
				
				// Target this single test
				args.add(withinClass);
				
				// Configure the VM for execution
				__javaExecSpec.classpath(EmulatedTestExecutor.this
					.emulatorClassPath(null, __spec.emulator));
				__javaExecSpec.setMain("cc.squirreljme.emulator.vm.VMFactory");
				__javaExecSpec.setArgs(args);
				
				// Pipe outputs to the specified areas so the console can be
				// read properly!
				__javaExecSpec.setStandardOutput(stdOut);


				__javaExecSpec.setErrorOutput(stdErr);


				
				// Do not throw an exception on a non-zero exit value since
				// it is important to us
				__javaExecSpec.setIgnoreExitValue(true);
			});
		
		// The exit value is the test result
		return result.getExitValue();
	}
	
	/**
	 * Returns the classpath for the emulator.
	 * 
	 * @param __project The project to use.
	 * @param __emulator The emulator to use.
	 * @return The classpath for the emulator.
	 * @throws NullPointerException On null arguments, or if {@code __project}
	 * is null and this is not already cached.
	 * @since 2020/06/22
	 */
	private Iterable<Object> emulatorClassPath(Project __project,
		String __emulator)
		throws NullPointerException
	{
		if (__emulator == null)
			throw new NullPointerException("NARG");
		
		// Use already cached value
		Map<String, Iterable<Object>> cache = this._emuClassPathCache;
		Iterable<Object> rv = cache.get(__emulator);
		if (rv != null)
			return rv; 
		
		// Get new result
		Iterable<Object> now = EmulatedTestUtilities.emulatorClassPath(
			__project, __emulator);
		
		// Add to the cache
		List<Object> toCache = new ArrayList<>();
		for (Object item : now)
			toCache.add(item);
		
		// Store unreadable form
		cache.put(__emulator,
			(rv = Collections.unmodifiableCollection(toCache)));
		
		// Ensure it stays unreadable
		return rv;
	}
	
	/**
	 * Goes through and executes the test classes.
	 *
	 * @param __spec The specification.
	 * @param __results The output results.
	 * @param __suite The suite to run.
	 * @param __classes The classes to run.
	 * @return Did all tests pass?
	 * @throws IOException On read errors.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/03/06
	 */
	@SuppressWarnings({"FeatureEnvy", "MagicNumber"})
	private boolean __executeClasses(EmulatedTestExecutionSpec __spec,
		TestResultProcessor __results, EmulatedTestSuiteDescriptor __suite,
		Iterable<String> __classes)
		throws IOException, NullPointerException
	{
		if (__spec == null || __results == null || __suite == null ||
			__classes == null)
			throw new NullPointerException("NARG");
		
		// And any results of the runs will be placed in this pool along
		// with the number of added and finished tests
		AtomicInteger finishedTests = new AtomicInteger();
		

		// Create jobs for the tests
		Set<String> failedTests = new TreeSet<>();
		boolean allPassed = true;
		for (String testClass : __classes)
		{

			// If stopping running, discontinue and fail the tests
			if (this._stopRunning)
			{
				allPassed = false;
				break;
			}

			

			// Execute the test


			EmulatedTestResult result = this.__executeClass(

				__spec, __suite, testClass);


			
			// Report the test


			result.report(__results);


			


			// Did this fail?

			if (result.isFailure())






				failedTests.add(result.className);





			
			// Increase the test counter, as this was grabbed
			finishedTests.incrementAndGet();



		}



		


		// There were test failures?
		if (!failedTests.isEmpty())
		{



			// Not every test passed
			allPassed = false;




			






			// Print all the failed tests out
			for (String testClass : failedTests)

				System.err.printf("Failed Test: %s%n", testClass);

		}
		
		// Return how all the tests ran
		return allPassed;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/03/06
	 */
	@Override
	public void stopNow()
	{
		// Stop running and prevent the next test from stopping
		this._stopRunning = true;
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.plugin.tasks.test;

import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import org.gradle.api.internal.tasks.testing.TestResultProcessor;

/**
 * The contains the result for emulated tests.
 *
 * @since 2020/06/22
 */
public final class EmulatedTestResult
{
	/** Which test is this for? */
	protected final String className;
	
	/** The suite. */
	protected final EmulatedTestSuiteDescriptor suite;
	
	/** The console lines. */
	private final Collection<ConsoleLine> _lines =
		new ArrayList<>(128);
	
	/** The exit code of the test. */
	private int _exitCode =
		Integer.MIN_VALUE;
	
	/** The start time. */
	private long _timeStart =
		Long.MIN_VALUE;
	
	/** The end time. */
	private long _timeEnd =
		Long.MIN_VALUE;
	
	/** The tossed exception, if any. */
	private Throwable _tossed;
	
	/**
	 * Initializes the base for the test result.
	 * 
	 * @param __suite The test suite.
	 * @param __className The name of the class.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public EmulatedTestResult(EmulatedTestSuiteDescriptor __suite,
		String __className)
		throws NullPointerException
	{
		if (__suite == null || __className == null)
			throw new NullPointerException("NARG");
		
		this.suite = __suite;
		this.className = __className;
	}
	
	/**
	 * Adds a line to the output.
	 * 
	 * @param __line The line to add.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public void addLine(ConsoleLine __line)
		throws NullPointerException
	{
		if (__line == null)
			throw new NullPointerException("NARG");
		
		synchronized (this)
		{
			this._lines.add(__line);
		}
	}
	
	/**
	 * Is this a test failure?
	 * 
	 * @return If this is a test failure.
	 * @since 2020/06/22
	 */
	public final boolean isFailure()
	{
		synchronized (this)
		{
			int exitCode = this._exitCode;
			return exitCode != ExitValueConstants.SUCCESS &&
				exitCode != ExitValueConstants.SKIPPED;
		}
	}
	
	/**
	 * Sends in the test report.
	 * 
	 * @param __results The output results.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public final void report(TestResultProcessor __results)
		throws NullPointerException
	{
		if (__results == null)
			throw new NullPointerException("NARG");
		
		EmulatedTestSuiteDescriptor suite = this.suite;
		String testClass = this.className;
		
		// In SquirrelJME all tests only have a single run method, so the
		// run is the actual class of execution
		EmulatedTestClassDescriptor classy =
			new EmulatedTestClassDescriptor(suite, testClass);
		EmulatedTestMethodDescriptor method =
			new EmulatedTestMethodDescriptor(classy);
		
		synchronized (this)
		{
			// Execution times
			long timeStart = this._timeStart;
			long timeEnd = this._timeEnd;
			
			// Signal start
			__results.started(classy,
				EmulatedTestUtilities.startAt(timeStart, suite));
			__results.started(method,
				EmulatedTestUtilities.startAt(timeStart, classy));
			
			// Print all the output text
			for (ConsoleLine line : this._lines)
				line.report(__results, method);
			
			// Was the test in error?
			int exitCode = this._exitCode;
			if (exitCode != ExitValueConstants.SUCCESS &&
				exitCode != ExitValueConstants.SKIPPED)
			{
				// Was an exception thrown? If not, make a generic one
				Throwable tossed = this._tossed;
				if (tossed == null)
				{
					tossed = new Throwable("Test Failed");
					
					// Make the trace empty as it has no meaning
					tossed.setStackTrace(new StackTraceElement[0]);
				}
				
				// Toss it now
				__results.failure(method.getId(), tossed);
			}
			
			// End execution
			__results.completed(method.getId(),
				EmulatedTestUtilities.passSkipOrFailAt(timeEnd, exitCode));
			__results.completed(classy.getId(),
				EmulatedTestUtilities.passSkipOrFailAt(timeEnd, exitCode));
		}
	}
	
	/**
	 * Returns standard error.
	 * 
	 * @return Standard error.
	 * @since 2020/06/22
	 */
	public OutputStream stdErr()
	{
		return new PipeOutputStream(this, true);
	}
	
	/**
	 * Returns standard output.
	 * 
	 * @return Standard output.
	 * @since 2020/06/22
	 */
	public OutputStream stdOut()
	{
		return new PipeOutputStream(this, false);
	}
	
	/**
	 * Finishes the test with the given exit code.
	 * 
	 * @param __exitCode The exit code.
	 * @param _toss The tossed exception, if any.
	 * @since 2020/06/22
	 */
	public void testFinish(int __exitCode, Throwable _toss)
	{
		synchronized (this)
		{
			if (this._timeEnd != Long.MIN_VALUE)
				throw new IllegalStateException("Test already finished.");
			
			this._timeEnd = System.currentTimeMillis();
			this._exitCode = __exitCode;
			this._tossed = _toss;
		}
	}
	
	/**
	 * Starts the test.
	 * 
	 * @since 2020/06/22
	 */
	public final void testStart()
	{
		synchronized (this)
		{
			if (this._timeStart != Long.MIN_VALUE)
				throw new IllegalStateException("Test already started.");
			
			this._timeStart = System.currentTimeMillis();
		}
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.plugin.tasks.test;

import cc.squirreljme.plugin.SquirrelJMEPluginConfiguration;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Collection;
import java.util.Deque;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.Dependency;
import org.gradle.api.artifacts.ProjectDependency;
import org.gradle.api.internal.tasks.testing.DefaultTestOutputEvent;
import org.gradle.api.internal.tasks.testing.TestCompleteEvent;
import org.gradle.api.internal.tasks.testing.TestDescriptorInternal;

		rv.add(emuProject.getConfigurations().getByName("runtimeClasspath")
			.getFiles());
		rv.add(((Jar)emuProject.getTasks().getByName("jar")).getOutputs()
			.getFiles());
		
		return rv;
	}
	
	/**
	 * Fails at the specified time.
	 * 
	 * @param __millis The time to fail at.
	 * @return The completion event.
	 * @since 2020/06/22
	 */
	private static TestCompleteEvent failAt(long __millis)
	{
		return new TestCompleteEvent(__millis,
			TestResult.ResultType.FAILURE);
	}
	
	/**
	 * Returns a failing completion.
	 *
	 * @return An event.
	 * @since 2020/03/06
	 */
	public static TestCompleteEvent failNow()
	{
		return EmulatedTestUtilities.failAt(System.currentTimeMillis());

	}
	
	/**
	 * Outputs a message.
	 *
	 * @param __dest The destination.
	 * @param __msg The message.

	 * @since 2020/03/06
	 */
	public static TestOutputEvent outputErr(String __msg)
	{
		return EmulatedTestUtilities.output(
			TestOutputEvent.Destination.StdErr, __msg);
	}
	
	/**
	 * Passes at the given time.
	 * 
	 * @param __millis The time to pass at.
	 * @return The completion event.
	 * @since 2020/06/22
	 */
	private static TestCompleteEvent passAt(long __millis)
	{
		return new TestCompleteEvent(__millis,
			TestResult.ResultType.SUCCESS);
	}
	
	/**
	 * Returns a passing completion.
	 *
	 * @return An event.
	 * @since 2020/03/06
	 */
	public static TestCompleteEvent passNow()
	{
		return EmulatedTestUtilities.passAt(System.currentTimeMillis());

	}
	
	/**
	 * Either passes or fails.
	 *
	 * @param __pass Does the test pass?
	 * @return The event.
	 * @since 2020/03/06
	 */
	public static TestCompleteEvent passOrFailNow(boolean __pass)
	{
		return (__pass ? EmulatedTestUtilities.passNow() :
			EmulatedTestUtilities.failNow());
	}
	
	/**
	 * Either passes or skips.
	 *
	 * @param __millis The time to finish.
	 * @param __pass Does the test pass?
	 * @return The event.
	 * @since 2020/03/06
	 */
	public static TestCompleteEvent passOrSkipAt(long __millis, boolean __pass)
	{
		return (__pass ? EmulatedTestUtilities.passAt(__millis) :
			EmulatedTestUtilities.skipAt(__millis));
	}
	
	/**
	 * Passes, skips, or fails at the given time.
	 * 
	 * @param __millis The time to finish.
	 * @param __exitCode The status code.
	 * @return The completion event.
	 * @since 2020/06/22
	 */
	public static TestCompleteEvent passSkipOrFailAt(long __millis,
		int __exitCode)
	{
		if (__exitCode == ExitValueConstants.SUCCESS)
			return EmulatedTestUtilities.passAt(__millis);
		else if (__exitCode == ExitValueConstants.SKIPPED)
			return EmulatedTestUtilities.skipAt(__millis);
		return EmulatedTestUtilities.failAt(__millis);
	}
	
	/**
	 * Depending on the exit code, this will pass, fail, or skip a test.
	 *
	 * @param __exitCode The exit code.
	 * @return The completion event.
	 * @since 2020/03/07
	 */
	public static TestCompleteEvent passSkipOrFailNow(int __exitCode)
	{

		return EmulatedTestUtilities.passSkipOrFailAt(
			System.currentTimeMillis(), __exitCode);
	}
	
	/**
	 * Reads test services from the JAR. 
	 *
	 * @param __path The path to read from.
	 * @throws IOException On read failures.
	 * @since 2020/06/22
	 */
	public static Collection<String> readJarServices(Path __path)
		throws IOException, NullPointerException
	{
		if (__path == null)
			throw new NullPointerException("NARG");
		
		try (InputStream in = Files.newInputStream(
			__path, StandardOpenOption.READ);
			ZipInputStream zip = new ZipInputStream(in))
		{
			return EmulatedTestUtilities.readJarServices(zip);
		}
	}
	
	/**
	 * Reads test services from the JAR. 
	 *
	 * @param __zip The ZIP to read.
	 * @throws IOException On read failures.
	 * @since 2020/05/25
	 */
	public static Collection<String> readJarServices(ZipInputStream __zip)
		throws IOException
	{
		// Resultant collection
		Collection<String> result = new LinkedHashSet<>();
		
		// Potential resource file data
		byte[] resourceData = null;
		
		// Go through entries within the ZIP
		ZipEntry entry;
		while (null != (entry = __zip.getNextEntry()))
		{
			// Only consider the services file
			if (!Objects.equals(EmulatedTestExecutor.SERVICE_RESOURCE,
				entry.getName()))
				continue;
			
			// Copy file data
			try (ByteArrayOutputStream baos = new ByteArrayOutputStream())
			{
				// Copy bytes
				byte[] buf = new byte[4096];
				for (;;)
				{
					int rc = __zip.read(buf);
					
					if (rc < 0)
						break;
					
					baos.write(buf, 0, rc);
				}
				
				// Set resource data and stop finding entries
				resourceData = baos.toByteArray();
				break;
			}
		}
		
		// Read in service list
		if (resourceData != null)
			try (BufferedReader br = new BufferedReader(new InputStreamReader(
				new ByteArrayInputStream(resourceData),
					StandardCharsets.UTF_8)))
			{
				for (;;)
				{
					// End of file?
					String ln = br.readLine();
					if (ln == null)
						break;
					
					// Only consider lines with content
					ln = ln.trim();
					if (!ln.isEmpty())
						result.add(ln);
				}
			}
		
		return result;
	}
	
	/**
	 * Skips at the given time.
	 * 
	 * @param __millis The time to skip at.
	 * @return The completion event.
	 * @since 2020/06/22
	 */
	private static TestCompleteEvent skipAt(long __millis)
	{
		return new TestCompleteEvent(__millis,
			TestResult.ResultType.SKIPPED);
	}
	
	/**
	 * Returns a skipping completion.
	 *
	 * @return An event.
	 * @since 2020/03/06
	 */
	public static TestCompleteEvent skipNow()
	{
		return EmulatedTestUtilities.skipAt(System.currentTimeMillis());
	}
	
	/**
	 * Returns a test starting now.
	 *
	 * @param __millis The starting time.
	 * @return An event
	 * @since 2020/06/22
	 */
	public static TestStartEvent startAt(long __millis)
	{
		return EmulatedTestUtilities.startAt(__millis, null);
	}
	
	/**
	 * Returns a test starting now.
	 *
	 * @param __test The test information.
	 * @return An event
	 * @since 2020/06/22
	 */
	public static TestStartEvent startAt(long __millis,
		TestDescriptorInternal __test)
	{
		return new TestStartEvent(__millis,
			(__test == null ? null : __test.getId()));
	}
	
	/**
	 * Returns a test starting now.
	 *
	 * @return An event
	 * @since 2020/03/06

	 *
	 * @param __test The test information.
	 * @return An event
	 * @since 2020/03/06
	 */
	public static TestStartEvent startNow(TestDescriptorInternal __test)
	{
		return EmulatedTestUtilities.startAt(
			System.currentTimeMillis(), __test);

	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.plugin.tasks.test;

import java.io.OutputStream;



/**
 * Pipes output stream to the results output accordingly.
 *
 * @since 2020/03/07
 */
public class PipeOutputStream
	extends OutputStream
{
	/** The output buffer. */
	protected final StringBuilder buffer =
		new StringBuilder();
	
	/** The test result. */
	protected final EmulatedTestResult result;
	
	/** Is this standard error. */
	protected final boolean stdErr;
	



	/** Do we have a carriage return? */
	private boolean _haveCr;
	
	/**
	 * Initializes the pipe output.
	 * 
	 * @param __result The result to send to.

	 * @param __stdErr Is this standard error?
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public PipeOutputStream(EmulatedTestResult __result, boolean __stdErr)

		throws NullPointerException
	{
		if (__result == null)
			throw new NullPointerException("NARG");
		

		this.result = __result;
		this.stdErr = __stdErr;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/03/07
	 */
	@SuppressWarnings("DuplicatedCode")
	@Override
	public void write(int __b)
	{
		StringBuilder buffer = this.buffer;
		
		// Flush the buffer on newlines
		if (__b == '\r' || __b == '\n')
		{
			if (__b == '\r')
				this._haveCr = true;
			else
			{
				this.__flush();
				this._haveCr = false;
			}
		}
		else
		{
			// Flush if we just gave a CR
			if (this._haveCr)
				this.__flush();
			
			if (__b < 0)
				buffer.append('?');
			else
				buffer.append((char)__b);
		}

		{
			byte b = __b[__o++];
			
			// Flush the buffer on newlines
			if (b == '\r' || b == '\n')
			{
				if (b == '\r')
					this._haveCr = true;
				else
				{
					this.__flush();
					this._haveCr = false;
				}
			}
			else
			{
				// Flush if we just gave a CR
				if (this._haveCr)
					this.__flush();
				
				if (b < 0)
					buffer.append('?');
				else
					buffer.append((char)b);
			}
		}
	}
	
	/**
	 * Flushes the buffer.
	 *
	 * @since 2020/03/07
	 */
	private void __flush()
	{
		// Send buffer to the output
		StringBuilder buffer = this.buffer;
		this.result.addLine(new ConsoleLine(this.stdErr,



			System.currentTimeMillis(), buffer.toString()));
		
		// Clear the buffer
		buffer.setLength(0);
		
		// Always clear CR state
		this._haveCr = false;
	}
}

 * Programs and Libraries
   * `cldc-compact`
     * Added a rehash indicator for the internal `__BucketMap__` so that
       `java.util.Hashtable` knows when a reorder was performed.
     * Added `java.util.Vector`, it was missing.
     * Added support for ISO-8859-15, this is the newer encoding with the
       Euro symbol.
     * Added support for `os.arch`, `os.name`, and `os.version`.
     * Corrected bug in `__CanSetPrintStream__` where if it were set to itself
       then it could lead to infinite recursion, instead if this kind of
       stream is attempted to be set it will use the target.
     * Corrected `java.lang.Object.clone()` to return the new copy of the array
       when cloning and not the original.
     * Corrected `java.util.Objects.equals()` not correctly checking equality
       on two objects.

     * Implemented `java.io.PrintStream`.
     * Implemented `java.util.EventObject`.
     * Implemented `java.util.Hashtable`.
     * Implemented `java.util.LinkedHashMap`.
     * Implemented `java.util.LinkedList`.
     * Made the stack trace printed by `Throwable` much cleaner so that it
       takes up less screen space and is formatted a bit better.
     * Removed `GuestDepth`, it is no longer a concept.
     * Return values for `line.separator`, `microedition.encoding`,
       `microedition.configuration`, and `microedition.locale`.
   * `demo-hello`
     * Made the system properties array `final`.
   * `jblend-api`
     * Added API Stubs.
   * `launcher`

   * SpringCoat
     * Add limit to stack frame depth.
     * Add support for system properties being based to virtual machine
       instances.
     * Allow inheritance of static methods in classes.
     * Profiler thread lists are easier to read because the main suite is
       listed instead of the VM identifier.
     * Refactored greatly to be much leaner and simplified.
   * SummerCoat
     * New Virtual Machine, register based.
     * Vast improvements over SpringCoat, faster and slimmer.
   * RatufaCoat
     * New Virtual Machine, based off SummerCoat.
     * Fast and slim, written in C.
 * Cleanup

plugins
{
	// C++ needs to be first otherwise the build will break
	id "cpp-library"
	id "java-library"
	id "java-test-fixtures"
}

description = "This library provides the base support for testing and " +
	"running SquirrelJME on a Java SE host, which is normally not " +
	"capable of doing as such."

// Although it would be useful to use Java 8, we have to stay on Java 7
// because SquirrelJME is a Java 7 VM.
compileJava
{
	sourceCompatibility = JavaVersion.VERSION_1_7
	targetCompatibility = JavaVersion.VERSION_1_7
}

// Due to the combination of C++ and Java these dependencies have to be very
// specific in that they only refer to the Java or C++ portion. So
// "implementation" and "compile" cannot be used because the C++ library will
// try to use them during compilation.
dependencies
{
	// SquirrelJME just uses TestNG here since it is flexible enough to
	// support how SquirrelJME needs to be (testing more as if it were running
	// on the target device). Due to the flexibility it allows easier switching
	// from Java SE, SpringCoat, and SummerCoat
	compileClasspath "org.testng:testng:7.1.0"
	runtimeClasspath "org.testng:testng:7.1.0"

	// We need these two modules to obtain the SquirrelJME specific classes
	compileClasspath project(":modules:cldc-compact")

	compileClasspath project(":modules:common-vm")
	compileClasspath project(":modules:io")

	compileClasspath project(":modules:tac")

	compileClasspath project(":modules:zip")

	// And for run-time to be able to be ran
	runtimeClasspath project(":modules:cldc-compact")

	runtimeClasspath project(":modules:common-vm")
	runtimeClasspath project(":modules:io")

	runtimeClasspath project(":modules:tac")

	runtimeClasspath project(":modules:zip")
}

// We need the native library in the JAR before we can properly use it
// But we can compile the Java code just fine without it
jar {
	dependsOn "assembleRelease"

	from buildDir.toPath().resolve("lib").resolve("main").
		resolve("release").toFile()
	into "/"
}

/* -*- Mode: C++; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// -------------------------------------------------------------------------*/

#include "squirreljme.h"
#include "cc_squirreljme_jvm_mle_ObjectShelf.h"

JNIEXPORT jint JNICALL Impl_mle_ObjectShelf_arrayLength(JNIEnv* env,
	jclass classy, jarray array)
{
	jclass classClass;
	jmethodID classIsArrayId;

	if (array == NULL)
		return -1;

	// Determine if this is an array or not
	classClass = env->FindClass("java/lang/Class");
	classIsArrayId = env->GetMethodID(classClass, "isArray", "()Z");
	if (JNI_FALSE == env->CallBooleanMethod(env->GetObjectClass(array),
		classIsArrayId))
		return -1;

	return env->GetArrayLength(array);
}

static const JNINativeMethod mleObjectMethods[] =
{
	{"arrayLength", "(Ljava/lang/Object;)I",
		(void*)Impl_mle_ObjectShelf_arrayLength},
};

jint JNICALL mleObjectInit(JNIEnv* env, jclass classy)
{
	return env->RegisterNatives(
		env->FindClass("cc/squirreljme/jvm/mle/ObjectShelf"),
		mleObjectMethods, sizeof(mleObjectMethods) /
			sizeof(JNINativeMethod));
}

/* -*- Mode: C++; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// -------------------------------------------------------------------------*/

#include "squirreljme.h"
#include "cc_squirreljme_jvm_mle_RuntimeShelf.h"

JNIEXPORT jint JNICALL Impl_mle_RuntimeShelf_lineEnding(JNIEnv*, jclass)
{
#if defined(_WIN32)
	return 3;
#else
	return 1;
#endif
}

JNIEXPORT jint JNICALL Impl_mle_RuntimeShelf_vmType(JNIEnv*, jclass)
{
	// The value 1 is Java SE type
	return 1;
}

static const JNINativeMethod mleRuntimeMethods[] =
{
	{"lineEnding", "()I", (void*)Impl_mle_RuntimeShelf_lineEnding},
	{"vmType", "()I", (void*)Impl_mle_RuntimeShelf_vmType},
};

jint JNICALL mleRuntimeInit(JNIEnv* env, jclass classy)
{
	return env->RegisterNatives(
		env->FindClass("cc/squirreljme/jvm/mle/RuntimeShelf"),
		mleRuntimeMethods, sizeof(mleRuntimeMethods) /
			sizeof(JNINativeMethod));
}

/* -*- Mode: C++; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// -------------------------------------------------------------------------*/

#include <stdio.h>

#include "squirreljme.h"
#include "cc_squirreljme_jvm_mle_TerminalShelf.h"

static FILE* getPipeForFd(jint fd)
{
	if (fd == 1)
		return stdout;
	else if (fd == 2)
		return stderr;
	return NULL;
}

JNIEXPORT jint JNICALL Impl_mle_TerminalShelf_flush(JNIEnv* env,
	jclass classy, jint fd)
{
	FILE* pipe = getPipeForFd(fd);

	if (pipe == NULL)
		return -1;

	if (fflush(pipe) == 0)
		return 1;
	return -1;
}

JNIEXPORT jint JNICALL Impl_mle_TerminalShelf_writeII(JNIEnv* env,
	jclass classy, jint fd, jint code)
{
	FILE* pipe = getPipeForFd(fd);

	if (pipe == NULL)
		return -1;

	if (fputc(code, pipe) >= 0)
		return 1;
	return -1;
}

static const JNINativeMethod mleTerminalMethods[] =
{
	{"flush", "(I)I", (void*)Impl_mle_TerminalShelf_flush},
	{"write", "(II)I", (void*)Impl_mle_TerminalShelf_writeII},
};

jint JNICALL mleTerminalInit(JNIEnv* env, jclass classy)
{
	return env->RegisterNatives(
		env->FindClass("cc/squirreljme/jvm/mle/TerminalShelf"),
		mleTerminalMethods, sizeof(mleTerminalMethods) /
			sizeof(JNINativeMethod));
}

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include "jni.h"
#include "cc_squirreljme_emulator_NativeBinding.h"
#include "cc_squirreljme_jvm_Assembly.h"
#include "squirreljme.h"

// Method handler for special functions
JNIEXPORT void JNICALL doNothing(JNIEnv* env, jclass classy);
JNIEXPORT jint JNICALL doNothingZeroI(JNIEnv* env, jclass classy);
JNIEXPORT void JNICALL notImplemented(JNIEnv* env, jclass classy);
JNIEXPORT void JNICALL restrictedFunction(JNIEnv* env, jclass classy);

// Glue for putting names together
#define GLUE_NAME(name) Java_cc_squirreljme_jvm_Assembly_sysCall##name

// Assembly method mappings
static const JNINativeMethod assemblyMethods[] =
{
	{"arrayLength", "(J)I", (void*)restrictedFunction},
	{"arrayLength", "(Ljava/lang/Object;)I", (void*)restrictedFunction},
	{"arrayLengthSet", "(JI)V", (void*)restrictedFunction},
	{"arrayLengthSet", "(Ljava/lang/Object;I)V", (void*)restrictedFunction},
	{"atomicCompareGetAndSet", "(IIJ)I", (void*)restrictedFunction},
	{"atomicDecrementAndGet", "(J)I", (void*)restrictedFunction},
	{"atomicIncrement", "(J)V", (void*)restrictedFunction},
	{"breakpoint", "()V", (void*)restrictedFunction},
	{"classInfoOfBoolean", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfBooleanPointer", "()J", (void*)restrictedFunction},
	{"classInfoOfByte", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfBytePointer", "()J", (void*)restrictedFunction},
	{"classInfoOfCharacter", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfCharacterPointer", "()J", (void*)restrictedFunction},
	{"classInfoOfDouble", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfDoublePointer", "()J", (void*)restrictedFunction},
	{"classInfoOfFloat", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfFloatPointer", "()J", (void*)restrictedFunction},
	{"classInfoOfInteger", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfIntegerPointer", "()J", (void*)restrictedFunction},
	{"classInfoOfLong", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfLongPointer", "()J", (void*)restrictedFunction},
	{"classInfoOfShort", "()Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"classInfoOfShortPointer", "()J", (void*)restrictedFunction},
	{"doublePack", "(II)D", (void*)restrictedFunction},
	{"doubleToRawLongBits", "(D)J", (void*)restrictedFunction},
	{"doubleUnpackHigh", "(D)I", (void*)restrictedFunction},
	{"doubleUnpackLow", "(D)I", (void*)restrictedFunction},
	{"exceptionHandle", "()V", (void*)restrictedFunction},
	{"floatToRawIntBits", "(F)I", (void*)restrictedFunction},
	{"intBitsToFloat", "(I)F", (void*)restrictedFunction},
	{"invoke", "(JJ)V", (void*)restrictedFunction},
	{"invoke", "(JJI)V", (void*)restrictedFunction},
	{"invoke", "(JJII)V", (void*)restrictedFunction},
	{"invoke", "(JJIII)V", (void*)restrictedFunction},
	{"invoke", "(JJIIII)V", (void*)restrictedFunction},
	{"invoke", "(JJIIIII)V", (void*)restrictedFunction},
	{"invoke", "(JJIIIIII)V", (void*)restrictedFunction},

	{"invokeVL", "(JJII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIIII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIIIII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIIIIII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIIIIIII)J", (void*)restrictedFunction},
	{"invokeVL", "(JJIIIIIIII)J", (void*)restrictedFunction},
	{"longBitsToDouble", "(J)D", (void*)restrictedFunction},
	{"longPack", "(II)J", (void*)restrictedFunction},
	{"longUnpackHigh", "(J)I", (void*)restrictedFunction},
	{"longUnpackLow", "(J)I", (void*)restrictedFunction},
	{"memReadByte", "(JI)I", (void*)restrictedFunction},
	{"memReadInt", "(JI)I", (void*)restrictedFunction},
	{"memReadJavaInt", "(JI)I", (void*)restrictedFunction},
	{"memReadJavaLong", "(JI)J", (void*)restrictedFunction},
	{"memReadJavaShort", "(JI)I", (void*)restrictedFunction},
	{"memReadPointer", "(JI)J", (void*)restrictedFunction},
	{"memReadShort", "(JI)I", (void*)restrictedFunction},
	{"memWriteByte", "(JII)V", (void*)restrictedFunction},
	{"memWriteInt", "(JII)V", (void*)restrictedFunction},
	{"memWriteJavaInt", "(JII)V", (void*)restrictedFunction},
	{"memWriteJavaLong", "(JIJ)V", (void*)restrictedFunction},
	{"memWriteJavaShort", "(JII)V", (void*)restrictedFunction},
	{"memWritePointer", "(JIJ)V", (void*)restrictedFunction},
	{"memWriteShort", "(JII)V", (void*)restrictedFunction},
	{"monitorCountDecrementAndGetAtomic", "(J)I", (void*)restrictedFunction},
	{"monitorCountDecrementAndGetAtomic", "(Ljava/lang/Object;)I", (void*)restrictedFunction},
	{"monitorCountIncrementAndGetAtomic", "(J)I", (void*)restrictedFunction},
	{"monitorCountIncrementAndGetAtomic", "(Ljava/lang/Object;)I", (void*)restrictedFunction},
	{"monitorCountGetAtomic", "(J)I", (void*)restrictedFunction},
	{"monitorCountGetAtomic", "(Ljava/lang/Object;)I", (void*)restrictedFunction},
	{"monitorCountSetAtomic", "(JI)V", (void*)restrictedFunction},

	{"objectGetClassInfo", "(Ljava/lang/Object;)Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"objectGetClassInfoPointer", "(J)J", (void*)restrictedFunction},
	{"objectGetClassInfoPointer", "(Ljava/lang/Object;)J", (void*)restrictedFunction},
	{"objectSetClassInfo", "(JJ)V", (void*)restrictedFunction},
	{"objectSetClassInfo", "(Ljava/lang/Object;J)V", (void*)restrictedFunction},
	{"objectSetClassInfo", "(JLcc/squirreljme/jvm/ClassInfo;)V", (void*)restrictedFunction},
	{"objectSetClassInfo", "(Ljava/lang/Object;Lcc/squirreljme/jvm/ClassInfo;)V", (void*)restrictedFunction},
	{"objectToPointer", "(Ljava/lang/Object;)J", (void*)restrictedFunction},
	{"objectToPointerRefQueue", "(Ljava/lang/Object;)J", (void*)restrictedFunction},
	{"pointerToObject", "(J)Ljava/lang/Object;", (void*)restrictedFunction},
	{"pointerToClassInfo", "(J)Lcc/squirreljme/jvm/ClassInfo;", (void*)restrictedFunction},
	{"poolLoad", "(JI)J", (void*)restrictedFunction},
	{"poolLoad", "(Ljava/lang/Object;I)J", (void*)restrictedFunction},
	{"poolStore", "(JIJ)V", (void*)restrictedFunction},
	{"poolStore", "(Ljava/lang/Object;IJ)V", (void*)restrictedFunction},
	{"refCount", "(J)V", (void*)restrictedFunction},
	{"refCount", "(Ljava/lang/Object;)V", (void*)restrictedFunction},
	{"refGetCount", "(J)I", (void*)restrictedFunction},
	{"refGetCount", "(Ljava/lang/Object;)I", (void*)restrictedFunction},
	{"refSetCount", "(JI)V", (void*)restrictedFunction},
	{"refSetCount", "(Ljava/lang/Object;I)V", (void*)restrictedFunction},
	{"refUncount", "(J)V", (void*)restrictedFunction},
	{"refUncount", "(Ljava/lang/Object;)V", (void*)restrictedFunction},
	{"returnFrame", "()V", (void*)restrictedFunction},
	{"returnFrame", "(I)V", (void*)restrictedFunction},
	{"returnFrame", "(II)V", (void*)restrictedFunction},
	{"returnFrameLong", "(J)V", (void*)restrictedFunction},
	{"sizeOfBaseArray", "()I", (void*)restrictedFunction},
	{"sizeOfBaseObject", "()I", (void*)restrictedFunction},
	{"sizeOfPointer", "()I", (void*)restrictedFunction},
	{"specialGetExceptionRegister", "()Ljava/lang/Object;", (void*)restrictedFunction},
	{"specialGetExceptionRegisterThrowable", "()Ljava/lang/Throwable;", (void*)restrictedFunction},
	{"specialGetExceptionRegisterPointer", "()J", (void*)restrictedFunction},
	{"specialGetPoolRegister", "()Ljava/lang/Object;", (void*)restrictedFunction},
	{"specialGetPoolRegisterPointer", "()J", (void*)restrictedFunction},
	{"specialGetReturnRegister", "()I", (void*)restrictedFunction},
	{"specialGetReturnRegisterLong", "()J", (void*)restrictedFunction},

	env->ThrowNew(env->FindClass("java/lang/Error"),
		__func__);
}

JNIEXPORT jint JNICALL Java_cc_squirreljme_emulator_NativeBinding__1_1bindMethods
	(JNIEnv* env, jclass classy)
{
	jint rv = 0;

	rv |= env->RegisterNatives(env->FindClass("cc/squirreljme/jvm/Assembly"),
		assemblyMethods, sizeof(assemblyMethods) / sizeof(JNINativeMethod));

	rv |= mleRuntimeInit(env, classy);
	rv |= mleObjectInit(env, classy);
	rv |= mleTerminalInit(env, classy);

	return rv;
}

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cc_squirreljme_jvm_mle_ObjectShelf */

#ifndef _Included_cc_squirreljme_jvm_mle_ObjectShelf
#define _Included_cc_squirreljme_jvm_mle_ObjectShelf
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     cc_squirreljme_jvm_mle_ObjectShelf
 * Method:    arrayLength
 * Signature: (Ljava/lang/Object;)I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_ObjectShelf_arrayLength
  (JNIEnv *, jclass, jobject);

/*
 * Class:     cc_squirreljme_jvm_mle_ObjectShelf
 * Method:    arrayNew
 * Signature: (Lcc/squirreljme/jvm/mle/brackets/TypeBracket;I)Ljava/lang/Object;
 */
JNIEXPORT jobject JNICALL Java_cc_squirreljme_jvm_mle_ObjectShelf_arrayNew
  (JNIEnv *, jclass, jobject, jint);

#ifdef __cplusplus
}
#endif
#endif

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cc_squirreljme_jvm_mle_RuntimeShelf */

#ifndef _Included_cc_squirreljme_jvm_mle_RuntimeShelf
#define _Included_cc_squirreljme_jvm_mle_RuntimeShelf
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     cc_squirreljme_jvm_mle_RuntimeShelf
 * Method:    encoding
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_RuntimeShelf_encoding
  (JNIEnv *, jclass);

/*
 * Class:     cc_squirreljme_jvm_mle_RuntimeShelf
 * Method:    lineEnding
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_RuntimeShelf_lineEnding
  (JNIEnv *, jclass);

/*
 * Class:     cc_squirreljme_jvm_mle_RuntimeShelf
 * Method:    locale
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_RuntimeShelf_locale
  (JNIEnv *, jclass);

/*
 * Class:     cc_squirreljme_jvm_mle_RuntimeShelf
 * Method:    vmType
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_RuntimeShelf_vmType
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cc_squirreljme_jvm_mle_TerminalShelf */

#ifndef _Included_cc_squirreljme_jvm_mle_TerminalShelf
#define _Included_cc_squirreljme_jvm_mle_TerminalShelf
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     cc_squirreljme_jvm_mle_TerminalShelf
 * Method:    flush
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_TerminalShelf_flush
  (JNIEnv *, jclass, jint);

/*
 * Class:     cc_squirreljme_jvm_mle_TerminalShelf
 * Method:    write
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_TerminalShelf_write__II
  (JNIEnv *, jclass, jint, jint);

/*
 * Class:     cc_squirreljme_jvm_mle_TerminalShelf
 * Method:    write
 * Signature: (I[BII)I
 */
JNIEXPORT jint JNICALL Java_cc_squirreljme_jvm_mle_TerminalShelf_write__I_3BII
  (JNIEnv *, jclass, jint, jbyteArray, jint, jint);

#ifdef __cplusplus
}
#endif
#endif

/* -*- Mode: C++; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// -------------------------------------------------------------------------*/

#ifndef __SQUIRRELJME_H__
#define __SQUIRRELJME_H__

#include "jni.h"

jint JNICALL mleRuntimeInit(JNIEnv* env, jclass classy);
jint JNICALL mleObjectInit(JNIEnv* env, jclass classy);
jint JNICALL mleTerminalInit(JNIEnv* env, jclass classy);

#endif /* __SQUIRRELJME_H__ */

package cc.squirreljme.emulator;

import cc.squirreljme.emulator.fb.NativeFramebuffer;
import cc.squirreljme.jvm.SystemCallError;
import cc.squirreljme.jvm.SystemCallIndex;
import cc.squirreljme.jvm.config.ConfigRomKey;
import cc.squirreljme.jvm.config.ConfigRomType;
import cc.squirreljme.jvm.mle.constants.LineEndingType;
import java.io.IOException;
import java.io.OutputStream;

/**
 * This contains the implementation of some system calls in the event that the
 * JNI emulation layer does not have a C-based implementation of a method.
 *

	 * @param __h Argument.
	 * @return The result.
	 * @since 2020/02/26
	 */
	public static long systemCall(short __si, int __a, int __b,
		int __c, int __d, int __e, int __f, int __g, int __h)
	{


		throw new Error("Invalid Emulator System Call");




























































































































































	}
	
	/**
	 * Returns the current thread context.
	 *
	 * @return The thread context.
	 * @since 2020/02/26

				e.addSuppressed(f);
			}
			
			throw new RuntimeException("Could not copy native library.", e);
		}
		
		// Attempt cleanup at shutdown.

		Runtime.getRuntime().addShutdownHook(









			new PathCleanup(libFile, tempDir));
		
		// Try loading the library now
		System.load(libFile.toString());
		
		// Bind methods
		if (NativeBinding.__bindMethods() != 0)
			throw new RuntimeException("Could not bind methods!");

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.emulator;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

/**
 * Cleanup for paths.
 *
 * @since 2020/06/22
 */
public final class PathCleanup
	extends Thread
{
	/** The paths to clear. */
	private final Path[] _paths;
	
	/**
	 * Cleans up the paths.
	 * 
	 * @param __paths The paths to clear.
	 * @since 2020/06/22
	 */
	public PathCleanup(Path... __paths)
	{
		this._paths = (__paths == null ? new Path[0] : __paths.clone());
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/22
	 */
	@Override
	public final void run()
	{
		for (Path p : this._paths)
			try
			{
				Files.delete(p);
			}
			catch (IOException ignored)
			{
			}
	}
}

	private long _currentstart =
		Long.MIN_VALUE;
	
	/** Current time sub-frame started execution, to remove self time. */
	private long _currentsubstart =
		Long.MIN_VALUE;
	
	/** The current in-call count for this frame. */
	private int _inCallCount;
	
	/**
	 * Initializes this frame.
	 *
	 * @param __l The frame location.
	 * @param __d The depth of this frame.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/11

			
		// {@squirreljme.error AH02 Cannot enter frame that is in an invoke.}
		if (this._currentsubstart != Long.MIN_VALUE)
			throw new IllegalStateException("AH02");
		
		// Mark time
		this._currentstart = __ns;
		
		// Increase call count
		this._inCallCount++;
	}
	
	/**
	 * Indicates that the frame has been exited.
	 *
	 * @param __ns The time of the exit.
	 * @return The time spent in this frame, in total, self time, and CPU

		// And only this frame time
		this._frameruntime += self;
		this._framecputime += self;
		
		// Clear these for next time
		this._currentstart = Long.MIN_VALUE;
		this._subtractself = 0;
		
		// Lower the in-call count, make sure it never goes below zero
		if ((--this._inCallCount) < 0)
			this._inCallCount = 0;
		
		// Return both times since they may be useful
		return new long[]{total, self, total};
	}
	
	/**
	 * Returns the number of times this frame is currently in a call.
	 *
	 * @return The number of times this frame is considered in a call.
	 * @since 2020/06/17
	 */
	public final int inCallCount()
	{
		return this._inCallCount;
	}
	
	/**
	 * Indicates that this frame is no longer invoking some other method.
	 *
	 * @param __ns The ending nanoseconds.
	 * @return The time which has passed.
	 * @throws IllegalStateException If the frame is not in an invoke.

// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.emulator.vm;

import cc.squirreljme.emulator.profiler.ProfilerSnapshot;
import cc.squirreljme.runtime.cldc.Poking;

import cc.squirreljme.vm.JarClassLibrary;
import cc.squirreljme.vm.NameOverrideClassLibrary;
import cc.squirreljme.vm.VMClassLibrary;
import java.io.File;
import java.io.IOException;

import java.io.OutputStream;
import java.nio.file.FileVisitOption;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.ServiceLoader;
import java.util.stream.Stream;


/**
 * This class is used to initialize virtual machines based on a set of factory
 * classes.
 *
 * This was added because there were many cases where tons of code was
 * duplicated to initialize the virtual machine, which were effectively

		// -Xemulator:(vm)
		// -Xsnapshot:(path-to-nps)
		// -Xlibraries:(class:path:...)
		// -Dsysprop=value
		// -classpath (class:path:...)
		// Main-class
		// Arguments...
		Deque<String> queue = new LinkedList<>(Arrays.<String>asList(__args));
		while (!queue.isEmpty())
		{
			// End of our items?
			String item = queue.peekFirst();
			if (item == null || item.isEmpty() || item.charAt(0) != '-')
				break;
			

		if (!__path.endsWith("*"))
		{
			__files.add(__path);
			return;
		}
		
		// Try searching for JAR files in a directory
		try


		{


			Path startPath = Paths.get(

				__path.substring(0, __path.length() - 1));

			Files.walkFileTree(startPath, new __JarWalker__(__files));
		}
		catch (IOException e)
		{
			throw new RuntimeException(String.format(
				"Could not load wildcard JARs: %s", __path), e);
		}
	}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.emulator.vm;

import cc.squirreljme.runtime.cldc.debug.Debugging;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Collection;

/**
 * Walks the file tree for wildcard JARs.
 *
 * @since 2020/06/22
 */
public final class __JarWalker__
	extends SimpleFileVisitor<Path>
{
	/** Where to place found files. */
	private final Collection<String> _files;
	
	/**
	 * Initializes the Jar walker.
	 * 
	 * @param __files The files to write to.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/22
	 */
	public __JarWalker__(Collection<String> __files)
		throws NullPointerException
	{
		if (__files == null)
			throw new NullPointerException("NARG");
		
		this._files = __files;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/22
	 */
	@Override
	public FileVisitResult visitFile(Path __path, BasicFileAttributes __attrib)
		throws IOException
	{
		// If this is a JAR, we will grab it
		String fn = __path.getFileName().toString();
		if (fn.endsWith(".jar") || fn.endsWith(".JAR"))
			this._files.add(__path.toString());
		
		// The default way is to just handle it
		return super.visitFile(__path, __attrib);
	}
}

plugins
{
	id "java-library"
}

description = "This is a SpringCoat virtual machine which " +
	"is an unoptimized pure interpreter aimed for the purpose of being an " +
	"educational stepping stone to other future virtual machines."

dependencies
{
	api project(":emulators:emulator-base")
	
	api project(":modules:cldc-compact")
	api project(":modules:common-vm")

	api project(":modules:meep-swm")
	api project(":modules:tool-classfile")
	api project(":modules:tool-manifest-reader")

}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.brackets.RefLinkHolder;
import cc.squirreljme.vm.springcoat.exceptions.SpringVirtualMachineException;

/**
 * This is the base for ghost objects which do not have a defined class type
 * or anything associated with a class object.
 *
 * @since 2020/05/30
 */
public abstract class AbstractGhostObject
	implements SpringObject
{
	/**
	 * {@inheritDoc}
	 * @since 2020/05/30
	 */
	@Override
	public final SpringMonitor monitor()
	{
		throw new SpringVirtualMachineException(
			"Ghost objects cannot have monitors: " + this.toString());
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/05/31
	 */
	@Override
	public RefLinkHolder refLink()
	{
		throw new SpringVirtualMachineException(
			"Ghost objects cannot have refLinks: " + this.toString());
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/05/30
	 */
	@Override
	public final SpringClass type()
	{
		throw new SpringVirtualMachineException(
			"Ghost objects cannot have types: " + this.toString());
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Contains virtual machine global state.
 *
 * @since 2020/05/30
 */
public final class GlobalState
{
	/** Ticker for atomic values. */
	public static final AtomicInteger TICKER =
		new AtomicInteger();
	
	/** The GC lock. */
	public static final AtomicInteger GC_LOCK =
		new AtomicInteger();
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.AtomicShelf;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;

/**
 * Functions for {@link AtomicShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEAtomic
	implements MLEFunction
{
	/** {@link AtomicShelf#gcLock()}. */
	GC_LOCK("gcLock:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Generate a key which will be returned in the lock
			int key = (int)MLEAtomic.TICK.handle(__thread);
			
			// When unlocked the lock will have zero, so we can set it to the
			// key we generated... otherwise we fail here
			if (GlobalState.GC_LOCK.compareAndSet(0, key))
				return key;
			return 0;
		}
	},
	
	/** {@link AtomicShelf#gcUnlock(int)}. */
	GC_UNLOCK("gcUnlock:(I)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Unlocking is simple and only works if we have the key used to
			// lock the garbage collector
			if (!GlobalState.GC_LOCK.compareAndSet((int)__args[0], 0))
				throw new SpringMLECallError("Wrong lock code.");
			
			return null;
		}
	},
	
	/** {@link AtomicShelf#spinLock(int)}. */
	SPIN_LOCK("spinLock:(I)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int count = (int)__args[0];
			
			if (count < 0)
				throw new SpringMLECallError("Negative spin count.");
			
			// If we spin for too long, instead give up our cycles
			if (count > MLEAtomic._SPIN_LIMIT)
				Thread.yield();
			
			return null;
		}
	},
	
	/** {@link AtomicShelf#tick()}. */
	TICK("tick:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return GlobalState.TICKER.decrementAndGet();
		}
	},
	
	/* End. */
	;
	
	/** How many times to spin before yielding. */
	private static final int _SPIN_LIMIT =
		8;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEAtomic(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.DebugShelf;
import cc.squirreljme.jvm.mle.brackets.TracePointBracket;
import cc.squirreljme.runtime.cldc.debug.CallTraceElement;
import cc.squirreljme.vm.springcoat.brackets.TracePointObject;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;

/**
 * Functions for {@link DebugShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEDebug
	implements MLEFunction
{
	/** {@link DebugShelf#getThrowableTrace(Throwable)}. */
	GET_THROWABLE_TRACE("getThrowableTrace:(Ljava/lang/Throwable;)" +
		"[Lcc/squirreljme/jvm/mle/brackets/TracePointBracket;")
	{
		/**
		 * {@inheritDoc
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject object = (SpringObject)__args[0];
			
			// Must be throwable type
			if (!(object instanceof SpringSimpleObject) ||
				object.type().isAssignableFrom(
				__thread.resolveClass("java/lang/Throwable")))
				throw new SpringMLECallError("Not a Throwable.");
			
			return ((SpringSimpleObject)object).fieldByNameAndType(
				false, "_stack",
				"[Lcc/squirreljme/jvm/mle/brackets/TracePointBracket;")
				.get();
		}
	},
	
	/** {@link DebugShelf#pointAddress(TracePointBracket)}. */
	POINT_ADDRESS("pointAddress:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TracePointBracket;)J")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEDebug.__trace(__args[0]).getTrace().address();
		}
	},
	
	/** {@link DebugShelf#pointClass(TracePointBracket)} .*/
	POINT_CLASS("pointClass:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TracePointBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEDebug.__trace(__args[0])
				.getTrace().className());
		}
	},
	
	/** {@link DebugShelf#pointFile(TracePointBracket)}. */
	POINT_FILE("pointFile:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TracePointBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEDebug.__trace(__args[0])
				.getTrace().file());
		}
	},
	
	/** {@link DebugShelf#pointJavaAddress(TracePointBracket)}. */
	POINT_JAVA_ADDRESS("pointJavaAddress:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TracePointBracket;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEDebug.__trace(__args[0]).getTrace().byteCodeAddress();
		}
	},
	
	/** {@link DebugShelf#pointJavaOperation(TracePointBracket)}. */
	POINT_JAVA_OPERATION("pointJavaOperation:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TracePointBracket;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEDebug.__trace(__args[0]).getTrace()
				.byteCodeInstruction();
		}
	},
	
	/** {@link DebugShelf#pointLine(TracePointBracket)}. */
	POINT_LINE("pointLine:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TracePointBracket;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEDebug.__trace(__args[0]).getTrace().line();
		}
	},
	
	/** {@link DebugShelf#pointMethodName(TracePointBracket)}. */
	POINT_METHOD_NAME("pointMethodName:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TracePointBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEDebug.__trace(__args[0])
				.getTrace().methodName());
		}
	},
	
	/** {@link DebugShelf#pointMethodType(TracePointBracket)}. */
	POINT_METHOD_TYPE( "pointMethodType:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TracePointBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEDebug.__trace(__args[0])
				.getTrace().methodDescriptor());
		}
	},
	
	/** {@link DebugShelf#traceStack()}. */
	TRACE_STACK("traceStack:()" +
		"[Lcc/squirreljme/jvm/mle/brackets/TracePointBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			CallTraceElement[] trace = __thread.thread.getStackTrace();
			
			int n = trace.length;
			TracePointObject[] rv = new TracePointObject[n];
			
			for (int i = 0; i < n; i++)
				rv[i] = new TracePointObject(trace[i]);
			
			return __thread.asVMObjectArray(__thread.loadClass(
				"[Lcc/squirreljme/jvm/mle/brackets/TracePointBracket;"),
				rv);
		}
	}
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEDebug(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Checks if this is a trace point object.
	 * 
	 * @param __object The object to check.
	 * @return As a trace point if this is one.
	 * @throws SpringMLECallError If this is not a trace point object.
	 * @since 2020/06/22
	 */
	static TracePointObject __trace(Object __object)
		throws SpringMLECallError
	{
		if (!(__object instanceof TracePointObject))
			throw new SpringMLECallError("Not a trace point.");
		
		return (TracePointObject)__object; 
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.AtomicShelf;
import cc.squirreljme.jvm.mle.DebugShelf;
import cc.squirreljme.jvm.mle.JarPackageShelf;
import cc.squirreljme.jvm.mle.MathShelf;
import cc.squirreljme.jvm.mle.ObjectShelf;
import cc.squirreljme.jvm.mle.ReferenceShelf;
import cc.squirreljme.jvm.mle.RuntimeShelf;
import cc.squirreljme.jvm.mle.TerminalShelf;
import cc.squirreljme.jvm.mle.ThreadShelf;
import cc.squirreljme.jvm.mle.TypeShelf;
import cc.squirreljme.vm.springcoat.exceptions.SpringVirtualMachineException;
import java.util.Map;
import java.util.TreeMap;
import net.multiphasicapps.classfile.ClassName;
import net.multiphasicapps.classfile.MethodNameAndType;

/**
 * Not Described.
 *
 * @since 2020/06/18
 */
public enum MLEDispatcher
	implements MLEDispatcherKey
{
	/** {@link AtomicShelf}. */
	ATOMIC("cc/squirreljme/jvm/mle/AtomicShelf",
		MLEAtomic.values()),
	
	/** {@link DebugShelf}. */
	DEBUG("cc/squirreljme/jvm/mle/DebugShelf",
		MLEDebug.values()),
	
	/** {@link JarPackageShelf}. */
	JAR_PACKAGE("cc/squirreljme/jvm/mle/JarPackageShelf",
		MLEJarPackage.values()),
	
	/** {@link MathShelf}. */
	MATH("cc/squirreljme/jvm/mle/MathShelf",
		MLEMath.values()),
	
	/** {@link ObjectShelf}. */
	OBJECT("cc/squirreljme/jvm/mle/ObjectShelf",
		MLEObject.values()),
	
	/** {@link ReferenceShelf}. */
	REFERENCE("cc/squirreljme/jvm/mle/ReferenceShelf",
		MLEReference.values()),
	
	/** {@link RuntimeShelf}. */
	RUNTIME("cc/squirreljme/jvm/mle/RuntimeShelf",
		MLERuntime.values()),
	
	/** {@link TerminalShelf}. */
	TERMINAL("cc/squirreljme/jvm/mle/TerminalShelf",
		MLETerminal.values()),
	
	/** {@link ThreadShelf}. */
	THREAD("cc/squirreljme/jvm/mle/ThreadShelf",
		MLEThread.values()),
	
	/** {@link TypeShelf}. */
	TYPE("cc/squirreljme/jvm/mle/TypeShelf",
		MLEType.values()),
	
	/* End. */
	;
	
	/** The function tree. */
	private static Map<String, Map<String, MLEDispatcherTarget>> _fnTree;
	
	/** The dispatcher key. */
	protected final String key;
	
	/** The functions. */
	private final MLEFunction[] _functions;
	
	static
	{
		Map<String, Map<String, MLEDispatcherTarget>> functionTree =
			new TreeMap<>();
		
		// Build the function tree
		for (MLEDispatcher dispatch : MLEDispatcher.values())
		{
			Map<String, MLEDispatcherTarget> subTree = new TreeMap<>();
			
			for (MLEFunction function : dispatch._functions)
				subTree.put(function.key(), function);
			
			functionTree.put(dispatch.key(), subTree);
		}
		
		MLEDispatcher._fnTree = functionTree;
	}
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @param __functions Functions for the dispatcher.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEDispatcher(String __key, MLEFunction[] __functions)
		throws NullPointerException
	{
		if (__key == null || __functions == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
		this._functions = __functions;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Handles the dispatching of the native method.
	 *
	 * @param __thread The current thread this is acting under.
	 * @param __class The native class being called.
	 * @param __func The method being called.
	 * @param __args The arguments to the call.
	 * @return The resulting object returned by the dispatcher.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/05/30
	 */
	public static Object dispatch(SpringThreadWorker __thread,
		ClassName __class, MethodNameAndType __func, Object... __args)
		throws NullPointerException
	{
		if (__thread == null || __class == null)
			throw new NullPointerException("NARG");
		
		// Find the sub-tree
		Map<String, MLEDispatcherTarget> subTree = MLEDispatcher._fnTree.get(
			__class.toString());
		if (subTree == null)
			throw new SpringVirtualMachineException(String.format(
				"Unknown MLE Shelf: %s", __class));
		
		// Find the target function
		MLEDispatcherTarget target = subTree.get(__func.toString());
		if (target == null)
			throw new SpringVirtualMachineException(String.format(
				"Unknown MLE Shelf Function: %s::%s", __class, __func));
		
		// Call it
		return target.handle(__thread, __args);
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

/**
 * This interface is used to represent keys for the dispatcher.
 *
 * @since 2020/06/18
 */
public interface MLEDispatcherKey
{
	/**
	 * Returns the key for the item.
	 *
	 * @return The key for the item.
	 * @since 2020/06/18
	 */
	String key();
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

/**
 * This represents a target for MLE dispatching.
 *
 * @since 2020/06/18
 */
public interface MLEDispatcherTarget
{
	/**
	 * Handles the MLE call.
	 *
	 * @param __thread The thread to dispatch.
	 * @param __args The arguments.
	 * @return The result of the call.
	 * @since 2020/06/18
	 */
	Object handle(SpringThreadWorker __thread, Object... __args);
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

/**
 * This represents a function in the MLE.
 *
 * @since 2020/06/18
 */
public interface MLEFunction
	extends MLEDispatcherKey, MLEDispatcherTarget
{
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.JarPackageShelf;
import cc.squirreljme.jvm.mle.brackets.JarPackageBracket;
import cc.squirreljme.vm.VMClassLibrary;
import cc.squirreljme.vm.springcoat.brackets.JarPackageObject;
import cc.squirreljme.vm.springcoat.brackets.TracePointObject;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
import cc.squirreljme.vm.springcoat.exceptions.SpringVirtualMachineException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import net.multiphasicapps.classfile.MethodDescriptor;

/**
 * Functions for {@link JarPackageShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEJarPackage
	implements MLEFunction
{
	/** {@link JarPackageShelf#classPath()}. */
	CLASS_PATH("classPath:()[Lcc/squirreljme/jvm/mle/brackets/" +
		"JarPackageBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			VMClassLibrary[] springPath = __thread.machine.classloader
				.classPath();
		
			// Wrap the classpath in package objects
			int n = springPath.length;
			SpringObject[] rv = new SpringObject[n];
			for (int i = 0; i < n; i++)
				rv[i] = new JarPackageObject(springPath[i]);
			
			// Wrap
			return __thread.asVMObjectArray(__thread.resolveClass(
				"[Lcc/squirreljme/jvm/mle/brackets/JarPackageBracket;"),
				rv);
		}
	},
	
	/** {@link JarPackageShelf#openResource(JarPackageBracket, String)}. */
	OPEN_RESOURCE("openResource:(Lcc/squirreljme/jvm/mle/brackets/" +
		"JarPackageBracket;Ljava/lang/String;)Ljava/io/InputStream;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			JarPackageObject jar = MLEJarPackage.__jarObject(__args[0]);
			
			String rcName = __thread.<String>asNativeObject(
				String.class, __args[1]);
			if (rcName == null)
				throw new SpringMLECallError("Null resource string.");
			
			// Locate the resource
			try (InputStream in = jar.library().resourceAsStream(rcName))
			{
				// Not found
				if (in == null)
					return SpringNullObject.NULL;
				
				// Copy everything to the a byte array, since it is easier to
				// handle resources without juggling special resource streams
				// and otherwise
				try (ByteArrayOutputStream baos = new ByteArrayOutputStream(
					Math.max(1024, in.available())))
				{
					// Copy all the data
					byte[] copy = new byte[4096];
					for (;;)
					{
						int rc = in.read(copy);
						
						if (rc < 0)
							break;
						
						baos.write(copy, 0, rc);
					}
					
					// Use this as the stream input
					return __thread.newInstance(__thread.loadClass(
						"java/io/ByteArrayInputStream"),
						new MethodDescriptor("([B)V"),
						__thread.asVMObject(baos.toByteArray()));
				}
			}
			
			// Could not read it
			catch (IOException e)
			{
				throw new SpringVirtualMachineException(
					"Failed to read resource", e);
			}
		}
	}
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEJarPackage(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Checks if this is a {@link JarPackageObject}.
	 * 
	 * @param __object The object to check.
	 * @return As a jar if this is one.
	 * @throws SpringMLECallError If this is not a jar.
	 * @since 2020/06/22
	 */
	static JarPackageObject __jarObject(Object __object)
		throws SpringMLECallError
	{
		if (!(__object instanceof JarPackageObject))
			throw new SpringMLECallError("Not a JarPackageObject.");
		
		return (JarPackageObject)__object; 
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.MathShelf;

/**
 * Functions for {@link MathShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEMath
	implements MLEFunction
{
	/** {@link MathShelf#rawDoubleToLong(double)}. */
	RAW_DOUBLE_TO_LONG("rawDoubleToLong:(D)J")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return Double.doubleToRawLongBits((double)__args[0]);
		}
	},
	
	/** {@link MathShelf#rawFloatToInt(float)}. */
	RAW_FLOAT_TO_INT("rawFloatToInt:(F)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return Float.floatToRawIntBits((float)__args[0]);
		}
	},
	
	/** {@link MathShelf#rawIntToFloat(int)}. */
	RAW_INT_TO_FLOAT("rawIntToFloat:(I)F")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return Float.intBitsToFloat((int)__args[0]);
		}
	},
	
	/** {@link MathShelf#rawLongToDouble(long)}. */
	RAW_LONG_TO_DOUBLE("rawLongToDouble:(J)D")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return Double.longBitsToDouble((long)__args[0]);
		}
	},
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEMath(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.ObjectShelf;
import cc.squirreljme.jvm.mle.brackets.TypeBracket;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
import net.multiphasicapps.classfile.MethodDescriptor;

/**
 * Functions for {@link MLEObject}.
 *
 * @since 2020/06/18
 */
public enum MLEObject
	implements MLEFunction
{
	/** {@link ObjectShelf#arrayCopy(boolean[], int, boolean[], int, int)}. */
	ARRAY_COPY_BOOLEAN("arrayCopy:([ZI[ZII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectBoolean>__arrayCopy(
				SpringArrayObjectBoolean.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(byte[], int, byte[], int, int)}. */
	ARRAY_COPY_BYTE("arrayCopy:([BI[BII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectByte>__arrayCopy(
				SpringArrayObjectByte.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(short[], int, short[], int, int)}. */
	ARRAY_COPY_SHORT("arrayCopy:([SI[SII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectShort>__arrayCopy(
				SpringArrayObjectShort.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(char[], int, char[], int, int)}. */
	ARRAY_COPY_CHAR("arrayCopy:([CI[CII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectChar>__arrayCopy(
				SpringArrayObjectChar.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(int[], int, int[], int, int)}. */
	ARRAY_COPY_INTEGER("arrayCopy:([II[III)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectInteger>__arrayCopy(
				SpringArrayObjectInteger.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(long[], int, long[], int, int)}. */
	ARRAY_COPY_LONG("arrayCopy:([JI[JII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectLong>__arrayCopy(
				SpringArrayObjectLong.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(float[], int, float[], int, int)}. */
	ARRAY_COPY_FLOAT("arrayCopy:([FI[FII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectFloat>__arrayCopy(
				SpringArrayObjectFloat.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayCopy(double[], int, double[], int, int)}. */
	ARRAY_COPY_DOUBLE("arrayCopy:([DI[DII)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEObject.<SpringArrayObjectDouble>__arrayCopy(
				SpringArrayObjectDouble.class,
				__args[0], (int)__args[1],
				__args[2], (int)__args[3], (int)__args[4]);
			return null;
		}
	},
	
	/** {@link ObjectShelf#arrayLength(Object)}. */
	ARRAY_LENGTH("arrayLength:(Ljava/lang/Object;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject object = MLEType.__notNullObject(__args[0]);
			
			if (object instanceof SpringArrayObject)
				return ((SpringArrayObject)object).length();
			
			return -1;
		}
	},
	
	/** {@link ObjectShelf#arrayNew(TypeBracket, int)}. */
	ARRAY_NEW( "arrayNew:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;I)Ljava/lang/Object;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int len = (int)__args[1];
			if (len < 0)
				throw new SpringMLECallError("Negative array size.");
			
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			if (!type.isArray())
				throw new SpringMLECallError("Type not an array.");
			
			return __thread.allocateArray(type, len);
		}
	},
	
	/** {@link ObjectShelf#holdsLock(Thread, Object)}. */
	HOLDS_LOCK("holdsLock:(Ljava/lang/Thread;Ljava/lang/Object;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/27
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringThread vmThread = MLEThread.__vmThread(
				MLEThread.TO_VM_THREAD.handle(__thread, __args[0]))
				.getThread();
			SpringObject target = (SpringObject)__args[1];
			
			// Cannot be null
			if (target == null || target == SpringNullObject.NULL)
				throw new SpringMLECallError("Target object is null.");
			
			return target.monitor().isHeldBy(vmThread);
		}
	}, 
	
	/** {@link ObjectShelf#identityHashCode(Object)}. */
	IDENTITY_HASH_CODE("identityHashCode:(Ljava/lang/Object;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject object = (SpringObject)__args[0];
			return System.identityHashCode(MLEType.__notNullObject(object));
		}
	},
	
	/** {@link ObjectShelf#newInstance(TypeBracket)}. */
	NEW_INSTANCE("newInstance:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Ljava/lang/Object;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			
			if (type.isArray())
				throw new SpringMLECallError("Cannot newInstance array");
			
			return __thread.newInstance(type, new MethodDescriptor("()V"));
		}
	},
	
	/** {@link ObjectShelf#notify(Object, boolean)}. */
	NOTIFY("notify:(Ljava/lang/Object;Z)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject target = MLEType.__notNullObject(__args[0]);
			boolean notifyAll = (int)__args[1] != 0; 
			
			// Signal the monitor
			return target.monitor().monitorNotify(__thread.thread, notifyAll);
		}
	},
	
	/** {@link ObjectShelf#wait(Object, long, int)}. */
	WAIT("wait:(Ljava/lang/Object;JI)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject target = MLEType.__notNullObject(__args[0]);
			long ms = (long)__args[1];
			int ns = (int)__args[2];
			
			return target.monitor().monitorWait(__thread.thread, ms, ns);
		}
	}, 
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEObject(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Copies the given array.
	 * 
	 * @param <A> The SpringCoat array type.
	 * @param __classy The class type.
	 * @param __src The source array.
	 * @param __srcOff The source offset.
	 * @param __dest The destination array.
	 * @param __destOff The destination offset.
	 * @param __len The length.
	 * @throws SpringMLECallError If the input is not valid.
	 * @since 2020/06/22
	 */
	@SuppressWarnings("SuspiciousSystemArraycopy")
	static <A extends SpringArrayObject> void __arrayCopy(
		Class<A> __classy, Object __src, int __srcOff,
		Object __dest, int __destOff, int __len)
		throws SpringMLECallError
	{
		// Wrong array type
		if (!__classy.isInstance(__src) ||
			!__classy.isInstance(__dest))
			throw new SpringMLECallError("Null array.");
		
		if (__srcOff < 0 || __destOff < 0 || __len < 0)
			throw new SpringMLECallError("Negative offset or length.");
		
		// Try to copy
		try
		{
			System.arraycopy(((SpringArrayObject)__src).array(), __srcOff,
				((SpringArrayObject)__dest).array(), __destOff, __len);
		}
		
		// Not a valid copy
		catch (ArrayStoreException|IndexOutOfBoundsException|
			NullPointerException e)
		{
			throw new SpringMLECallError("Invalid copy.", e);
		}
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.ReferenceShelf;
import cc.squirreljme.jvm.mle.brackets.RefLinkBracket;
import cc.squirreljme.vm.springcoat.brackets.RefLinkObject;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;

/**
 * Functions for {@link ReferenceShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEReference
	implements MLEFunction
{
	/** {@link ReferenceShelf#deleteLink(RefLinkBracket)}. */
	DELETE_LINK("deleteLink:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Check it, but otherwise do nothing
			MLEReference.__refLink(__args[0]);
			
			return null;
		}
	},
	
	/** {@link ReferenceShelf#linkGetNext(RefLinkBracket)}. */
	LINK_GET_NEXT("linkGetNext:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;)Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEReference.__refLink(__args[0]).getNext();
		}
	},
	
	/** {@link ReferenceShelf#linkGetObject(RefLinkBracket)}. */
	LINK_GET_OBJECT("linkGetObject:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;)Ljava/lang/Object;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEReference.__refLink(__args[0]).getObject();
		}
	},
	
	/** {@link ReferenceShelf#linkGetPrev(RefLinkBracket)}. */
	LINK_GET_PREV("linkGetPrev:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;)Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEReference.__refLink(__args[0]).getPrev();
		}
	},
	
	/** {@link ReferenceShelf#linkSetNext(RefLinkBracket, RefLinkBracket)}. */
	LINK_SET_NEXT("linkSetNext:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEReference.__refLink(__args[0]).setNext(
				MLEReference.__refLink(__args[1]));
			return null;
		}
	},
	
	/** {@link ReferenceShelf#linkSetObject(RefLinkBracket, Object)}. */
	LINK_SET_OBJECT("linkSetObject:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;Ljava/lang/Object;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEReference.__refLink(__args[0])
				.setObject((SpringObject)__args[1]);
			return null;
		}
	},
	
	/** {@link ReferenceShelf#linkSetPrev(RefLinkBracket, RefLinkBracket)}. */
	LINK_SET_PREV("linkSetPrev:(Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			MLEReference.__refLink(__args[0]).setPrev(
				MLEReference.__refLink(__args[1]));
			return null;
		}
	},
	
	/** {@link ReferenceShelf#newLink()}. */
	NEW_LINK("newLink:()Lcc/squirreljme/jvm/mle/brackets/" +
		"RefLinkBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new RefLinkObject();
		}
	},
	
	/** {@link ReferenceShelf#objectGet(Object)}. */
	OBJECT_GET("objectGet:(Ljava/lang/Object;)" +
		"Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject object = (SpringObject)__args[0];
			if (!(object instanceof SpringSimpleObject))
				throw new SpringMLECallError("Invalid object"); 
			
			return object.refLink().get();
		}
	},
	
	/** {@link ReferenceShelf#objectSet(Object, RefLinkBracket)}. */
	OBJECT_SET("objectSet:(Ljava/lang/Object;" +
		"Lcc/squirreljme/jvm/mle/brackets/RefLinkBracket;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject object = (SpringObject)__args[0];
			if (!(object instanceof SpringSimpleObject))
				throw new SpringMLECallError("Invalid object"); 
			
			object.refLink().set(MLEReference.__refLink(__args[1]));
			return null;
		}
	}
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEReference(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Checks if this is a {@link RefLinkObject}.
	 * 
	 * @param __object The object to check.
	 * @return As a {@link RefLinkObject} if this is one.
	 * @throws SpringMLECallError If this is not a {@link RefLinkObject}.
	 * @since 2020/06/28
	 */
	static RefLinkObject __refLink(Object __object)
		throws SpringMLECallError
	{
		if (!(__object instanceof RefLinkObject))
			throw new SpringMLECallError("Not a RefLinkObject.");
		
		return (RefLinkObject)__object; 
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.RuntimeShelf;
import cc.squirreljme.jvm.mle.constants.BuiltInEncodingType;
import cc.squirreljme.jvm.mle.constants.BuiltInLocaleType;
import cc.squirreljme.jvm.mle.constants.VMDescriptionType;
import cc.squirreljme.jvm.mle.constants.VMStatisticType;
import cc.squirreljme.jvm.mle.constants.VMType;
import cc.squirreljme.runtime.cldc.SquirrelJME;
import cc.squirreljme.runtime.cldc.debug.Debugging;
import cc.squirreljme.runtime.cldc.lang.LineEndingUtils;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;

/**
 * Functions for {@link MLERuntime}.
 *
 * @since 2020/06/18
 */
public enum MLERuntime
	implements MLEFunction
{
	/** {@link RuntimeShelf#currentTimeMillis()}. */
	CURRENT_TIME_MILLIS("currentTimeMillis:()J")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return System.currentTimeMillis();
		}
	},
	
	/** {@link RuntimeShelf#encoding()}. */
	ENCODING("encoding:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return BuiltInEncodingType.UTF8;
		}
	},
	
	/** {@link RuntimeShelf#exit(int)}. */
	EXIT("exit:(I)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			__thread.machine.exit((int)__args[0]);
			return null;
		}
	},
	
	/** {@link RuntimeShelf#lineEnding()}. */
	LINE_ENDING("lineEnding:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return LineEndingUtils.toType(
				System.getProperty("line.separator"));
		}
	},
	
	/** {@link RuntimeShelf#locale()}. */
	LOCALE("locale:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("SwitchStatementWithTooFewBranches")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			switch (System.getProperty("user.country"))
			{
				case "US":
					switch (System.getProperty("user.language"))
					{
						case "en":
							return BuiltInLocaleType.ENGLISH_US;
					}
					return BuiltInLocaleType.UNSPECIFIED;
				
				default:
					return BuiltInLocaleType.UNSPECIFIED;
			}
		}
	},
	
	/** {@link RuntimeShelf#nanoTime()}. */
	NANO_TIME("nanoTime:()J")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return System.nanoTime();
		}
	},
	
	/** {@link RuntimeShelf#systemProperty(String)}. */
	SYSTEM_PROPERTY("systemProperty:(Ljava/lang/String;)" +
		"Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			String key = __thread
				.<String>asNativeObject(String.class, __args[0]);
			
			if (key == null)
				throw new SpringMLECallError("Null key.");
			
			return __thread.machine._sysproperties.get(key);
		}
	},
	
	/** {@link RuntimeShelf#vmDescription(int)}. */
	VM_DESCRIPTION("vmDescription:(I)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int index = (int)__args[0];
			if (index < 0 || index >= VMDescriptionType.NUM_TYPES)
				throw new SpringMLECallError(
					"Index out of range: " + index);
			
			switch (index)
			{
				case VMDescriptionType.EXECUTABLE_PATH:
					return null;
				
				case VMDescriptionType.OS_ARCH:
					return "springcoat/" + System.getProperty("os.arch");
					
				case VMDescriptionType.OS_NAME:
					return System.getProperty("os.name");
				
				case VMDescriptionType.OS_VERSION:
					return System.getProperty("os.version");
				
				case VMDescriptionType.VM_EMAIL:
					return "xer@multiphasicapps.net";
					
				case VMDescriptionType.VM_NAME:
					return "SquirrelJME SpringCoat";
				
				case VMDescriptionType.VM_URL:
					return "https://squirreljme.cc/";
					
				case VMDescriptionType.VM_VENDOR:
					return "Stephanie Gawroriski";
				
				case VMDescriptionType.VM_VERSION:
					return SquirrelJME.RUNTIME_VERSION;
			}
			
			return null;
		}
	},
	
	/** {@link RuntimeShelf#vmStatistic(int)}. */
	VM_STATISTIC("vmStatistic:(I)J")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int index = (int)__args[0];
			if (index < 0 || index >= VMStatisticType.NUM_STATISTICS)
				throw new SpringMLECallError(
					"Index out of range: " + index);
			
			switch (index)
			{
				case VMStatisticType.MEM_FREE:
					return Runtime.getRuntime().freeMemory();
					
				case VMStatisticType.MEM_MAX:
					return Runtime.getRuntime().maxMemory();
				
				case VMStatisticType.MEM_USED:
					return Runtime.getRuntime().totalMemory();
			}
			
			return 0L;
		}
	},
	
	/** {@link RuntimeShelf#vmType()}. */
	VM_TYPE("vmType:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return VMType.SPRINGCOAT;
		}
	},
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLERuntime(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.TerminalShelf;
import cc.squirreljme.jvm.mle.constants.StandardPipeType;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
import java.io.IOException;
import java.io.OutputStream;

/**
 * Functions for {@link MLETerminal}.
 *
 * @since 2020/06/18
 */
public enum MLETerminal
	implements MLEFunction
{
	/** {@link TerminalShelf#flush(int)}. */
	FLUSH("flush:(I)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("resource")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			try
			{
				MLETerminal.__fdOutput((int)__args[0]).flush();
				return 1;
			}
			catch (IllegalArgumentException|IOException e)
			{
				return -1;
			}
		}
	},
	
	/** {@link TerminalShelf#write(int, int)}. */
	WRITE_BYTE("write:(II)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("resource")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			try
			{
				MLETerminal.__fdOutput((int)__args[0]).write((int)__args[1]);
				return 1;
			}
			catch (IllegalArgumentException|IOException e)
			{
				return -1;
			}
		}
	},
	
	/** {@link TerminalShelf#write(int, byte[], int, int)}. */
	WRITE_BYTES("write:(I[BII)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("resource")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			if (!(__args[1] instanceof SpringArrayObjectByte))
				throw new SpringMLECallError("Not a byte array.");
			
			SpringArrayObjectByte buf = (SpringArrayObjectByte)__args[1];
			int off = (int)__args[2];
			int len = (int)__args[3];
			
			// Perform basic bounds checking here
			if (off < 0 || len < 0 || (off + len) > buf.length)
				throw new SpringMLECallError("Index out of bounds.");
			
			try
			{
				MLETerminal.__fdOutput((int)__args[0])
					.write(buf.array(), off, len);
				return len;
			}
			catch (IllegalArgumentException|IOException e)
			{
				return -1;
			}
		}
	},
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLETerminal(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Returns the output stream for the given descriptor.
	 *
	 * @param __fd The file descriptor.
	 * @return The output stream for it.
	 * @throws SpringMLECallError If the descriptor is not valid.
	 * @since 2020/06/13
	 */
	static OutputStream __fdOutput(int __fd)
		throws SpringMLECallError
	{
		switch (__fd)
		{
			case StandardPipeType.STDOUT:	return System.out;
			case StandardPipeType.STDERR:	return System.err;
			
			default:
				throw new SpringMLECallError("Unknown FD: " + __fd);
		}
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.ThreadShelf;
import cc.squirreljme.jvm.mle.brackets.VMThreadBracket;
import cc.squirreljme.vm.springcoat.brackets.VMThreadObject;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
import net.multiphasicapps.classfile.ClassName;
import net.multiphasicapps.classfile.MethodNameAndType;

/**
 * Functions for {@link ThreadShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEThread
	implements MLEFunction
{
	/** {@link ThreadShelf#aliveThreadCount(boolean, boolean)}. */
	ALIVE_THREAD_COUNT("aliveThreadCount:(ZZ)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			boolean includeMain = ((int)__args[0] != 0);
			boolean includeDaemon = ((int)__args[1] != 0);
			
			// Count every thread
			int count = 0;
			SpringMachine machine = __thread.machine;
			synchronized (machine)
			{
				for (SpringThread thread : machine.getThreads())
				{
					boolean isMain = thread.isMain();
					boolean isDaemon = thread.isDaemon();
					
					if ((includeMain && isMain) ||
						(includeDaemon && isDaemon) ||
						(!isMain && !isDaemon))
						count++;
				}
			}
			
			return count;
		}
	},
	
	/** {@link ThreadShelf#createVMThread(Thread)}. */
	CREATE_VM_THREAD( "createVMThread:(Ljava/lang/Thread;)Lcc/" +
		"squirreljme/jvm/mle/brackets/VMThreadBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringSimpleObject javaThread = MLEThread.__javaThread(__thread,
				__args[0]);
			
			// Find the thread which the given passed object is bound to, this
			// is the target thread
			SpringThread target = null;
			SpringMachine machine = __thread.machine;
			synchronized (machine)
			{
				// Search through every thread
				SpringThread[] threads = machine.getThreads();
				for (SpringThread thread : threads)
				{
					SpringObject instance;
					try
					{
						instance = thread.threadInstance();
					}
					catch (IllegalStateException ignored)
					{
						continue;
					}
					
					// If this is the thread for this, then use that!
					if (javaThread == instance)
					{
						target = thread;
						break;
					}
				}
				
				// If there is exactly one thread, we can rather get into a bit
				// of a loop where our main thread is created outside of normal
				// means by the VM and not by any other thread.. but only if
				// this initial thread has no actual instance
				if (threads.length == 1 && !threads[0].hasThreadInstance())
					target = threads[0];
				
				// No actual thread exists that the object is bound to, so
				// oops! We need to actually create one here and bind it
				// accordingly!
				if (target == null)
					target = machine.createThread(null, false);
			}
			
			// Create object with this attached thread
			VMThreadObject vmThread = new VMThreadObject(target);
			
			// The thread gets these as well
			target.setThreadInstance(javaThread);
			target.setVMThread(vmThread);
			
			return vmThread;
		}
	},
	
	/** {@link ThreadShelf#currentExitCode()}. */
	CURRENT_EXIT_CODE("currentExitCode:()I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.machine._exitcode;
		}
	},
	
	/** {@link ThreadShelf#currentJavaThread()}. */
	CURRENT_JAVA_THREAD("currentJavaThread:()Ljava/lang/Thread;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.thread.threadInstance();
		}
	},
	
	/** {@link ThreadShelf#javaThreadClearInterrupt(Thread)}. */
	JAVA_THREAD_CLEAR_INTERRUPT("javaThreadClearInterrupt:" +
		"(Ljava/lang/Thread;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/28
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringFieldStorage field = MLEThread.__javaThread(__thread,
				__args[0]).fieldByNameAndType(false, 
				"_interrupted", "Z");
			
			// Get and clear the field value
			Object old = field.get();
			field.set(false);
			return old;
		}
	}, 
	
	/** {@link ThreadShelf#javaThreadFlagStarted(Thread)}. */
	JAVA_THREAD_FLAG_STARTED("javaThreadFlagStarted:(Ljava/lang/" +
		"Thread;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Just set the started field to true
			MLEThread.__javaThread(__thread, __args[0]).fieldByNameAndType(
				false, "_started", "Z").set(true);
			return null;
		}
	},
	
	/** {@link ThreadShelf#javaThreadIsStarted(Thread)}. */
	JAVA_THREAD_IS_STARTED("javaThreadIsStarted:(Ljava/lang/Thread;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Just get the state of the given field
			return MLEThread.__javaThread(__thread, __args[0])
				.fieldByNameAndType(false, 
					"_started", "Z").get();
		}
	},
	
	/** {@link ThreadShelf#javaThreadRunnable(Thread)}. */
	JAVA_THREAD_RUNNABLE("javaThreadRunnable:(Ljava/lang/Thread;)" +
		"Ljava/lang/Runnable;")
	{
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Just get the state of the given field
			return MLEThread.__javaThread(__thread, __args[0])
				.fieldByNameAndType(
				false, "_runnable",
				"Ljava/lang/Runnable;").get();
		}
	},
	
	/** {@link ThreadShelf#javaThreadSetAlive(Thread, boolean)}. */
	JAVA_THREAD_SET_ALIVE("javaThreadSetAlive:(Ljava/lang/Thread;Z)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			// Just set the started field to true
			MLEThread.__javaThread(__thread, __args[0]).fieldByNameAndType(
				false, "_isAlive", "Z")
				.set((int)__args[1] != 0);
			return null;
		}
	},
	
	/** {@link ThreadShelf#runProcessMain()}. */
	RUN_PROCESS_MAIN("runProcessMain:()V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			__thread.runProcessMain();
			return null;
		}
	},
	
	/** {@link ThreadShelf#setCurrentExitCode(int)}. */
	SET_CURRENT_EXIT_CODE("setCurrentExitCode:(I)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/27
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int exitCode = (int)__args[0];
			
			__thread.machine.setExitCode(exitCode);
			
			return null;
		}
	}, 
	
	/** {@link ThreadShelf#sleep(int, int)}. */
	SLEEP("sleep:(II)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int ms = (int)__args[0];
			int ns = (int)__args[1];
			
			if (ms < 0 || ns < 0 || ns > 1000000000)
				throw new SpringMLECallError("Out of range time.");
			
			if (ms == 0 && ns == 0)
				Thread.yield();
			else
				try
				{
					Thread.sleep(ms, ns);
				}
				catch (InterruptedException ignored)
				{
					return true;
				}
			
			return false;
		}
	},
	
	/** {@link ThreadShelf#toJavaThread(VMThreadBracket)}. */
	TO_JAVA_THREAD("toJavaThread:(Lcc/squirreljme/jvm/mle/" +
		"brackets/VMThreadBracket;)Ljava/lang/Thread;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			VMThreadObject vmThread = MLEThread.__vmThread(__args[0]);
			
			return vmThread.getThread().threadInstance();
		}
	}, 
	
	/** {@link ThreadShelf#toVMThread(Thread)}. */
	TO_VM_THREAD("toVMThread:(Ljava/lang/Thread;)Lcc/squirreljme/" +
		"jvm/mle/brackets/VMThreadBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEThread.__javaThread(__thread, __args[0]).fieldByField(
				__thread.resolveClass("java/lang/Thread")
				.lookupField(false, "_vmThread",
				"Lcc/squirreljme/jvm/mle/brackets/VMThreadBracket;"))
				.get();
		}
	},
	
	/** {@link ThreadShelf#vmThreadId(VMThreadBracket)}. */
	VM_THREAD_ID("vmThreadId:(Lcc/squirreljme/jvm/mle/brackets/" +
		"VMThreadBracket;)I")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEThread.__vmThread(__args[0]).getThread().id;
		}
	},
	
	/** {@link ThreadShelf#vmThreadInterrupt(VMThreadBracket)}. */ 
	VM_THREAD_INTERRUPT("vmThreadInterrupt:(Lcc/squirreljme/jvm/mle/" +
		"brackets/VMThreadBracket;)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/22
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			VMThreadObject vmThread = MLEThread.__vmThread(__args[0]);
			
			// Send an interrupt to the thread
			vmThread.getThread().hardInterrupt();
			
			return null;
		}
	},
	
	/** {@link ThreadShelf#vmThreadIsMain(VMThreadBracket)}. */
	VM_THREAD_IS_MAIN("vmThreadIsMain:(Lcc/squirreljme/jvm/mle/" +
		"brackets/VMThreadBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEThread.__vmThread(__args[0]).getThread().isMain();
		}
	},
	
	/** {@link ThreadShelf#vmThreadSetPriority(VMThreadBracket, int)}. */
	VM_THREAD_SET_PRIORITY("vmThreadSetPriority:(Lcc/squirreljme/" +
		"jvm/mle/brackets/VMThreadBracket;I)V")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringThread thread = MLEThread.__vmThread(__args[0]).getThread();
			int priority = (int)__args[1];
			
			if (priority < Thread.MIN_PRIORITY ||
				priority > Thread.MAX_PRIORITY)
				throw new SpringMLECallError(
					"Thread priority out of range.");
			
			// Try to set the priority
			try
			{
				thread._worker.setPriority(priority);
			}
			catch (IllegalArgumentException|SecurityException e)
			{
				throw new SpringMLECallError(
					"Could not set priority.", e);
			}
			
			return null;
		}
	}, 
	
	/** {@link ThreadShelf#vmThreadStart(VMThreadBracket)}. */
	VM_THREAD_START("vmThreadStart:(Lcc/squirreljme/jvm/mle/brackets/" +
		"VMThreadBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringThread target = MLEThread.__vmThread(__args[0]).getThread();
			
			// Create worker for thread and start it
			SpringThreadWorker worker = new SpringThreadWorker(
				__thread.machine, target, false);
			
			// Enter the base setup frame
			target.enterFrame(worker.loadClass(MLEThread._START_CLASS)
				.lookupMethod(true, MLEThread._BASE_THREAD_METHOD));
			
			// Try to start it
			try
			{
				worker.start();
				return true;
			}
			catch (IllegalThreadStateException ignored)
			{
				return false;
			}
		}
	},
	
	/** {@link ThreadShelf#waitForUpdate(int)}. */
	WAIT_FOR_UPDATE("waitForUpdate:(I)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			int ms = (int)__args[0];
			
			if (ms < 0)
				throw new SpringMLECallError("Negative milliseconds");
			
			// Waiting for nothing? just give up our slice
			if (ms == 0)
			{
				Thread.yield();
				return false;
			}
			
			// Wait until the monitor is hit
			SpringMachine machine = __thread.machine;
			synchronized (machine)
			{
				try
				{
					machine.wait(ms);
				}
				catch (InterruptedException e)
				{
					return true;
				}
			}
			
			// Assume not interrupted
			return false;
		}
	}, 
	
	/* End. */
	;
	
	/** The class which contains the thread starting point. */
	static final ClassName _START_CLASS =
		new ClassName("java/lang/__Start__");
	
	/** The method to enter for main threads. */
	static final MethodNameAndType _BASE_THREAD_METHOD =
		new MethodNameAndType("__base", "()V");
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEThread(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Checks if this is a Java thread.
	 * 
	 * @param __thread The context thread.
	 * @param __object The object to check.
	 * @return The verified object.
	 * @throws SpringMLECallError If {@code __object} is {@code null} or is
	 * not an instance of {@link Throwable}.
	 * @since 2020/06/28
	 */
	static SpringSimpleObject __javaThread(SpringThreadWorker __thread,
		Object __object)
		throws SpringMLECallError
	{
		if (__thread == null)
			throw new NullPointerException("NARG");
		
		if (!(__object instanceof SpringSimpleObject))
			throw new SpringMLECallError("Not a Java Thread");
		
		SpringSimpleObject rv = (SpringSimpleObject)__object;
		if (!rv.type().isAssignableFrom(
			__thread.resolveClass("java/lang/Thread")))
			throw new SpringMLECallError("Not instance of Thread.");
		
		return rv;
	}
	
	/**
	 * Ensures that this is a {@link VMThreadObject}.
	 * 
	 * @param __object The object to check.
	 * @return As a {@link VMThreadObject}.
	 * @throws SpringMLECallError If this is not one.
	 * @since 2020/06/27
	 */
	static VMThreadObject __vmThread(Object __object)
		throws SpringMLECallError
	{
		if (!(__object instanceof VMThreadObject))
			throw new SpringMLECallError("Not a VMThreadObject.");
		
		return (VMThreadObject)__object; 
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.jvm.mle.TypeShelf;
import cc.squirreljme.jvm.mle.brackets.TypeBracket;
import cc.squirreljme.runtime.cldc.debug.Debugging;
import cc.squirreljme.vm.springcoat.brackets.JarPackageObject;
import cc.squirreljme.vm.springcoat.brackets.TypeObject;
import cc.squirreljme.vm.springcoat.exceptions.SpringClassNotFoundException;
import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
import java.util.Objects;
import net.multiphasicapps.classfile.ClassName;
import net.multiphasicapps.classfile.MethodNameAndType;
import net.multiphasicapps.classfile.PrimitiveType;

/**
 * Functions for {@link TypeShelf}.
 *
 * @since 2020/06/18
 */
public enum MLEType
	implements MLEFunction
{
	/** {@link TypeShelf#binaryName(TypeBracket)}. */
	BINARY_NAME("binaryName:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/27
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEType.__type(__args[0])
				.getSpringClass().name().binaryName().toString());
		}
	}, 
	
	/** {@link TypeShelf#binaryPackageName(TypeBracket)}. */
	BINARY_PACKAGE_NAME("binaryPackageName:(Lcc/squirreljme/jvm/" +
		"mle/brackets/TypeBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEType.__type(__args[0])
				.getSpringClass().name().binaryName().inPackage()
				.toString());
		}
	},
	
	/** {@link TypeShelf#classToType(Class)}. */
	CLASS_TO_TYPE("classToType:(Ljava/lang/Class;)" +
		"Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__simple(__args[0]).fieldByField(
				__thread.resolveClass(new ClassName("java/lang/Class"))
				.lookupField(false, "_type",
				"Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")).get();
		}
	},
	
	/** {@link TypeShelf#component(TypeBracket)}. */
	COMPONENT("component:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/28
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			
			if (!type.isArray())
				throw new SpringMLECallError("Not an array type.");
			
			return new TypeObject(type.componentType());
		}
	},
	
	/** {@link TypeShelf#componentRoot(TypeBracket)}. */
	COMPONENT_ROOT("componentRoot:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TypeBracket;)Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/28
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			
			if (!type.isArray())
				throw new SpringMLECallError("Not an array type.");
			
			// Find the root component
			while (type.isArray())
				type = type.componentType();
			return new TypeObject(type);
		}
	},
	
	/** {@link TypeShelf#enumValues(TypeBracket)}. */
	ENUM_VALUES("enumValues:(Lcc/squirreljme/jvm/mle/" +
		"brackets/TypeBracket;)[Ljava/lang/Enum;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/28
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			
			// Must be an enumeration
			if (!type.isEnum())
				throw new SpringMLECallError("Not an enumeration type");
			
			// Call the static values() method in the given class, it is
			// automatically generated by the Java compiler (it is synthetic)
			return __thread.invokeMethod(true, type.name(),
				new MethodNameAndType("values", 
					"()" + type.name().field().addDimensions(1)));
		}
	}, 
	
	/** {@link TypeShelf#equals(TypeBracket, TypeBracket)}. */
	EQUALS("equals:(Lcc/squirreljme/jvm/mle/brackets/TypeBracket;" +
		"Lcc/squirreljme/jvm/mle/brackets/TypeBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return Objects.equals(
				MLEType.__type(__args[0]).getSpringClass(),
				MLEType.__type(__args[1]).getSpringClass());
		}
	},
	
	/** {@link TypeShelf#findType(String)}. */
	FIND_TYPE("findType:(Ljava/lang/String;)" +
		"Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringObject name = MLEType.__notNullObject(__args[0]);
			
			try
			{
				return new TypeObject(__thread.loadClass(
					__thread.<String>asNativeObject(String.class, name)));
			}
			
			// Since the method returns null when not found, we want to return
			// this here
			catch (SpringClassNotFoundException e)
			{
				return null;
			}
		}
	},
	
	/** {@link TypeShelf#inJar(TypeBracket)}. */
	IN_JAR("inJar:(Lcc/squirreljme/jvm/mle/brackets/TypeBracket;)" +
		"Lcc/squirreljme/jvm/mle/brackets/JarPackageBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new JarPackageObject(MLEType.__type(__args[0])
				.getSpringClass().inJar());
		}
	},
	
	/** {@link TypeShelf#interfaces(TypeBracket)}. */
	INTERFACES("interfaces:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)[Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/29
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass type = MLEType.__type(__args[0]).getSpringClass();
			
			SpringClass[] interfaces = type.interfaceClasses();
			int n = interfaces.length;
			
			SpringObject[] rv = new SpringObject[n];
			for (int i = 0; i < n; i++)
				rv[i] = new TypeObject(interfaces[i]);
			
			return __thread.asVMObjectArray(__thread.resolveClass(
				"[Lcc/squirreljme/jvm/mle/brackets/TypeBracket;"), rv);
		}
	}, 
	
	/** {@link TypeShelf#isArray(TypeBracket)}. */
	IS_ARRAY("isArray:(Lcc/squirreljme/jvm/mle/brackets/TypeBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__type(__args[0]).getSpringClass().isArray();
		}
	},
	
	/** {@link TypeShelf#isEnum(TypeBracket)}. */
	IS_ENUM("isEnum:(Lcc/squirreljme/jvm/mle/brackets/TypeBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/28
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__type(__args[0]).getSpringClass().isEnum();
		}
	},
	
	/** {@link TypeShelf#isInterface(TypeBracket)}. */
	IS_INTERFACE("isInterface:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__type(__args[0]).getSpringClass().flags()
				.isInterface();
		}
	},
	
	/** {@link TypeShelf#isPrimitive(TypeBracket)}. */
	IS_PRIMITIVE("isPrimitive:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Z")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__type(__args[0]).getSpringClass().name()
				.isPrimitive();
		}
	},
	
	/** {@link TypeShelf#objectType(Object)}. */
	OBJECT_TYPE("objectType:(Ljava/lang/Object;)" +
		"Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				MLEType.__notNullObject(__args[0]).type().name().toString()));
		}
	},
	
	/** {@link TypeShelf#runtimeName(TypeBracket)}. */
	RUNTIME_NAME("runtimeName:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Ljava/lang/String;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return MLEType.__type(__args[0]).getSpringClass()
				.name().toRuntimeString();
		}
	},
	
	/** {@link TypeShelf#superClass(TypeBracket)}. */
	SUPER_CLASS("superClass:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Lcc/squirreljme/jvm/mle/brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			SpringClass superClass = MLEType.__type(__args[0]).getSpringClass()
				.superClass();
			
			if (superClass == null)
				return SpringNullObject.NULL;
			return new TypeObject(superClass);
		}
	},
	
	/** {@link TypeShelf#typeOfBoolean()}. */
	TYPE_OF_BOOLEAN("typeOfBoolean:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.BOOLEAN)));
		}
	},
	
	/** {@link TypeShelf#typeOfByte()}. */
	TYPE_OF_BYTE("typeOfByte:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.BYTE)));
		}
	},
	
	/** {@link TypeShelf#typeOfCharacter()}. */
	TYPE_OF_CHARACTER("typeOfCharacter:()Lcc/squirreljme/jvm/mle/" +
		"brackets/TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.CHARACTER)));
		}
	},
	
	/** {@link TypeShelf#typeOfDouble()}. */
	TYPE_OF_DOUBLE("typeOfDouble:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.DOUBLE)));
		}
	},
	
	/** {@link TypeShelf#typeOfFloat()}. */
	TYPE_OF_FLOAT("typeOfFloat:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.FLOAT)));
		}
	},
	
	/** {@link TypeShelf#typeOfInteger()}. */
	TYPE_OF_INTEGER("typeOfInteger:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.INTEGER)));
		}
	},
	
	/** {@link TypeShelf#typeOfLong()}. */
	TYPE_OF_LONG("typeOfLong:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.LONG)));
		}
	},
	
	/** {@link TypeShelf#typeOfShort()}. */
	TYPE_OF_SHORT("typeOfShort:()Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return new TypeObject(__thread.loadClass(
				ClassName.fromPrimitiveType(PrimitiveType.SHORT)));
		}
	},
	
	/** {@link TypeShelf#typeToClass(TypeBracket)}. */
	TYPE_TO_CLASS("typeToClass:(Lcc/squirreljme/jvm/mle/brackets/" +
		"TypeBracket;)Ljava/lang/Class;")
	{
		/**
		 * {@inheritDoc}
		 * @since 2020/06/18
		 */
		@Override
		public Object handle(SpringThreadWorker __thread, Object... __args)
		{
			return __thread.asVMObject(MLEType.__type(__args[0])
				.getSpringClass());
		}
	},
	
	/* End. */
	;
	
	/** The dispatch key. */
	protected final String key;
	
	/**
	 * Initializes the dispatcher info.
	 *
	 * @param __key The key.
	 * @throws NullPointerException On null arguments.
	 * @since 2020/06/18
	 */
	MLEType(String __key)
		throws NullPointerException
	{
		if (__key == null)
			throw new NullPointerException("NARG");
		
		this.key = __key;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/06/18
	 */
	@Override
	public String key()
	{
		return this.key;
	}
	
	/**
	 * Checks if the object is {@code null}.
	 * 
	 * @param __object The object to check.
	 * @return The object.
	 * @throws SpringMLECallError If is null.
	 * @since 2020/06/22
	 */
	static SpringObject __notNullObject(Object __object)
		throws SpringMLECallError
	{
		if (__object == null || SpringNullObject.NULL == __object)
			throw new SpringMLECallError("Null object.");
		
		return (SpringObject)__object;
	}
	
	/**
	 * Checks if this is a simple object.
	 * 
	 * @param __object The object to check.
	 * @return The simple object.
	 * @throws SpringMLECallError If not a simple object.
	 * @since 2020/06/22
	 */
	static SpringSimpleObject __simple(Object __object)
	{
		if (!(__object instanceof SpringSimpleObject))
			throw new SpringMLECallError("Not a SpringSimpleObject.");
		
		return (SpringSimpleObject)__object; 
	}
	
	/**
	 * Checks if this is a {@link TypeObject}.
	 * 
	 * @param __object The object to check.
	 * @return As a {@link TypeObject} if this is one.
	 * @throws SpringMLECallError If this is not a {@link TypeObject}.
	 * @since 2020/06/22
	 */
	static TypeObject __type(Object __object)
		throws SpringMLECallError
	{
		if (!(__object instanceof TypeObject))
			throw new SpringMLECallError("Not a TypeObject.");
		
		return (TypeObject)__object; 
	}
}

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.brackets.RefLinkHolder;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;

/**
 * This is an object which acts as an array, which stores some kind of data.
 *
 * @since 2018/09/15
 */
public abstract class SpringArrayObject
	implements SpringObject
{
	/** The monitor for this array. */
	protected final SpringMonitor monitor =
		new SpringMonitor();
	
	/** The reference link holder. */
	protected final RefLinkHolder refLink =
		new RefLinkHolder();
	
	/** The type of this object itself. */
	protected final SpringClass selftype;
	
	/** The component type. */
	protected final SpringClass component;
	
	/** The length of the array. */
	protected final int length;
	
	/** String representation. */
	private Reference<String> _string;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws IllegalArgumentException If the type is not an array.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/09/15
	 */
	public SpringArrayObject(SpringClass __self, int __l)
		throws IllegalArgumentException, NullPointerException,
			SpringNegativeArraySizeException
	{
		if (__self == null)
			throw new NullPointerException("NARG");
		
		// The passed type must always be an array
		if (!__self.isArray())
			throw new IllegalArgumentException("Type not an array: " + __self);
		
		// {@squirreljme.error BK01 Attempt to allocate an array of a
		// negative size. (The length requested)}
		if (__l < 0)
			throw new SpringNegativeArraySizeException(
				String.format("BK01 %d", __l));
		
		this.selftype = __self;
		this.component = __self.componentType();
		this.length = __l;
	}
	
	/**
	 * Returns the raw backing array.
	 *
	 * @return The array.

	 * @throws SpringArrayIndexOutOfBoundsException If the index is not within
	 * bounds.
	 * @since 2018/09/16
	 */
	public abstract void set(int __dx, Object __v)
		throws SpringArrayStoreException, SpringArrayIndexOutOfBoundsException;
	










	/**
	 * Returns the length of this array.
	 *
	 * @return The array length.
	 * @since 2018/09/16
	 */
	public final int length()
	{
		return this.length;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/09/15
	 */
	@Override
	public final SpringMonitor monitor()
	{
		return this.monitor;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2020/05/31
	 */
	@Override
	public final RefLinkHolder refLink()
	{
		return this.refLink;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/09/15
	 */
	@Override

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;

/**
 * Array backed by a boolean array.
 *
 * @since 2018/11/14
 */
public final class SpringArrayObjectBoolean
	extends SpringArrayObject
{
	/** Elements in the array. */
	private final boolean[] _elements;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/11/14
	 */
	public SpringArrayObjectBoolean(SpringClass __self, int __l)

		throws NullPointerException
	{
		super(__self, __l);
		
		// Initialize elements
		this._elements = new boolean[__l];
	}
	
	/**
	 * Wraps the native array.
	 *
	 * @param __self The self type.
	 * @param __cl The component type.
	 * @param __a The array to wrap.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/18
	 */
	public SpringArrayObjectBoolean(SpringClass __self, boolean[] __a)

		throws NullPointerException
	{
		super(__self, __a.length);
		
		this._elements = __a;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/19
	 */
	@Override
	public final boolean[] array()
	{
		return this._elements;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/14

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;

/**
 * Array backed by a byte array.
 *
 * @since 2018/11/04
 */
public final class SpringArrayObjectByte
	extends SpringArrayObject
{
	/** Elements in the array. */
	private final byte[] _elements;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/11/04
	 */
	public SpringArrayObjectByte(SpringClass __self, int __l)

		throws NullPointerException
	{
		super(__self, __l);
		
		// Initialize elements
		this._elements = new byte[__l];
	}
	
	/**
	 * Wraps the native array.
	 *
	 * @param __self The self type.

	 * @param __a The array to wrap.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/18
	 */
	public SpringArrayObjectByte(SpringClass __self, byte[] __a)

		throws NullPointerException
	{
		super(__self, __a.length);
		
		this._elements = __a;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/19
	 */
	@Override
	public final byte[] array()
	{
		return this._elements;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/14

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;

/**
 * Array backed by a char array.
 *
 * @since 2018/11/04
 */
public final class SpringArrayObjectChar
	extends SpringArrayObject
{
	/** Elements in the array. */
	private final char[] _elements;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/11/04
	 */
	public SpringArrayObjectChar(SpringClass __self, int __l)

		throws NullPointerException
	{
		super(__self, __l);
		
		// Initialize elements
		this._elements = new char[__l];
	}
	
	/**
	 * Wraps the native array.
	 *
	 * @param __self The self type.

	 * @param __a The array to wrap.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/18
	 */
	public SpringArrayObjectChar(SpringClass __self, char[] __a)

		throws NullPointerException
	{
		super(__self, __a.length);
		
		this._elements = __a;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/19
	 */
	@Override
	public final char[] array()
	{
		return this._elements;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/14

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;

/**
 * Array backed by a double array.
 *
 * @since 2018/11/14
 */
public final class SpringArrayObjectDouble
	extends SpringArrayObject
{
	/** Elements in the array. */
	private final double[] _elements;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/11/14
	 */
	public SpringArrayObjectDouble(SpringClass __self, int __l)

		throws NullPointerException
	{
		super(__self, __l);
		
		// Initialize elements
		this._elements = new double[__l];
	}
	
	/**
	 * Wraps the native array.
	 *
	 * @param __self The self type.

	 * @param __a The array to wrap.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/18
	 */
	public SpringArrayObjectDouble(SpringClass __self, double[] __a)

		throws NullPointerException
	{
		super(__self, __a.length);
		
		this._elements = __a;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/19
	 */
	@Override
	public final double[] array()
	{
		return this._elements;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/14

// -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
// ---------------------------------------------------------------------------
// Multi-Phasic Applications: SquirrelJME
//     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
//     Copyright (C) Multi-Phasic Applications <multiphasicapps.net>
// ---------------------------------------------------------------------------
// SquirrelJME is under the GNU General Public License v3+, or later.
// See license.mkd for licensing and copyright information.
// ---------------------------------------------------------------------------

package cc.squirreljme.vm.springcoat;

import cc.squirreljme.vm.springcoat.exceptions.SpringArrayIndexOutOfBoundsException;
import cc.squirreljme.vm.springcoat.exceptions.SpringArrayStoreException;
import cc.squirreljme.vm.springcoat.exceptions.SpringNegativeArraySizeException;

/**
 * Array backed by a float array.
 *
 * @since 2018/11/14
 */
public final class SpringArrayObjectFloat
	extends SpringArrayObject
{
	/** Elements in the array. */
	private final float[] _elements;
	
	/**
	 * Initializes the array.
	 *
	 * @param __self The self type.

	 * @param __l The array length.
	 * @throws NullPointerException On null arguments.
	 * @throws SpringNegativeArraySizeException If the array size is negative.
	 * @since 2018/11/14
	 */
	public SpringArrayObjectFloat(SpringClass __self, int __l)

		throws NullPointerException
	{
		super(__self, __l);
		
		// Initialize elements
		this._elements = new float[__l];
	}
	
	/**
	 * Wraps the native array.
	 *
	 * @param __self The self type.

	 * @param __a The array to wrap.
	 * @throws NullPointerException On null arguments.
	 * @since 2018/11/18
	 */
	public SpringArrayObjectFloat(SpringClass __self, float[] __a)

		throws NullPointerException
	{
		super(__self, __a.length);
		
		this._elements = __a;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/19
	 */
	@Override
	public final float[] array()
	{
		return this._elements;
	}
	
	/**
	 * {@inheritDoc}
	 * @since 2018/11/14