+ * The names live in their own package, so they can never collide with the sequentially named
+ * classes an ordinary compilation produces.
+ *
+ * @see AotIndex
+ */
+public final class AotGenerator
+{
+ /** Package holding every generated class. */
+ static final String PACKAGE = AotIndex.PACKAGE;
+
+ /** Flag indicating the compiler should name and emit classes for the index. */
+ private static volatile boolean generating = false;
+
+ /** Emitted classes, keyed by fully qualified name, so a shared class is written once. */
+ private static final Map
+ * That name is the one part which differs between two otherwise identical classes, and it is a
+ * constant pool UTF8 entry preceded by its own two byte length, so both are dropped.
+ *
+ * @param raw
+ * Class file bytes.
+ * @param internalName
+ * The class's own name in internal form.
+ *
+ * @return Hex encoded digest of the name independent content.
+ */
+ private static String fingerprint(byte[] raw, String internalName)
+ {
+ try
+ {
+ byte[] needle = internalName.getBytes(StandardCharsets.UTF_8);
+ MessageDigest digest = MessageDigest.getInstance("SHA-256");
+ int pos = 0;
+
+ for (int i = 0; i <= raw.length - needle.length; )
+ {
+ if (matches(raw, i, needle))
+ {
+ digest.update(raw, pos, Math.max(pos, i - 2) - pos);
+
+ i += needle.length;
+ pos = i;
+ }
+ else
+ {
+ i++;
+ }
+ }
+
+ digest.update(raw, pos, raw.length - pos);
+
+ StringBuilder buf = new StringBuilder(64);
+
+ for (byte b : digest.digest())
+ {
+ buf.append(Character.forDigit((b >> 4) & 0xf, 16));
+ buf.append(Character.forDigit(b & 0xf, 16));
+ }
+
+ return buf.toString();
+ }
+ catch (NoSuchAlgorithmException exc)
+ {
+ throw new IllegalStateException(exc);
+ }
+ }
+
+ /**
+ * Test whether
+ * It is located once, by asking the classpath for its stamp, and thereafter read directly. The
+ * conversion classpath is several hundred jars, so searching it per class is what this avoids.
+ */
+ private static final Object SOURCE = openSource();
+
+ /** Loader which resolves the generated classes straight out of {@link #SOURCE}. */
+ private static final AotClassLoader LOADER = new AotClassLoader(AotIndex.class.getClassLoader());
+
+ /**
+ * Not instantiable.
+ */
+ private AotIndex()
+ {
+ }
+
+ /**
+ * Compose the resource name holding a profile's index. Profile names contain path separators,
+ * which are folded so that every index is one flat resource.
+ *
+ * @param profile
+ * Profile name.
+ *
+ * @return Resource file name.
+ */
+ public static String indexFileName(String profile)
+ {
+ return profile.replace('/', '.') + ".txt";
+ }
+
+ static
+ {
+ Runtime.getRuntime().addShutdownHook(new Thread(AotIndex::report));
+ }
+
+ /**
+ * Describe what the generated classes were built for.
+ *
+ * @return A short description, for reporting.
+ */
+ private static String describeGeneratedFor()
+ {
+ String meta = text(bytesOf(META_RESOURCE));
+
+ return (meta == null) ? "an unrecorded debug level" : meta.replace('=', ' ');
+ }
+
+ /**
+ * Report whether any entry is currently resident.
+ *
+ * @return
+ * The two carry a shared stamp over the rule sets and the expression compiler. Disagreement
+ * means the generated classes describe rules or code generation which no longer exist, so they
+ * are ignored outright and every expression is compiled as it always was. That is the whole
+ * staleness story: the artifact is optional and regenerable, and being wrong is never a
+ * possible outcome of it being old.
+ *
+ * @return An open {@link java.util.jar.JarFile}, a {@link File} directory, or
+ *
+ * The result is equivalent, as far as {@link #instantiate} is concerned, to the compiler which
+ * originally produced the class: it carries the same symbol to slot maps and the same return
+ * type, which is all that binding a blueprint to a caller's scope requires.
+ *
+ * @param expression
+ * Expression the class belongs to.
+ * @param entry
+ * Index entry describing the class.
+ *
+ * @return The compiler, or
+ * Must be called after {@link #parse} and {@link #preprocess}: the point at which every symbol
+ * has been resolved against the scope in force, but nothing has been assembled.
+ *
+ * Deliberately over-inclusive -- each node's type together with a canonical rendering of
+ * whatever payload the parser attached, falling back to the payload's class and
+ *
+ * {@link CacheKey} therefore includes the scope alongside the infix text and the runtime flags.
+ * Without it, two rulesets declaring an identically named variable with different types collide
+ * on one key, and the expression fails at runtime with a
* Several runtime flag constants can be set to alter the behavior of an
* expression. If multiple flags are to be set, they are bitwise OR'd
@@ -214,11 +234,28 @@
/** Line separator */
private static final String LINE_SEP = System.getProperty("line.separator");
- /** Shared cache that maps an expression to its compiler */
+ /**
+ * Shared cache that maps an expression, in a given scope, to its compiler. The key includes
+ * the scope; see Caching model in the class javadoc.
+ */
private static final Map
+ * Loading is single threaded and reads a fixed set of files in document order -- the profiles
+ * name every include and rule set explicitly, with no wildcards -- so the expressions of a
+ * profile are created in a stable sequence. That makes (profile, position in the
+ * sequence) a durable name for an occurrence, which is what lets the class generated for it
+ * when FWD was built be found again.
+ */
+ private static String aotProfile = null;
+
+ /** Source of positions within the profile currently being loaded. */
+ private static int aotOrdinal = 0;
/** Symbol resolver used to compile this expression */
private final WeakReference
+ *
+ * The scope is part of the key because a generated expression class is specific to the scope
+ * which compiled it: symbol resolution types every user variable accessor from
+ *
+ * Keyed by scope first, then by the expression's cache key, because a generated expression
+ * class is specific to the scope which compiled it. See Caching model in the
+ * {@link Expression} class javadoc.
+ *
+ * The scope keys are held weakly, so an entry is discarded once the ruleset which owns that
+ * scope is out of service. Note that this tracks the identity of the specific
+ *
+ * Scope matters and is the reason for the walk. A generated class bakes in the types of the
+ * variables it reads, resolved from the scope which compiled it, so each expression has to be
+ * compiled under its own container or function -- exactly as the walk arranges.
+ *
+ *
+ * Invoked by the build. The first argument is the output directory; the rest are profile
+ * names, as a conversion would name them.
+ *
+ * @param args
+ * Output directory, followed by one or more profile names.
+ *
+ * @throws Exception
+ * if the output cannot be written.
+ */
+ public static void main(String[] args)
+ throws Exception
+ {
+ if (args.length < 2)
+ {
+ System.err.println("usage: AotWarmer
diff -Nru old/src/com/goldencode/p2j/pattern/Rule.java new/src/com/goldencode/p2j/pattern/Rule.java
--- old/src/com/goldencode/p2j/pattern/Rule.java 2026-09-25 09:27:23.836989746 +0300
+++ new/src/com/goldencode/p2j/pattern/Rule.java 2026-09-25 09:27:23.848805321 +0300
@@ -584,6 +584,54 @@
}
/**
+ * Force this rule's condition and every expression beneath it to be compiled, without executing
+ * anything. Used when generating the expression classes of the shipped rule sets.
+ *
+ * @param resolver
+ * AST symbol resolver, with this rule's container scope already in force.
+ */
+ void warm(AstSymbolResolver resolver)
+ {
+ if (condition != null)
+ {
+ try
+ {
+ condition.warm();
+ }
+ catch (Throwable thr)
+ {
+ // an expression which cannot be compiled in isolation is simply left out of the
+ // generated set; a conversion which reaches it compiles it as it always did
+ AotWarmer.failed(condition, thr);
+ }
+ }
+
+ warmAll(trueActions, resolver);
+ warmAll(falseActions, resolver);
+ }
+
+ /**
+ * Force a list of rule elements to be compiled.
+ *
+ * @param elements
+ * Elements to warm, possibly
true while a generation run is in progress.
+ */
+ static boolean isGenerating()
+ {
+ return generating;
+ }
+
+ /**
+ * Turn generation mode on or off.
+ *
+ * @param on
+ * true to start generating.
+ */
+ public static void setGenerating(boolean on)
+ {
+ generating = on;
+ }
+
+ /**
+ * Compose the class name for a compilation, in the internal, slash separated form which
+ * {@link ClassFile} requires and which is embedded in the generated constant pool.
+ *
+ * @param signature
+ * The compilation's signature, from {@link Compiler#signature}.
+ *
+ * @return Internal form of the class name.
+ */
+ static String internalName(String signature)
+ {
+ return (PACKAGE + "A" + AotIndex.digest(signature)).replace('.', '/');
+ }
+
+ /**
+ * Accept a class the compiler has just assembled, together with the state a conversion needs in
+ * order to bind it to a caller's scope without parsing the expression again.
+ *
+ * @param expression
+ * Expression the class was generated for.
+ * @param classFile
+ * The assembled class.
+ * @param returnType
+ * Return type the blueprint must be configured with.
+ * @param libraries
+ * Library symbol to slot map.
+ * @param variables
+ * Variable symbol to slot map.
+ */
+ static synchronized void emit(Expression expression, ClassFile classFile, Class returnType,
+ Mapneedle occurs in raw at at.
+ *
+ * @param raw
+ * Buffer to search.
+ * @param at
+ * Offset at which to compare.
+ * @param needle
+ * Bytes to look for.
+ *
+ * @return true on a match.
+ */
+ private static boolean matches(byte[] raw, int at, byte[] needle)
+ {
+ for (int i = 0; i < needle.length; i++)
+ {
+ if (raw[at + i] != needle[i])
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Render a symbol to slot map as a list ordered by slot.
+ *
+ * @param slots
+ * Map of symbol name to slot index.
+ *
+ * @return Symbol names in slot order.
+ */
+ private static ListWhat this replaces
+ *
+ * Left to itself a conversion generates, defines and JIT compiles a class for every expression of
+ * every rule set it loads, on every run. Those rule sets are fixed content shipped with FWD, so
+ * the work is the same every time and can be done once, at build time. A run which finds an
+ * occurrence here loads an ordinary class from the classpath instead.
+ *
+ * How an occurrence is named
+ *
+ * Every expression belonging to a rule set is created during a profile load, which reads a fixed
+ * set of files in document order on a single thread, so each occurrence has a stable position in
+ * that sequence. {@link Expression#assignAotId} turns that into a durable name, and this index is
+ * keyed on it. Because the index and the rule sets are produced by one build and shipped in one
+ * artifact, they cannot disagree about that sequence.
+ *
+ * What an entry holds beyond the class
+ *
+ * The class alone is not enough: {@link Compiler#instantiate} binds a compiled expression to the
+ * libraries and variables of the calling scope through the symbol-to-slot maps that parsing
+ * produced, and the blueprint needs its return type. Recording those is what removes parsing from
+ * the fast path.
+ *
+ * Failing safe
+ *
+ * Every entry carries a digest of the expression text it was generated from, checked before the
+ * class is used. In a released build that check can never fail; it exists for the developer case
+ * where rules have been edited without regenerating, and it turns what would be a wrong class into
+ * an ordinary compilation. A missing index, an unreadable entry, an absent class -- all degrade to
+ * compiling, never to misbehaving.
+ */
+final class AotIndex
+{
+ /** Package holding every generated class. */
+ static final String PACKAGE = "com.goldencode.expr.aot.";
+
+ /** Resource directory holding the per profile indexes, relative to the classpath root. */
+ static final String RESOURCE_DIR = "com/goldencode/expr/aot/index/";
+
+ /** Identity of the inputs the generated classes were built from, inside fwd-trpl.jar. */
+ static final String STAMP_RESOURCE = "com/goldencode/expr/aot/stamp.txt";
+
+ /** Identity those classes are expected to have, inside p2j.jar. */
+ static final String EXPECTED_RESOURCE = "com/goldencode/expr/aot-expected.txt";
+
+ /** What the generated classes were built for, inside fwd-trpl.jar. */
+ static final String META_RESOURCE = "com/goldencode/expr/aot/meta.txt";
+
+ /** Format marker of the index. */
+ static final String MAGIC = "#fwd-aot 2";
+
+ /** Occurrences served from the index. */
+ private static int hits = 0;
+
+ /** Occurrences which had to be compiled. */
+ private static int misses = 0;
+
+ /** Occurrences compiled because they belong to no profile -- expression text built at run time. */
+ private static int unnamedMisses = 0;
+
+ /** Hits and misses per profile, so a shortfall can be attributed rather than guessed at. */
+ private static final Mapnull. */
+ private static volatile String resident = null;
+
+ /**
+ * Flag disabling use of the generated classes, so a conversion compiles expressions exactly as
+ * it would without them. Set P2J_AOT_DISABLE in the environment. Kept as an
+ * escape hatch: if a generated class is ever suspected, this turns the mechanism off without
+ * rebuilding or repackaging anything.
+ */
+ private static final boolean DISABLED = (System.getenv("P2J_AOT_DISABLE") != null);
+
+ /**
+ * The artifact holding the generated classes -- fwd-trpl.jar -- or null when it is
+ * absent, unreadable, or does not match this build.
+ * true if a lookup could succeed.
+ */
+ static boolean isAvailable()
+ {
+ return !entries.isEmpty();
+ }
+
+ /**
+ * Make the generated entries of a profile resident, replacing whichever profile was resident
+ * before. Called as a profile's rule sets begin loading.
+ *
+ * @param profile
+ * Profile being loaded, or null to drop what is resident.
+ */
+ static synchronized void selectProfile(String profile)
+ {
+ if (DISABLED || profile == null || profile.equals(resident))
+ {
+ return;
+ }
+
+ resident = profile;
+ entries = read(profile);
+ }
+
+ /**
+ * Load one of the generated classes.
+ *
+ * @param className
+ * Fully qualified name of the class.
+ *
+ * @return The class.
+ *
+ * @throws ClassNotFoundException
+ * if it is not present.
+ */
+ static Class loadClass(String className)
+ throws ClassNotFoundException
+ {
+ return LOADER.loadClass(className, true);
+ }
+
+ /**
+ * Note that an occurrence was served from the index.
+ */
+ static synchronized void hit()
+ {
+ hits++;
+ tally(resident, 0);
+ }
+
+ /**
+ * Note that an occurrence had to be compiled.
+ */
+ static synchronized void miss()
+ {
+ misses++;
+ tally(resident, 1);
+ }
+
+ /**
+ * Note that an occurrence had to be compiled because it has no durable name at all, which means
+ * its text was assembled at run time rather than read from a rule set. Nothing can be
+ * generated for those.
+ */
+ static synchronized void unnamedMiss()
+ {
+ misses++;
+ unnamedMisses++;
+ }
+
+ /**
+ * Record an outcome against the profile currently loaded.
+ *
+ * @param profile
+ * Profile in force, or null.
+ * @param slot
+ * 0 for a hit, 1 for a miss.
+ */
+ private static void tally(String profile, int slot)
+ {
+ byProfile.computeIfAbsent((profile == null) ? "null if it has none.
+ * @param infix
+ * The occurrence's expression text, checked against the text the entry was generated
+ * from.
+ * @param flags
+ * The occurrence's runtime flags, likewise checked.
+ *
+ * @return The entry, or null if there is none or it does not describe this
+ * expression, in which case the caller compiles as usual.
+ */
+ static Entry lookup(String aotId, String infix, int flags)
+ {
+ if (aotId == null || entries.isEmpty())
+ {
+ return null;
+ }
+
+ int hash = aotId.lastIndexOf('#');
+
+ if (hash < 0 || !aotId.regionMatches(0, resident, 0, hash))
+ {
+ // an occurrence of some other profile; only one profile's entries are resident
+ return null;
+ }
+
+ Entry entry = entries.get(Integer.valueOf(aotId.substring(hash + 1)));
+
+ if (entry == null || entry.flags != flags || !entry.infixDigest.equals(digest(infix)))
+ {
+ return null;
+ }
+
+ return entry;
+ }
+
+ /**
+ * Digest an expression text.
+ *
+ * @param text
+ * Text to digest.
+ *
+ * @return Truncated hex encoded digest.
+ */
+ static String digest(String text)
+ {
+ try
+ {
+ byte[] raw = MessageDigest.getInstance("SHA-256")
+ .digest(text.getBytes(StandardCharsets.UTF_8));
+ StringBuilder buf = new StringBuilder(32);
+
+ for (byte b : raw)
+ {
+ buf.append(Character.forDigit((b >> 4) & 0xf, 16));
+ buf.append(Character.forDigit(b & 0xf, 16));
+ }
+
+ return buf.substring(0, 24);
+ }
+ catch (NoSuchAlgorithmException exc)
+ {
+ throw new IllegalStateException(exc);
+ }
+ }
+
+ /**
+ * Read the index from the classpath.
+ *
+ * @return The entries, or an empty map if no index is present or it cannot be parsed.
+ */
+ private static Mapnull if the generated classes should not be used.
+ */
+ private static Object openSource()
+ {
+ try
+ {
+ ClassLoader loader = AotIndex.class.getClassLoader();
+ String expected = text(loader.getResourceAsStream(EXPECTED_RESOURCE));
+
+ if (expected == null)
+ {
+ // this FWD build ships no generated classes
+ return null;
+ }
+
+ java.net.URL url = loader.getResource(STAMP_RESOURCE);
+
+ if (url == null)
+ {
+ // fwd-trpl.jar is not on the classpath; perfectly fine, just slower
+ return null;
+ }
+
+ String actual = text(url.openStream());
+
+ if (!expected.equals(actual))
+ {
+ System.err.println("AotIndex: fwd-trpl.jar was generated from different sources than " +
+ "this p2j.jar (expected " + expected + ", found " + actual +
+ "); ignoring it and compiling expressions normally");
+
+ return null;
+ }
+
+ if ("jar".equals(url.getProtocol()))
+ {
+ java.net.JarURLConnection conn = (java.net.JarURLConnection) url.openConnection();
+
+ conn.setUseCaches(false);
+
+ return new java.util.jar.JarFile(new File(conn.getJarFileURL().toURI()));
+ }
+
+ if ("file".equals(url.getProtocol()))
+ {
+ // exploded on disk: climb back out of the resource path to the classpath root
+ File root = new File(url.toURI());
+
+ for (int i = 0; i < STAMP_RESOURCE.split("/").length; i++)
+ {
+ root = root.getParentFile();
+ }
+
+ return root;
+ }
+
+ return null;
+ }
+ catch (Exception exc)
+ {
+ System.err.println("AotIndex: could not open fwd-trpl.jar, compiling normally: " + exc);
+
+ return null;
+ }
+ }
+
+ /**
+ * Read a small text resource, trimmed.
+ *
+ * @param in
+ * Stream to read, possibly null. Closed on return.
+ *
+ * @return The trimmed content, or null.
+ */
+ private static String text(InputStream in)
+ {
+ if (in == null)
+ {
+ return null;
+ }
+
+ try (InputStream stream = in)
+ {
+ return new String(stream.readAllBytes(), StandardCharsets.UTF_8).trim();
+ }
+ catch (IOException exc)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * Interpret bytes as trimmed text.
+ *
+ * @param raw
+ * Bytes, possibly null.
+ *
+ * @return The trimmed content, or null.
+ */
+ private static String text(byte[] raw)
+ {
+ return (raw == null) ? null : new String(raw, StandardCharsets.UTF_8).trim();
+ }
+
+ /**
+ * Read one entry from the artifact.
+ *
+ * @param path
+ * Entry path, relative to the artifact root.
+ *
+ * @return The bytes, or null if absent.
+ */
+ private static byte[] bytesOf(String path)
+ {
+ try
+ {
+ if (SOURCE instanceof java.util.jar.JarFile)
+ {
+ java.util.jar.JarFile jar = (java.util.jar.JarFile) SOURCE;
+ java.util.zip.ZipEntry entry = jar.getEntry(path);
+
+ if (entry == null)
+ {
+ return null;
+ }
+
+ try (InputStream in = jar.getInputStream(entry))
+ {
+ return in.readAllBytes();
+ }
+ }
+
+ if (SOURCE instanceof File)
+ {
+ File file = new File((File) SOURCE, path);
+
+ return file.isFile() ? java.nio.file.Files.readAllBytes(file.toPath()) : null;
+ }
+
+ // no usable artifact: nothing to read, and the caller compiles instead
+ return null;
+ }
+ catch (IOException exc)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * Report what the generated classes did for this run. A run which loaded an index but matched
+ * nothing is called out: that is what a conversion looks like when its debug level differs
+ * from the one the classes were generated for, and it would otherwise be invisible.
+ */
+ private static void report()
+ {
+ if (DISABLED)
+ {
+ return;
+ }
+
+ System.err.println("AotIndex: served " + hits + ", compiled " + misses +
+ ((unnamedMisses == 0) ? ""
+ : (" (" + unnamedMisses +
+ " of them expressions built at run time, which " +
+ "cannot be generated ahead of time)")));
+
+ // Attribute the shortfall. A profile which misses wholesale was not generated -- excluded
+ // from the build, or it failed to load in the generator -- and that is worth knowing,
+ // because it is fixable in a way that individual misses are not.
+ byProfile.entrySet()
+ .stream()
+ .filter(e -> e.getValue()[1] > 0)
+ .sorted((a, b) -> b.getValue()[1] - a.getValue()[1])
+ .limit(10)
+ .forEach(e -> System.err.println("AotIndex: " + e.getKey() + " served " +
+ e.getValue()[0] + ", compiled " +
+ e.getValue()[1]));
+
+ if (hits == 0 && misses > 0)
+ {
+ System.err.println("AotIndex: WARNING - an index was found but no occurrence matched it. " +
+ "The usual cause is a conversion debug level (the Dn option) different " +
+ "from the one the classes were generated for; expressions are being " +
+ "compiled as if the generated classes were absent.");
+ }
+ }
+
+ /**
+ * One indexed occurrence: which class serves it, and the state needed to bind that class to a
+ * caller's scope without parsing the expression again.
+ */
+ static final class Entry
+ {
+ /** Fully qualified name of the class which serves this occurrence. */
+ final String className;
+
+ /** Runtime flags the class was generated under. */
+ final int flags;
+
+ /** Digest of the expression text the class was generated from. */
+ final String infixDigest;
+
+ /** Name of the blueprint's return type. */
+ final String returnType;
+
+ /** Library symbol names, in slot order. */
+ final ListWhy not the application loader
+ *
+ * The conversion classpath is several hundred jars. Resolving a generated class through the
+ * application loader searches all of them, and doing that once per generated class costs
+ * seconds. This loader knows the single artifact they live in, so a load is one zip entry read.
+ *
+ * Why loadClass is overridden and not just findClass
+ *
+ * The inherited loadClass is parent first: it would consult the application loader
+ * -- and therefore search that whole classpath -- before ever calling {@link #findClass}, which
+ * is exactly the cost this loader exists to avoid. Generated classes are never on the parent's
+ * classpath, so for them the order is inverted. Everything else, including the superclass of
+ * every generated class and every type its code refers to, delegates normally.
+ */
+ private static final class AotClassLoader extends ClassLoader
+ {
+ static
+ {
+ // per class name locking rather than one lock for the loader: conversion threads load
+ // these concurrently
+ registerAsParallelCapable();
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param parent
+ * Loader to delegate everything but the generated classes to.
+ */
+ AotClassLoader(ClassLoader parent)
+ {
+ super(parent);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected Class loadClass(String name, boolean resolve)
+ throws ClassNotFoundException
+ {
+ if (!name.startsWith(PACKAGE))
+ {
+ return super.loadClass(name, resolve);
+ }
+
+ synchronized (getClassLoadingLock(name))
+ {
+ Class found = findLoadedClass(name);
+
+ if (found == null)
+ {
+ found = findClass(name);
+ }
+
+ if (resolve)
+ {
+ resolveClass(found);
+ }
+
+ return found;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected Class findClass(String name)
+ throws ClassNotFoundException
+ {
+ byte[] data = bytesOf(name.replace('.', '/') + ".class");
+
+ if (data == null)
+ {
+ throw new ClassNotFoundException(name);
+ }
+
+ return defineClass(name, data, 0, data.length);
+ }
+ }
+}
diff -Nru old/src/com/goldencode/expr/Compiler.java new/src/com/goldencode/expr/Compiler.java
--- old/src/com/goldencode/expr/Compiler.java 2026-09-25 09:27:23.808572431 +0300
+++ new/src/com/goldencode/expr/Compiler.java 2026-09-25 09:27:23.846480642 +0300
@@ -57,6 +57,8 @@
** Cloned global variables during instantiation.
** Reserved class name atomically upfront in process() and synchronize
** load() on the shared loader instance to fix concurrent compilation.
+** 019 TG 20260909 compile() takes the compile-time scope, which is now part of the
+** compiler cache key.
*/
/*
@@ -117,6 +119,7 @@
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
+import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
@@ -253,6 +256,13 @@
/** Instance of compiled expression custom subclass */
private CompiledExpression compiled = null;
+
+ /**
+ * Compilers restored from the classes generated when FWD was built, keyed by the whole of the
+ * index entry they were built from -- class, return type and both slot maps. See
+ * {@link #restore} for why the class name alone is not a sufficient key.
+ */
+ private static final MapCompiledExpression.
@@ -299,17 +313,19 @@
* @throws CompilerException
* if any error occurs during compilation of the expression.
*/
- static CompiledExpression compile(Expression expression)
+ static CompiledExpression compile(Expression expression, Scope scope)
throws CompilerException
{
- // Check if there is already a compiler for this expression.
- Compiler compiler = expression.getCompiler();
+ // Check if there is already a compiler for this expression in this scope. The lookup is
+ // scope aware because a generated class is specific to the scope which compiled it: the
+ // types of the variables it reads are frozen into its bytecode.
+ Compiler compiler = expression.getCompiler(scope);
if (compiler == null)
{
compiler = new Compiler(expression);
}
CompiledExpression compiled = compiler.process(expression.getResolver());
- expression.putCompiler(compiler);
+ expression.putCompiler(compiler, scope);
return compiled;
}
@@ -353,17 +369,6 @@
CompiledExpression process(SymbolResolver resolver)
throws CompilerException
{
- // Create a class file object into which to install execute method.
- int myIndex = classCount.getAndIncrement(); // reserve atomically upfront
- classFile = new ClassFile(
- PKG_PREFIX + CLASS_NAME_PREFIX + myIndex,
- CLASS_COMPILEDEXPRESSION
- );
-
- // Get constant pool, which is needed during assembly and
- // compilation.
- constantPool = classFile.getConstantPool();
-
try
{
// Parse infix expression into AST.
@@ -378,12 +383,41 @@
ExpressionParser.visit(tree, 0);
}
+ // Everything the generated code depends on is resolved at this point and nothing has been
+ // assembled yet, which is both where the compilation can be described and therefore where
+ // a name derived from that description can be chosen. Only the generator needs such a
+ // name; an ordinary run keeps the sequential naming, and the two live in different
+ // packages so they can never collide.
+ String internal;
+
+ if (AotGenerator.isGenerating())
+ {
+ internal = AotGenerator.internalName(signature());
+ }
+ else
+ {
+ internal = PKG_PREFIX + CLASS_NAME_PREFIX + classCount.getAndIncrement();
+ }
+
+ // Create a class file object into which to install execute method. Note that ClassFile
+ // takes the internal, slash separated form, which is what ends up in the constant pool.
+ classFile = new ClassFile(internal, CLASS_COMPILEDEXPRESSION);
+
+ // Get constant pool, which is needed during assembly and
+ // compilation.
+ constantPool = classFile.getConstantPool();
+
// Assemble core bytecode for execute method.
CodeUnit unit = assemble(tree);
// Prepare class file and wrap execute bytecode with return logic.
prepare(unit);
+ if (AotGenerator.isGenerating())
+ {
+ AotGenerator.emit(expression, classFile, returnType, libraries, variables);
+ }
+
// Load the class using the custom classloader.
load();
@@ -429,6 +463,325 @@
}
/**
+ * Build a compiler around a class which was generated when FWD was built, without parsing,
+ * resolving or assembling anything.
+ * null if the class could not be used, in which case the
+ * caller compiles as usual.
+ */
+ static Compiler restore(Expression expression, AotIndex.Entry entry)
+ {
+ // Occurrences outnumber restored compilers several to one, and this runs per occurrence, so
+ // without a cache each one pays a reflective instantiation and a rebuild of the slot maps
+ // for state already assembled.
+ //
+ // The key is NOT the class name alone. Generated classes are folded together when their
+ // bytecode is identical bar their own name, and only slot *indices* are baked into that
+ // bytecode -- the symbol names mapped onto those indices live here, not in the class. Two
+ // occurrences can therefore share a class while resolving different variables through the
+ // same slots, so everything this compiler takes from the entry has to be part of the key.
+ // (Loading the class itself is still shared across all of them: the class loader caches by
+ // name, so the define and verify happen once regardless.)
+ String cacheKey = entry.className + '\u0000' + entry.returnType + '\u0000' +
+ entry.libraries + '\u0000' + entry.variables;
+
+ Compiler cached = RESTORED.get(cacheKey);
+
+ if (cached != null)
+ {
+ return cached;
+ }
+
+ Compiler compiler = new Compiler(expression);
+
+ try
+ {
+ // resolved directly from the artifact holding it, rather than by searching the whole
+ // conversion classpath once per generated class
+ compiler.customClass = AotIndex.loadClass(entry.className);
+
+ compiler.returnType = "null".equals(entry.returnType) ? null : forName(entry.returnType);
+
+ slots(entry.libraries, compiler.libraries);
+ slots(entry.variables, compiler.variables);
+
+ compiler.compiled =
+ (CompiledExpression) compiler.customClass.getDeclaredConstructor().newInstance();
+ compiler.compiled.setReturnType(compiler.returnType);
+ compiler.compiled.setLibraries(new Object[0]);
+ compiler.compiled.setVariables(new Variable[0]);
+ compiler.compiled.setThreadId(Thread.currentThread().getId());
+
+ Compiler previous = RESTORED.putIfAbsent(cacheKey, compiler);
+
+ return (previous == null) ? compiler : previous;
+ }
+ catch (Throwable thr)
+ {
+ // any trouble at all and the caller falls back to compiling, which is always correct
+ System.err.println("AotIndex: could not use " + entry.className + ": " + thr);
+
+ return null;
+ }
+ }
+
+ /**
+ * Get the scope independent blueprint instance of the generated class. Callers clone it and
+ * bind the clone to their own scope through {@link #instantiate}.
+ *
+ * @return The blueprint, or null if this compiler has not produced one.
+ */
+ CompiledExpression getBlueprint()
+ {
+ return compiled;
+ }
+
+ /**
+ * Resolve a type name, allowing for the primitives which are not loadable classes.
+ *
+ * @param name
+ * Fully qualified type name.
+ *
+ * @return The class.
+ *
+ * @throws ClassNotFoundException
+ * if the name cannot be resolved.
+ */
+ private static Class forName(String name)
+ throws ClassNotFoundException
+ {
+ switch (name)
+ {
+ case "boolean": return Boolean.TYPE;
+ case "byte": return Byte.TYPE;
+ case "char": return Character.TYPE;
+ case "short": return Short.TYPE;
+ case "int": return Integer.TYPE;
+ case "long": return Long.TYPE;
+ case "float": return Float.TYPE;
+ case "double": return Double.TYPE;
+ case "void": return Void.TYPE;
+ default: return Class.forName(name);
+ }
+ }
+
+ /**
+ * Rebuild a symbol to slot map from the symbol names in slot order.
+ *
+ * @param names
+ * Symbol names, in slot order.
+ * @param target
+ * Map to populate.
+ */
+ private static void slots(ListtoString for anything unrecognized. Over-inclusion only costs a redundant class;
+ * omitting something the assembler uses would let two classes with different casts share a
+ * description, which is exactly the defect this description exists to prevent.
+ *
+ * @return Canonical description of this compilation.
+ */
+ String signature()
+ {
+ StringBuilder buf = new StringBuilder(256);
+
+ buf.append("infix=").append(expression.getInfix())
+ .append("\nflags=").append(expression.getRuntimeFlags())
+ .append("\nprecision=").append(expression.getPrecision())
+ .append("\nresult=").append(name(resultType))
+ .append("\nreturn=").append(name(returnType))
+ .append("\nlibs=").append(slotNames(libraries))
+ .append("\nvars=").append(slotNames(variables));
+
+ describe(tree, buf);
+
+ return buf.toString();
+ }
+
+ /**
+ * Append a canonical description of a node and, recursively, of its children.
+ *
+ * @param ast
+ * Node to describe, or null.
+ * @param buf
+ * Target buffer.
+ */
+ private void describe(ExtraAst ast, StringBuilder buf)
+ {
+ if (ast == null)
+ {
+ return;
+ }
+
+ buf.append("\n(").append(ast.getType());
+
+ Class operand = ast.getOperandType();
+
+ if (operand != null)
+ {
+ buf.append(" op=").append(name(operand));
+ }
+
+ Object extra = ast.getExtra();
+
+ if (extra instanceof LogicalData)
+ {
+ // the branch bookkeeping is derived from the tree shape, which is described anyway; only
+ // the payload it wraps affects the emitted code
+ extra = ((LogicalData) extra).getExtra();
+ buf.append(" logical");
+ }
+
+ if (extra instanceof Function)
+ {
+ Function func = (Function) extra;
+ String symbol = func.getSymbol();
+
+ // every component is spelled out rather than taken from Function.toString(), which
+ // abbreviates: it omits the method's declaring class, and two methods differing only
+ // there assemble to different invocations
+ Method method = func.getMethod();
+
+ buf.append(" kind=").append(func.getType())
+ .append(" sym=").append(symbol)
+ .append(" target=").append(name(func.getTarget()))
+ .append(" ret=").append(name(func.getReturnType()))
+ .append(" minArgs=").append(func.getMinArgs())
+ .append(" varArg=").append(func.isVarArg())
+ .append(" params=").append(names(func.getParameterTypes()));
+
+ if (method == null)
+ {
+ buf.append(" m=null");
+ }
+ else
+ {
+ buf.append(" m=").append(name(method.getDeclaringClass()))
+ .append('#').append(method.getName())
+ .append(names(method.getParameterTypes()))
+ .append(':').append(name(method.getReturnType()))
+ .append('/').append(method.getModifiers());
+ }
+
+ if (symbol != null)
+ {
+ // the slot index is emitted into the bytecode as a literal
+ Integer slot = libraries.get(symbol);
+
+ if (slot == null)
+ {
+ slot = variables.get(symbol);
+ }
+
+ buf.append(" slot=").append(slot);
+ }
+ }
+ else if (extra != null)
+ {
+ // unrecognized payload: describe it rather than ignore it
+ buf.append(" extra=").append(extra.getClass().getName())
+ .append('[').append(extra).append(']');
+ }
+
+ buf.append(" text=").append(ast.getText());
+
+ describe((ExtraAst) ast.getFirstChild(), buf);
+
+ buf.append(')');
+
+ describe((ExtraAst) ast.getNextSibling(), buf);
+ }
+
+ /**
+ * Render a symbol to slot map in slot order.
+ *
+ * @param slots
+ * Map of symbol name to slot index.
+ *
+ * @return Canonical rendering.
+ */
+ private static String slotNames(Mapnull.
+ *
+ * @param type
+ * Class to render, or null.
+ *
+ * @return The class name, or "null".
+ */
+ private static String name(Class type)
+ {
+ return (type == null) ? "null" : type.getName();
+ }
+
+ /**
+ * Render an array of class references, tolerating null.
+ *
+ * @param types
+ * Classes to render, or null.
+ *
+ * @return Canonical rendering.
+ */
+ private static String names(Class[] types)
+ {
+ if (types == null)
+ {
+ return "null";
+ }
+
+ StringBuilder buf = new StringBuilder(32);
+
+ buf.append('(');
+
+ for (int i = 0; i < types.length; i++)
+ {
+ if (i > 0)
+ {
+ buf.append(',');
+ }
+
+ buf.append(name(types[i]));
+ }
+
+ return buf.append(')').toString();
+ }
+
+ /**
* This method tracks changes in the current and maximum stack depths. It
* is called by the Instruction class for each instruction
* in a method's code attribute. The maximum stack depth is ultimately
diff -Nru old/src/com/goldencode/expr/Expression.java new/src/com/goldencode/expr/Expression.java
--- old/src/com/goldencode/expr/Expression.java 2026-09-25 09:27:23.813359810 +0300
+++ new/src/com/goldencode/expr/Expression.java 2026-09-25 09:27:23.847012251 +0300
@@ -59,6 +59,11 @@
** 013 AOG 20260220 Added global cache for compilers to make threads share the same compiler
** for the same expressions. Added lazy instantiation of compiled expression.
** Added clone method implementation used for thread-specific expressions.
+** 014 TG 20260909 Added the compile-time scope to CacheKey, so that the compiler cache
+** can no longer hand a class typed for one scope to another. Read the
+** compiler and instance caches before taking the compile lock, so that a
+** cache hit does not serialize across conversion threads. Build the
+** cache key once per lookup.
*/
/*
** This program is free software: you can redistribute it and/or modify
@@ -153,6 +158,21 @@
* expression residing in the cache, then the cached, compiled expression is
* used. Otherwise, the expression is considered new and it is compiled and
* cached.
+ *
+ * Caching model: a compiled expression is bound to its scope
+ *
+ * A generated CE<n> class is specific to the scope which compiled it
+ * and must never be executed on behalf of a different scope. Symbol resolution types every
+ * user variable accessor from var.getType() as found in the scope in force at
+ * compile time, and since CompiledExpression.getVar(int) returns
+ * Object, the assembler freezes that type into a checkcast. The
+ * name to slot index maps a {@link Compiler} holds are rebound per caller by
+ * {@link Compiler#instantiate}; the cast types are not.
+ * ClassCastException raised
+ * inside the generated class.
* null outside a load.
+ * null if it did not come from a
+ * rule set load and so has no generated counterpart. Carried through {@link #clone}, so every
+ * thread's copy of one occurrence shares a single name.
+ */
+ private String aotId = null;
/**
* Construct a new instance of an Expression using the
@@ -559,7 +603,66 @@
}
/**
- * Clears global compiler cache.
+ * Note that the rule sets of a profile are about to be loaded, so that each expression created
+ * during that load can be given a durable name. Loading is single threaded, so this needs no
+ * synchronization.
+ *
+ * @param profile
+ * Name of the profile being loaded.
+ */
+ public static void beginProfileLoad(String profile)
+ {
+ aotProfile = profile;
+ aotOrdinal = 0;
+
+ AotIndex.selectProfile(profile);
+ }
+
+ /**
+ * Note that a profile load has finished. Expressions created afterwards -- from a dynamically
+ * assembled expression text, say -- are not part of the profile's stable sequence and are left
+ * unnamed, so that they compile normally. They cannot disturb the names already handed out.
+ */
+ public static void endProfileLoad()
+ {
+ aotProfile = null;
+ }
+
+ /**
+ * Give this expression the next durable name in the profile being loaded. Does nothing outside
+ * a profile load.
+ */
+ public void assignAotId()
+ {
+ if (aotProfile != null)
+ {
+ aotId = aotProfile + '#' + (aotOrdinal++);
+ }
+ }
+
+ /**
+ * Get this expression occurrence's durable name.
+ *
+ * @return The name, or null if it did not come from a rule set load.
+ */
+ public String getAotId()
+ {
+ return aotId;
+ }
+
+ /**
+ * Force this expression to be compiled, without executing it. Used when generating the classes
+ * of the shipped rule sets; the caller is responsible for having put the expression's own scope
+ * in force first.
+ */
+ public void warm()
+ {
+ getCompiledInstance();
+ }
+
+ /**
+ * Clears global compiler cache. Invoked when a ruleset goes out of service; the keys hold
+ * the scopes of that ruleset, so the entries are dead at that point anyway.
*/
public void cleanup()
{
@@ -715,37 +818,94 @@
return compiled;
}
- // Check cache; compile if necessary.
+ // Check cache; compile if necessary. The key is built once and reused for every lookup
+ // below, as constructing it hashes the expression text.
SymbolResolver sr = resolver.get();
- CacheKey key = new CacheKey(this);
Scope scope = sr.getCurrentScope();
- Lock lock = locks.computeIfAbsent(key, k -> new ReentrantLock());
- CompiledExpression instance;
+ CacheKey key = new CacheKey(this, scope);
- lock.lock();
- try
+ // A cached instance is unusable without its compiler, which performs the instantiation
+ // below. Both are read before the lock is taken, so that a cache hit does not have to
+ // queue behind another thread's compile.
+ CompiledExpression instance = sr.getCachedInstance(scope, key);
+ Compiler compiler = compilers.get(key);
+
+ if ((instance == null || compiler == null) && AotIndex.isAvailable())
{
- instance = sr.getCachedInstance(scope, key);
+ // This occurrence's class may have been generated when FWD was built. Using it needs no
+ // parsing, resolution or assembly, and so nothing that the compile lock orders, which is
+ // why it is attempted before the lock is taken.
+ AotIndex.Entry entry = AotIndex.lookup(aotId, infix, flags);
- // A cached instance is unusable without its compiler, which performs the instantiation below.
- if (instance == null || getCompiler() == null)
+ if (entry == null)
{
- // Nothing usable in the cache; we must compile.
- instance = Compiler.compile(this);
- sr.putCachedInstance(scope, key, instance);
+ if (aotId == null)
+ {
+ AotIndex.unnamedMiss();
+ }
+ else
+ {
+ AotIndex.miss();
+ }
+ }
+ else
+ {
+ Compiler restored = Compiler.restore(this, entry);
+
+ if (restored == null)
+ {
+ AotIndex.miss();
+ }
+ else
+ {
+ AotIndex.hit();
+
+ compiler = compilers.putIfAbsent(key, restored);
+
+ if (compiler == null)
+ {
+ compiler = restored;
+ }
+
+ instance = compiler.getBlueprint();
+
+ sr.putCachedInstance(scope, key, instance);
+ }
}
}
- catch (CompilerException exc)
- {
- // Wrap this in an unchecked exception, so the caller does not
- // take the mandatory performance hit of a try-catch around
- // every call to execute the expression.
- throw new ExpressionException(
- "Expression error [" + infix + "]", exc);
- }
- finally
+
+ if (instance == null || compiler == null)
{
- lock.unlock();
+ Lock lock = locks.computeIfAbsent(key, k -> new ReentrantLock());
+
+ lock.lock();
+ try
+ {
+ // re-check under the lock; another thread may have compiled this expression while
+ // we were waiting for it
+ instance = sr.getCachedInstance(scope, key);
+
+ if (instance == null || compilers.get(key) == null)
+ {
+ // Nothing usable in the cache; we must compile.
+ instance = Compiler.compile(this, scope);
+ sr.putCachedInstance(scope, key, instance);
+ }
+
+ compiler = compilers.get(key);
+ }
+ catch (CompilerException exc)
+ {
+ // Wrap this in an unchecked exception, so the caller does not
+ // take the mandatory performance hit of a try-catch around
+ // every call to execute the expression.
+ throw new ExpressionException(
+ "Expression error [" + infix + "]", exc);
+ }
+ finally
+ {
+ lock.unlock();
+ }
}
compiled = instance.clone(sr);
@@ -753,33 +913,40 @@
dirty = false;
// Trigger the lazy instantiation
- this.getCompiler().instantiate(compiled, resolver.get());
+ compiler.instantiate(compiled, sr);
return compiled;
}
/**
- * Registers a compiled expression in the global cache.
+ * Registers a compiled expression in the global cache, under the given scope.
*
* @param compiler
* The {@link Compiler} instance to be cached for future reuse.
+ * @param scope
+ * Scope whose symbols the compiler resolved. This must be the same scope the
+ * caller used to look the compiler up, so that publication and lookup agree on
+ * the key.
*/
- public void putCompiler(Compiler compiler)
+ public void putCompiler(Compiler compiler, Scope scope)
{
- CacheKey key = new CacheKey(this);
- compilers.putIfAbsent(key, compiler);
+ compilers.putIfAbsent(new CacheKey(this, scope), compiler);
}
/**
- * Retrieves a previously cached compiler for the current expression.
+ * Retrieves a previously cached compiler for this expression in the given scope. A compiler
+ * found this way generated its class for that same scope, so its blueprint may be reused as
+ * is.
+ *
+ * @param scope
+ * Scope to look the compiler up for.
*
* @return The cached {@link Compiler} instance, or {@code null}
* if no match exists in the cache.
*/
- public Compiler getCompiler()
+ public Compiler getCompiler(Scope scope)
{
- CacheKey key = new CacheKey(this);
- return compilers.get(key);
+ return compilers.get(new CacheKey(this, scope));
}
/**
@@ -791,6 +958,17 @@
* var.getType() as found in that scope, and the assembler freezes that type into
+ * a checkcast. Two rulesets declaring an identically named variable with
+ * different types produce the same text and flags but incompatible classes, so a key without
+ * a scope would conflate them and the expression would fail at runtime with a
+ * ClassCastException inside the generated class.
*/
private static class CacheKey
{
@@ -800,17 +978,23 @@
/** Runtime flags set for expression */
private final int flags;
+ /** Scope in force when the expression was compiled; may be null. */
+ private final Scope scope;
+
/**
* Convenience constructor which instantiates a new key and sets the
* internal key state, based upon the expression state.
*
* @param expr
* Expression object on which the cache key state is based.
+ * @param scope
+ * Scope in force for this lookup, or null if none.
*/
- CacheKey(Expression expr)
+ CacheKey(Expression expr, Scope scope)
{
this.infix = expr.infix;
this.flags = expr.flags;
+ this.scope = scope;
}
/**
@@ -825,6 +1009,7 @@
int result = 17;
result = 37 * result + flags;
result = 37 * result + infix.hashCode();
+ result = 37 * result + ((scope == null) ? 0 : scope.hashCode());
return result;
}
@@ -850,7 +1035,8 @@
// Assume case is safe.
CacheKey that = (CacheKey) o;
- return (infix.equals(that.infix) && flags == that.flags);
+ return (infix.equals(that.infix) && flags == that.flags &&
+ ((scope == null) ? (that.scope == null) : scope.equals(that.scope)));
}
}
diff -Nru old/src/com/goldencode/expr/SymbolResolver.java new/src/com/goldencode/expr/SymbolResolver.java
--- old/src/com/goldencode/expr/SymbolResolver.java 2026-09-25 09:27:23.817947205 +0300
+++ new/src/com/goldencode/expr/SymbolResolver.java 2026-09-25 09:27:23.847315524 +0300
@@ -83,6 +83,8 @@
** Removed synchronized modifier for a few methods as the context-local is used.
** 20260724 Replaced locking system with synchronized map to reduce bottleneck.
** Moved shared maps to concurrent maps to guarantee synchronization.
+** 020 TG 20260909 Documented that a generated expression class is bound to the scope which
+** compiled it, as its variable accessor types are frozen into bytecode.
*/
/*
** This program is free software: you can redistribute it and/or modify
@@ -339,7 +341,19 @@
}
}
- /** Compiled expression instance cache */
+ /**
+ * Compiled expression instance cache.
+ * Scope object which performed the put: {@link Scope#equals}
+ * matches clones by originId, so a per-thread clone can look the entry up, but
+ * the entry still dies with the particular clone that created it.
+ */
private static final MapWhy this drives the ordinary machinery
+ *
+ * The classes produced here have to be exactly the ones a conversion would have produced, and the
+ * only way to be certain of that is to produce them the same way. This driver therefore loads a
+ * profile through {@link PatternEngine} as usual and then walks the resulting rule tree, putting
+ * each container or function in scope and asking its expressions to compile. Nothing is executed:
+ * an expression is compiled by asking for its return type, which is the same lazy compilation a
+ * conversion triggers on first use.
+ * Coverage is an optimization, not a contract
+ *
+ * Anything this driver misses -- an expression whose profile fails to load, one which cannot be
+ * compiled outside a running conversion, a variable initializer -- is simply absent from the index,
+ * and a conversion which reaches it compiles it exactly as it does today. Failures are therefore
+ * counted and reported rather than allowed to fail the build.
+ */
+public final class AotWarmer
+{
+ /** Number of expressions which could not be compiled ahead of time. */
+ private static int failures = 0;
+
+ /** One example failure per distinct message, to keep the build log readable. */
+ private static final Map-Dp2j.aot.verbose=true to see which profiles were skipped and why expressions
+ * were left to run time.
+ */
+ private static final boolean VERBOSE = Boolean.getBoolean("p2j.aot.verbose");
+
+ /**
+ * Generate the expression classes of every profile named, and write them out.
+ * true if the profile was loaded.
+ */
+ private static boolean generate(String profile)
+ {
+ PatternEngine engine = new PatternEngine();
+
+ try
+ {
+ // Hold the engine in its initializing state for the whole walk. That keeps the shared
+ // rule tree in play instead of the per thread copies a conversion would take, which is
+ // both what we want to enumerate and cheaper.
+ PatternEngine.isInitializingGlobals = true;
+
+ Expression.beginProfileLoad(profile);
+
+ try
+ {
+ engine.initialize(profile);
+ }
+ finally
+ {
+ Expression.endProfileLoad();
+ }
+
+ AstSymbolResolver resolver = AstSymbolResolver.getResolver();
+
+ engine.getBaseRuleContainer().warm(resolver);
+
+ return true;
+ }
+ catch (Throwable thr)
+ {
+ skipped++;
+
+ if (VERBOSE)
+ {
+ System.out.println(" skipped profile " + profile + ": " + thr);
+ }
+
+ return false;
+ }
+ finally
+ {
+ PatternEngine.isInitializingGlobals = false;
+
+ try
+ {
+ engine.finish();
+ }
+ catch (Throwable thr)
+ {
+ // teardown trouble does not invalidate what was already generated
+ }
+ }
+ }
+
+ /**
+ * Not instantiable.
+ */
+ private AotWarmer()
+ {
+ }
+}
diff -Nru old/src/com/goldencode/p2j/pattern/AstSymbolResolver.java new/src/com/goldencode/p2j/pattern/AstSymbolResolver.java
--- old/src/com/goldencode/p2j/pattern/AstSymbolResolver.java 2026-09-25 09:27:23.822968771 +0300
+++ new/src/com/goldencode/p2j/pattern/AstSymbolResolver.java 2026-09-25 09:27:23.847808824 +0300
@@ -571,6 +571,11 @@
break;
}
+ // Every expression belonging to a rule set passes through here, in the single threaded,
+ // document order sequence of a profile load, so this is the one place which can give an
+ // occurrence the durable name its generated class is indexed under.
+ expr.assignAotId();
+
return expr;
}
@@ -1298,6 +1303,27 @@
{
return context.get().ruleScope;
}
+
+ /**
+ * Make a named function the innermost scope, as invoking it would. Used when generating the
+ * expression classes of the shipped rule sets, where a function's expressions must be compiled
+ * in the function's own scope but must not be executed.
+ *
+ * @param func
+ * Function to push.
+ */
+ void pushFunctionScope(NamedFunction func)
+ {
+ context.get().funcScopes.push(func);
+ }
+
+ /**
+ * Undo a {@link #pushFunctionScope}.
+ */
+ void popFunctionScope()
+ {
+ context.get().funcScopes.pop();
+ }
/**
* Set the current source and copy ASTs which will form the basis of all
diff -Nru old/src/com/goldencode/p2j/pattern/NamedFunction.java new/src/com/goldencode/p2j/pattern/NamedFunction.java
--- old/src/com/goldencode/p2j/pattern/NamedFunction.java 2026-09-25 09:27:23.827642673 +0300
+++ new/src/com/goldencode/p2j/pattern/NamedFunction.java 2026-09-25 09:27:23.848116304 +0300
@@ -362,6 +362,49 @@
}
/**
+ * Force every expression in this function's body to be compiled in the function's own scope,
+ * without executing anything. Used when generating the expression classes of the shipped rule
+ * sets.
+ *
+ * @param resolver
+ * AST symbol resolver.
+ * @param callerScope
+ * Scope which encloses this function.
+ */
+ void warm(AstSymbolResolver resolver, Scope callerScope)
+ {
+ enclosingScopes.push(callerScope);
+ resolver.pushFunctionScope(this);
+
+ try
+ {
+ for (Object item : expr)
+ {
+ if (item instanceof Expression)
+ {
+ try
+ {
+ ((Expression) item).warm();
+ }
+ catch (Throwable thr)
+ {
+ AotWarmer.failed((Expression) item, thr);
+ }
+ }
+ else if (item instanceof Rule)
+ {
+ ((Rule) item).warm(resolver);
+ }
+ }
+ }
+ finally
+ {
+ resolver.popFunctionScope();
+ enclosingScopes.pop();
+ }
+ }
+
+ /**
* Execute this named function, handling all user provided parameter
* assignments before the actual execution. The execution proceeds
* through all expressions (defined via {@link #registerExpression}) and
diff -Nru old/src/com/goldencode/p2j/pattern/PatternEngine.java new/src/com/goldencode/p2j/pattern/PatternEngine.java
--- old/src/com/goldencode/p2j/pattern/PatternEngine.java 2026-09-25 09:27:23.832068413 +0300
+++ new/src/com/goldencode/p2j/pattern/PatternEngine.java 2026-09-25 09:27:23.848306731 +0300
@@ -324,6 +324,8 @@
import com.goldencode.artifacts.*;
import com.goldencode.ast.*;
+// single type import: a wildcard here would make SymbolResolver ambiguous against p2j.uast
+import com.goldencode.expr.Expression;
import com.goldencode.p2j.cfg.*;
import com.goldencode.p2j.convert.*;
import com.goldencode.p2j.security.*;
@@ -1089,7 +1091,19 @@
try
{
isInitializingGlobals = true;
- initialize(profile);
+
+ // Name every expression created while this profile's rule sets are read, so that an
+ // occurrence can be matched to the class generated for it when FWD was built.
+ Expression.beginProfileLoad(profile);
+
+ try
+ {
+ initialize(profile);
+ }
+ finally
+ {
+ Expression.endProfileLoad();
+ }
baseRuleContainer.applyGlobal(RULE_INIT);
diff -Nru old/src/com/goldencode/p2j/pattern/RuleContainer.java new/src/com/goldencode/p2j/pattern/RuleContainer.java
--- old/src/com/goldencode/p2j/pattern/RuleContainer.java 2026-09-25 09:27:23.841455168 +0300
+++ new/src/com/goldencode/p2j/pattern/RuleContainer.java 2026-09-25 09:27:23.849021154 +0300
@@ -619,6 +619,58 @@
}
/**
+ * Force every expression in this container, its functions and its includes to be compiled,
+ * each with its own scope in force, without executing anything. Used when generating the
+ * expression classes of the shipped rule sets.
+ *
+ * @param resolver
+ * AST symbol resolver.
+ */
+ void warm(AstSymbolResolver resolver)
+ {
+ RuleContainer previous = resolver.getRuleScope();
+
+ resolver.setRuleScope(this);
+
+ try
+ {
+ Listnull.
+ * @param resolver
+ * AST symbol resolver.
+ */
+ private static void warmAll(List