Typesettable,

Cloneable,

Supplier<F>,

Consumer<Consumer<Expression<?, ?, ?>>>

{

public boolean shouldCache()

{

return domainType.equals(Integer.class) && !isGeneratedFunctional() && upstreamExpression == null;

}

protected void declareCacheField(ClassVisitor cw)

{

if (shouldCache())

{

cw.visitField(Opcodes.ACC_PUBLIC, "cache", Type.getDescriptor(ArrayList.class), null, null);

}

}

protected void generateCacheFieldInitializer(MethodVisitor mv)

{

if (shouldCache())

{

String internalName = Type.getInternalName(ArrayList.class);

loadThisOntoStack(mv);

mv.visitTypeInsn(Opcodes.NEW, internalName);

mv.visitInsn(Opcodes.DUP);

mv.visitMethodInsn(Opcodes.INVOKESPECIAL, internalName, "<init>", "()V", false);

mv.visitFieldInsn(Opcodes.PUTFIELD, className, "cache", Type.getDescriptor(ArrayList.class));

}

}

/**

public int nextLocalVariableSlot = 5;

/**

public int allocateLocalVariableSlot()

{

return nextLocalVariableSlot++;

}

public final List<Expression<?, ?, ?>> downstreamExpressions = new ArrayList<>();

public Expression<?, ?, ?> registerDownstreamExpression(Expression<?, ?, ?> child)

{

child.upstreamExpression = this;

downstreamExpressions.add(child);

return child;

}

public String typeString()

{

String var = getIndependentVariable() != null ? getIndependentVariable().getName() : "?";

if (!downstreamExpressions.isEmpty())

{

String inner = downstreamExpressions.stream().map(Expression::typeString).collect(java.util.stream.Collectors.joining(", "));

return format("%s:%s=%s➔(%s=%s)", functionClass.getSimpleName(), var, domainType.getSimpleName(), coDomainType.getSimpleName(), inner);

}

return format("%s:%s=%s➔%s", functionClass.getSimpleName(), var, domainType.getSimpleName(), coDomainType.getSimpleName());

}

/**

public String nestedTypeString()

{

LinkedList<Expression<?, ?, ?>> chain = new LinkedList<>();

Expression<?, ?, ?> cursor = this;

while (cursor != null)

{

chain.addFirst(cursor);

cursor = cursor.upstreamExpression;

}

for (int i = 0; i < chain.size() - 1; i++)

{

var upstream = chain.get(i);

var downstream = chain.get(i + 1);

assert upstream.coDomainType

== downstream.domainType : format("type mismatch at nesting level %d: upstream codomain %s is not assignable from downstream domain %s",

i,

upstream.coDomainType.getSimpleName(),

downstream.domainType.getSimpleName());

}

StringBuilder sb = new StringBuilder();

int openParens = 0;

for (var expr : chain)

{

String domain = expr.domainType.getSimpleName();

String var = expr.getIndependentVariable() != null ? expr.getIndependentVariable().getName() : "?";

String f = expr.functionClass.getSimpleName();

sb.append(format("%s:%s=%s➔", f, var, domain));

if (expr.isGeneratedFunctional())

{

sb.append('(').append(expr.coDomainType.getSimpleName()).append('=');

openParens++;

}

else

{

sb.append(expr.coDomainType.getSimpleName());

}

}

for (int i = 0; i < openParens; i++)

{

sb.append(')');

}

return sb.toString();

}

/**

private VariableNode<D, C, F> placeholderVariable;

public boolean deferVariableResolution = false;

public Stream<VariableNode<D, C, F>> variableNodeStream()

{

return rootNode.variableNodeStream();

}

protected VariableNode<D, C, F> newVariable(int startPos, VariableReference<D, C, F> reference)

{

return new VariableNode<D, C, F>(this,

reference,

!deferVariableResolution);

}

/**

@SuppressWarnings("unchecked")

public Expression<D, C, F> inlineFunction(String functionName)

{

if (context == null)

{

throw new IllegalArgumentException("expression has no context");

}

Expression<D, C, F> definingExpression = context.getFunctionExpression(functionName);

Node<D, C, F> body = definingExpression.rootNode.spliceInto(this);

rootNode = rootNode.substitute(functionName, body);

updateStringRepresentation();

return this;

}

private static String ASSERTION_ERROR_METHOD_DESCRIPTOR = Compiler.getMethodDescriptor(Void.class, Object.class);

private static final char COMBINING_DOT_ABOVE = '\u0307';

private static final char COMBINING_TWO_DOTS_ABOVE = '\u0308';

public static Class<?>[] implementedInterfaces = new Class[]

{ Typesettable.class, AutoCloseable.class, Initializable.class, Named.class };

public static String IS_INITIALIZED = "isInitialized";

private static String JAVA_LANG_ASSERTION_ERROR = "java/lang/AssertionError";

public static String nameOfInitializerFunction = "initialize";

private static boolean saveClasses = Boolean.valueOf(System.getProperty("arb4j.saveClasses", "false"));

private static boolean decompileClasses = Boolean.valueOf(System.getProperty("arb4j.decompileClasses", "false"));

public static boolean saveGraphs = Boolean.valueOf(System.getProperty("arb4j.saveGraphs", "false"));

public static boolean trace = Boolean.valueOf(System.getProperty("arb4j.trace", "false"));

public static boolean traceNodes = Boolean.valueOf(System.getProperty("arb4j.traceNodes", "false"));

public static String VOID_METHOD_DESCRIPTOR = Compiler.getMethodDescriptor(Void.class);

static

{

assert arb.functions.integer.Sequence.class.equals(Sequence.class) : "you forgot to import arb.functions.sequences.Sequence or imported a class named sequence in another package";

}

public File compiledClassDir = new File("compiled");

public Expression<?, ?, ?> upstreamExpression;

public char character = 0;

public String className;

public Class<? extends C> coDomainType;

public Class<F> compiledClass;

HashMap<Class<?>, AtomicInteger> constantCounts = new HashMap<>();

public Context context;

HashSet<String> declaredIntermediateVariables = new HashSet<>();

public List<Dependency> dependencies;

public Class<? extends D> domainType;

public String expression;

public boolean functionalDependsOnIndependentVariable;

private VariableNode<Object, Object, Function<?, ?>> functionalIndependentVariable;

public Class<? extends F> functionClass;

public String functionClassDescriptor;

public String functionName;

public String genericFunctionClassInternalName;

public boolean inAbsoluteValue = false;

private VariableNode<D, C, F> independentVariable;

int currentLevel = 0;

public LinkedList<Consumer<MethodVisitor>> initializers = new LinkedList<>();

public boolean insideInitializer = false;

protected F instance;

public byte[] instructions;

public HashMap<String, IntermediateVariable<D, C, F>> intermediateVariables = new HashMap<>();

private ArrayList<LiteralConstantNode<D, C, F>> literalConstantNodes;

public HashMap<String, LiteralConstantNode<D, C, F>> literalConstants = new HashMap<>();

private final Logger log = LoggerFactory.getLogger(Expression.class);

public FunctionMapping<D, C, F> functionMapping;

public int position = -1;

public char previousCharacter;

public record CursorState(int position, char character, char previousCharacter)

{

}

public CursorState saveCursor()

{

return new CursorState(position,

character,

previousCharacter);

}

public void restoreCursor(CursorState state)

{

position = state.position();

character = state.character();

previousCharacter = state.previousCharacter();

}

public boolean recursive = false;

private final HashMap<String, FunctionMapping<?, ?, ?>> referencedFunctions = new HashMap<>();

private HashMap<String, VariableNode<D, C, F>> referencedVariables = new HashMap<>();

public Node<D, C, F> rootNode;

public boolean variablesDeclared = false;

public boolean acceptUntil(Predicate<Expression<?, ?, ?>> visitor)

{

Expression<?, ?, ?> e = this;

while (e != null)

{

if (visitor.test(e))

{

return true;

}

e = e.upstreamExpression;

}

return false;

}

public Expression(Class<? extends D> domain, Class<? extends C> coDomain, Class<? extends F> function)

{

this.upstreamExpression = null;

this.domainType = domain;

this.coDomainType = coDomain;

this.functionClass = function;

this.genericFunctionClassInternalName = Type.getInternalName(function);

this.functionClassDescriptor = function.descriptorString();

if (context != null && context.saveClasses)

{

saveClasses = true;

}

if (Expression.trace)

{

log.debug("#{}: new Expression(domain={}, coDomain={}, function={})", System.identityHashCode(this), domain, coDomain, function);

}

}

public Expression(String className,

Class<? extends D> domainClass,

Class<? extends C> coDomainClass,

Class<? extends F> functionClass,

String expressionString,

Context context)

{

this(className,

domainClass,

coDomainClass,

functionClass,

expressionString,

context,

null,

null);

}

public Expression(String className,

Class<? extends D> domain,

Class<? extends C> codomain,

Class<? extends F> function,

String expression,

Context context,

String functionName,

Expression<?, ?, ?> ascenentExpression)

{

assert className != null : "className needs to be specified";

this.upstreamExpression = ascenentExpression;

this.className = className;

this.domainType = domain;

this.coDomainType = codomain;

this.functionClass = function;

this.genericFunctionClassInternalName = Type.getInternalName(function);

this.functionClassDescriptor = function.descriptorString();

this.setExpression(Parser.normalize(expression));

this.context = context;

this.functionName = functionName;

if (context != null && context.saveClasses)

{

saveClasses = true;

}

if (Expression.trace)

{

log.debug("#{}: new Expression(className={}, domain={}, coDomain={}, function={}, expression={}, context={}, functionName={}, upstreamExpression={}#{})",

System.identityHashCode(this),

className,

domain,

codomain,

function,

expression,

context,

functionName,

ascenentExpression,

System.identityHashCode(ascenentExpression));

}

}

protected Node<D, C, F> addAndSubtract(Node<D, C, F> node)

{

while (true)

{

if (nextCharacterRepresentsAddition())

{

node = node.add(exponentiateMultiplyAndDivide());

}

else if (nextCharacterRepresentsSubtraction())

{

var rhs = exponentiateMultiplyAndDivide();

assert rhs != null : "rhs is null for node=" + node + " in " + this;

node = node == null ? rhs.neg() : node.sub(rhs);

}

else

{

return node;

}

}

}

protected void addCheckForNullField(MethodVisitor mv, String varName, boolean variable)

{

Class<?> fieldClass;

if (variable)

{

Object field = context.getVariable(varName);

fieldClass = field != null ? field.getClass() : null;

}

else

{

fieldClass = context.functions.get(varName).type();

}

if (fieldClass != null)

{

addNullCheckForField(mv, className, varName, fieldClass.descriptorString());

}

}

protected void addChecksForNullVariableReferences(MethodVisitor mv)

{

if (context != null)

{

context.variableClassStream()

.filter(event -> referencedVariables.containsKey(event.getLeft()))

.forEach(entry -> addCheckForNullField(loadThisOntoStack(mv), entry.getLeft(), true));

}

}

public String allocateIntermediateVariable(MethodVisitor methodVisitor, Class<?> type)

{

Class<?> actualType = type.isInterface() ? scalarType(type) : type;

String intermediateVariableName = newIntermediateVariable(actualType);

assert intermediateVariableName != null : "intermediateVariableName is null for type " + type;

loadThisAndFieldOntoStack(methodVisitor, intermediateVariableName, actualType);

return intermediateVariableName;

}

public String allocateIntermediateVariable(MethodVisitor methodVisitor, String prefix, Class<?> type)

{

Class<?> actualType = type.isInterface() ? scalarType(type) : type;

String intermediateVariableName = newIntermediateVariable(prefix, actualType);

loadFieldOntoStack(loadThisOntoStack(methodVisitor), intermediateVariableName, actualType.descriptorString());

return intermediateVariableName;

}

public VariableNode<?, ?, ?> getIndependentVariableNamed(String name)

{

if (getIndependentVariable() != null && getIndependentVariable().getName().equals(name))

{

return getIndependentVariable();

}

if (upstreamExpression != null)

{

var immediatelyUpstreamIndependentVariable = upstreamExpression.getIndependentVariable();

if (immediatelyUpstreamIndependentVariable != null)

{

return immediatelyUpstreamIndependentVariable;

}

}

return null;

}

public boolean thisOrAnyUpstreamIndependentVariableIsNamed(String name)

{

if (getIndependentVariable() != null && getIndependentVariable().getName().equals(name))

{

return true;

}

return anyUpstreamIndependentVariableIsNamed(name);

}

public boolean anyUpstreamIndependentVariableIsNamed(String name)

{

if (upstreamExpression != null)

{

if (upstreamExpression.thisOrAnyUpstreamIndependentVariableIsNamed(name))

{

return true;

}

}

return false;

}

/**

public VariableNode<D, C, F> assignInputVariable(VariableNode<D, C, F> variable)

{

assert variable != null : "variable shan't be null";

if (canHaveIndependentVariable())

{

if (getIndependentVariable() != null)

{

if (!getIndependentVariable().equals(variable))

{

throw new CompilerException(String.format("undefined variable reference '%s' at position=%s in expression '%s' "

+ "since the independent variable has already been declared to be '%s' in %s",

variable,

position,

toStringExtended(),

getIndependentVariable(),

toStringExtended()));

}

else

{

return variable;

}

}

setIndependentVariable(variable);

getIndependentVariable().isIndependent = true;

getIndependentVariable().reference.type = domainType;

return variable;

}

else

{

if (!canHavePlaceholder())

{

throw new IllegalArgumentException(this.toStringExtended()

+ " cannot have a placeholder or an independent variable so it cant be set to "

+ variable

+ " for "

+ expression

+ " that has type "

+ getTypeString());

}

var placeholder = setPlaceholderVariable(variable);

placeholder.reference.type = coDomainType;

return placeholder;

}

}

protected void assureInputNameHasNotAlreadyBeenAssociatedWithAContextVariable(String inputVariableName)

{

if (context != null)

{

if (context.getVariable(inputVariableName) != null)

{

throw new CompilerException(inputVariableName + " cannot be declared as the input since it is already registered as a context variable in " + context);

}

}

}

protected boolean characterAfterNextIs(char ch)

{

return position + 1 < getExpression().length() && getExpression().charAt(position + 1) == ch;

}

@Override

protected Object clone()

{

var expr = new Expression<D, C, F>(className,

domainType,

coDomainType,

functionClass,

getExpression(),

context,

functionName,

upstreamExpression);

expr.context = context;

expr.setIndependentVariable(independentVariable);

expr.position = position;

expr.character = character;

expr.previousCharacter = previousCharacter;

expr.placeholderVariable = placeholderVariable;

return expr;

}

@SuppressWarnings("unchecked")

public Expression<D, C, F> cloneExpression()

{

return (Expression<D, C, F>) clone();

}

public Expression<D, C, F> compile()

{

if (compiledClass != null)

{

return this;

}

if (context == null)

{

context = new Context();

}

if (trace)

{

log.debug(String.format("#%s: compile(expression=%s, className=%s, context=%s)\n", System.identityHashCode(this), getExpression(), className, context));

}

if (instructions == null)

{

generate();

}

assert context != null : "context is null for "

+ this

+ " and upstreamExpression="

+ upstreamExpression

+ " upstreamExpression.context="

+ upstreamExpression.context;

compiledClass = loadFunctionClass(className, instructions, context);

return this;

}

protected void constructReferencedFunctionInstanceIfItIsNull(MethodVisitor mv, FunctionMapping<?, ?, ?> mapping)

{

assert mapping != null : "mapping shan't be null";

if ((mapping.functionName == null || functionName == null || !functionName.equals(mapping.functionName)) && mapping.expression != null)

{

Class<?> type = mapping.type();

if (type == null || type.isInterface())

{

mapping.instantiate();

type = mapping.type();

}

assert type != null : "type is null for mapping=" + mapping;

var alreadyInitialized = new Label();

loadThisOntoStack(mv).visitFieldInsn(GETFIELD, className, mapping.functionName, mapping.functionFieldDescriptor());

mv.visitJumpInsn(Opcodes.IFNONNULL, alreadyInitialized);

loadThisOntoStack(mv);

generateNewObjectInstruction(mv, type);

duplicateTopOfTheStack(mv);

invokeDefaultConstructor(mv, type);

putField(mv, className, mapping.functionName, type);

mv.visitLabel(alreadyInitialized);

}

}

public VariableNode<D, C, F> newVariableNode(String inputVariableName)

{

return new VariableNode<>(this,

newVariableReference(inputVariableName),

!deferVariableResolution);

}

public VariableReference<D, C, F> newVariableReference(String inputVariableName)

{

return new VariableReference<>(inputVariableName,

null,

coDomainType);

}

private ClassVisitor declareContext(ClassVisitor cw)

{

Class<?> type = Context.class;

String typeDescriptor = type.descriptorString();

cw.visitField(ACC_PUBLIC, "context", typeDescriptor, null, null);

return cw;

}

protected MethodVisitor declareEvaluateMethodArguments(MethodVisitor methodVisitor, Label startLabel, Label endLabel)

{

methodVisitor.visitLocalVariable("this", String.format("L%s;", className), null, startLabel, endLabel, 0);

methodVisitor.visitLocalVariable(getIndependentVariable() != null ? getIndependentVariable().getName()

: "in",

domainType.descriptorString(),

null,

startLabel,

endLabel,

1);

methodVisitor.visitLocalVariable("order", "I", null, startLabel, endLabel, 2);

methodVisitor.visitLocalVariable("bits", "I", null, startLabel, endLabel, 3);

methodVisitor.visitLocalVariable("result", coDomainType.descriptorString(), null, startLabel, endLabel, 4);

return methodVisitor;

}

protected void declareFields(ClassVisitor cw)

{

cw.visitField(Opcodes.ACC_PUBLIC, IS_INITIALIZED, "Z", null, null);

declareContext(cw);

declareCacheField(cw);

if (!coDomainType.isInterface())

{

declareLiteralConstants(cw);

declareIntermediateVariables(cw);

}

declareFunctionReferences(cw);

declareVariables(cw);

}

protected ClassVisitor declareFunctionReferences(ClassVisitor classVisitor)

{

if (context == null)

{

return classVisitor;

}

context.populateFunctionReferenceGraph();

dependencies = Utensils.sortDependencies(context.functionReferenceGraph, getReferencedFunctions());

if (saveGraphs)

{

context.saveDependencyGraph(dependencies);

}

// Declare functions in dependency order

for (Dependency dependency : dependencies)

{

String dependencyVariableName = dependency.variableName;

var functionMapping = getReferencedFunctions().get(dependencyVariableName);

if (functionMapping != null)

{

functionMapping.declare(classVisitor, dependencyVariableName);

}

}

return classVisitor;

}

protected void declareIntermediateVariables(ClassVisitor classVisitor)

{

sortedIntermediateVariableStream().filter(variable -> !declaredIntermediateVariables.contains(variable.name)).forEach(variable ->

{

variable.declareField(classVisitor);

declaredIntermediateVariables.add(variable.name);

});

}

protected ClassVisitor declareLiteralConstants(ClassVisitor classVisitor)

{

for (var constant : getSortedLiteralConstantNodes())

{

constant.declareField(classVisitor);

}

return classVisitor;

}

protected void declareVariableEntry(ClassVisitor classVisitor, Entry<String, Named> variable)

{

if (trace)

{

log.trace("Declaring variable of " + className + ": " + variable);

}

if (variable.getValue() != null)

{

String varName = variable.getKey();

if (!declaredVariables.contains(varName))

{

classVisitor.visitField(ACC_PUBLIC, varName, variable.getValue().getClass().descriptorString(), null, null);

declaredVariables.add(varName);

}

}

else

{

if (trace)

{

log.trace("Skipping null variable of " + className + ": " + variable);

}

}

}

/**

protected void declareVariables(ClassVisitor classVisitor)

{

// Declare the parent's independent variable as a field so we can receive it

if (upstreamExpression != null)

{

var upstreamIndependentVariableNode = upstreamExpression.getIndependentVariable();

if (upstreamIndependentVariableNode != null && !upstreamIndependentVariableNode.type().equals(Object.class))

{

String upstreamIndVarName = upstreamIndependentVariableNode.reference.name;

classVisitor.visitField(ACC_PUBLIC, upstreamIndVarName, upstreamIndependentVariableNode.type().descriptorString(), null, null);

declaredVariables.add(upstreamIndVarName);

}

}

// Declare fields for all referenced variables from ancestor expressions

// These are variables where upstreamInput=true that were added to

// referencedVariables

declareFieldsForUpstreamInputPropagation(classVisitor);

// Declare context variables

if (context != null)

{

var varList = context.variableEntryStream().sorted((a, b) -> a.getKey().compareTo(b.getKey())).toList();

if (trace)

{

String vars = varList.stream().map(f -> f.getKey()).collect(Collectors.joining(","));

log.debug("declareVariables for {}: context variables {}", className, vars);

}

for (var variable : varList)

{

declareVariableEntry(classVisitor, variable);

}

}

variablesDeclared = true;

}

protected void declareFieldsForUpstreamInputPropagation(ClassVisitor classVisitor)

{

upstreamInputVariableEntryStream().forEach(entry ->

{

String varName = entry.getKey();

VariableNode<D, C, F> varNode = entry.getValue();

Class<?> varType = varNode.type();

assert varType != null && !varType.equals(Object.class) : "type of " + varNode + " should not be Object or null";

if (declaredVariables.contains(varName))

{

return;

}

if (trace)

{

log.debug("declareVariables for {}: declaring upstreamInput variable {} of type {}", className, varName, varType);

}

Compiler.declareField(classVisitor, varName, varType);

declaredVariables.add(varName);

});

}

Predicate<? super Entry<String, VariableNode<D, C, F>>> predicate = entry ->

{

String varName = entry.getKey();

VariableNode<D, C, F> varNode = entry.getValue();

if (varNode.isIndependent)

{

return false;

}

if (upstreamExpression != null)

{

VariableNode<?, ?, ?> upstreamIndependentVariable = upstreamExpression.getIndependentVariable();

if (upstreamIndependentVariable != null && varName.equals(upstreamIndependentVariable.getName()))

{