avail/avail.descriptor.methods/MethodDescriptor

MethodDescriptor

A method maintains all A_Definitions that have the same name. At compile time a name is looked up and the corresponding method is stored as a literal in the object code for a call site. At runtime, the actual function is located within the method and then invoked. The methods also keep track of bidirectional dependencies, so that a change of membership (e.g., adding a method definition) causes an immediate invalidation of optimized level two code that depends on the previous membership.

Methods and macros are stored in separate tuples. Note that macros may be polymorphic (multiple definitions), and a lookup structure is used at compile time to decide which macro is most specific.

Author

Mark van Gulik

Todd L Smith

Parameters

mutability

The Mutability of the resulting descriptor. This should only be Mutability.MUTABLE for the initialMutableDescriptor, and Mutability.SHARED for normal instances.

Types

Companion

object Companion

IntegerSlots

enum IntegerSlots : Enum<MethodDescriptor.IntegerSlots> , IntegerSlotsEnum

The layout of integer slots for my instances.

ObjectSlots

enum ObjectSlots : Enum<MethodDescriptor.ObjectSlots> , ObjectSlotsEnum

The fields that are of type AvailObject.

SpecialMethodAtom

enum SpecialMethodAtom : Enum<MethodDescriptor.SpecialMethodAtom>

SpecialMethodAtom enumerates atoms that are known to the virtual machine and that correspond to specific primitive invocations. Multiple primitives may be provided to make the associated method polymorphic.

Functions

checkWriteForField

fun checkWriteForField(e: AbstractSlotsEnum)

Ensure that the specified field is writable.

create

inline fun create(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit = { }): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

createImmutable

inline fun createImmutable(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

createShared

inline fun createShared(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

dynamicLookupStats

fun dynamicLookupStats(): LookupStatistics

Answer the LookupStatistics that tracks dynamic lookups, involving type testing within a LookupTree. By the time the first one occurs, a bundle will have been set.

hasVariableIntegerSlots

fun hasVariableIntegerSlots(): Boolean

Can an object using this descriptor have more than the minimum number of integer slots?

hasVariableObjectSlots

fun hasVariableObjectSlots(): Boolean

Can an object using this descriptor have more than the minimum number of object slots?

immutable

~~open~~ ~~override~~ ~~fun~~ ~~immutable~~(): Nothing

Answer the immutable version of this descriptor.

maximumIndent

open fun maximumIndent(): Int

Answer how many levels of printing to allow before elision.

mutable

~~open~~ ~~override~~ ~~fun~~ ~~mutable~~(): Nothing

Answer the mutable version of this descriptor.

o_AcceptsArgTypesFromFunctionType

open override fun o_AcceptsArgTypesFromFunctionType(self: AvailObject, functionType: A_Type): Boolean

Answer whether the argument types supported by the specified FunctionTypeDescriptor are acceptable argument types for invoking a FunctionDescriptor whose type is self.

o_AcceptsListOfArgTypes

open override fun o_AcceptsListOfArgTypes(self: AvailObject, argTypes: List<A_Type>): Boolean

Answer whether these are acceptable TypeDescriptor for invoking a FunctionDescriptor whose type is self.

o_AcceptsListOfArgValues

open override fun o_AcceptsListOfArgValues(self: AvailObject, argValues: List<A_BasicObject>): Boolean

Answer whether these are acceptable arguments for invoking a FunctionDescriptor whose type is self.

o_AcceptsTupleOfArgTypes

open override fun o_AcceptsTupleOfArgTypes(self: AvailObject, argTypes: A_Tuple): Boolean

Answer whether these are acceptable TypeDescriptor for invoking a FunctionDescriptor that is an instance of self. There may be more entries in the TupleDescriptor than are required by the FunctionTypeDescriptor.

o_AcceptsTupleOfArguments

open override fun o_AcceptsTupleOfArguments(self: AvailObject, arguments: A_Tuple): Boolean

Answer whether these are acceptable arguments for invoking a FunctionDescriptor that is an instance of self. There may be more entries in the TupleDescriptor than are required by the FunctionTypeDescriptor.

o_AddBundle

open override fun o_AddBundle(self: AvailObject, bundle: A_Bundle)

o_AddConstantBinding

open override fun o_AddConstantBinding( self: AvailObject, name: A_String, constantBinding: A_Variable)

o_AddDefinitionParsingPlan

open override fun o_AddDefinitionParsingPlan(self: AvailObject, plan: A_DefinitionParsingPlan)

o_AddDependentChunk

open override fun o_AddDependentChunk(self: AvailObject, chunk: L2Chunk)

Record the fact that the given L2Chunk depends on the object not changing in some way peculiar to the kind of object. Most typically, this is applied to A_Methods, triggering invalidation if A_Definitions are added to or removed from the method, but at some point we may also support slowly-changing variables.

o_AddGrammaticalRestriction

open override fun o_AddGrammaticalRestriction(self: AvailObject, grammaticalRestriction: A_GrammaticalRestriction)

o_AddImportedName

open override fun o_AddImportedName(self: AvailObject, trueName: A_Atom)

o_AddImportedNames

open override fun o_AddImportedNames(self: AvailObject, trueNames: A_Set)

o_AddLexer

open override fun o_AddLexer(self: AvailObject, lexer: A_Lexer)

o_AddPlanInProgress

open override fun o_AddPlanInProgress(self: AvailObject, planInProgress: A_ParsingPlanInProgress)

o_AddPrivateName

open override fun o_AddPrivateName(self: AvailObject, trueName: A_Atom)

o_AddPrivateNames

open override fun o_AddPrivateNames(self: AvailObject, trueNames: A_Set)

o_AddSeal

open override fun o_AddSeal( self: AvailObject, methodName: A_Atom, argumentTypes: A_Tuple)

o_AddSealedArgumentsType

open override fun o_AddSealedArgumentsType(self: AvailObject, typeTuple: A_Tuple)

o_AddSemanticRestriction

open override fun o_AddSemanticRestriction(self: AvailObject, restriction: A_SemanticRestriction)

o_AddToDoubleCanDestroy

open override fun o_AddToDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_AddToFloatCanDestroy

open override fun o_AddToFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_AddToInfinityCanDestroy

open override fun o_AddToInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_AddToIntegerCanDestroy

open override fun o_AddToIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_AddUnloadFunction

open override fun o_AddUnloadFunction(self: AvailObject, unloadFunction: A_Function)

o_AddVariableBinding

open override fun o_AddVariableBinding( self: AvailObject, name: A_String, variableBinding: A_Variable)

o_AddWriteReactor

open override fun o_AddWriteReactor( self: AvailObject, key: A_Atom, reactor: VariableDescriptor.VariableAccessReactor)

o_AdjustPcAndStackp

open override fun o_AdjustPcAndStackp( self: AvailObject, pc: Int, stackp: Int)

o_AllAncestors

open override fun o_AllAncestors(self: AvailObject): A_Set

o_AllParsingPlansInProgress

open override fun o_AllParsingPlansInProgress(self: AvailObject): A_Map

o_ApparentSendName

open override fun o_ApparentSendName(self: AvailObject): A_Atom

o_AppendCanDestroy

open override fun o_AppendCanDestroy( self: AvailObject, newElement: A_BasicObject, canDestroy: Boolean): A_Tuple

o_ApplyModuleHeader

open override fun o_ApplyModuleHeader( self: AvailObject, loader: AvailLoader, moduleHeader: ModuleHeader): String?

o_ApplyStylesThen

open override fun o_ApplyStylesThen( self: AvailObject, context: CompilationContext, visitedSet: MutableSet<A_Phrase>, then: () -> Unit)

o_ArgsTupleType

open override fun o_ArgsTupleType(self: AvailObject): A_Type

o_ArgumentRestrictionSets

open override fun o_ArgumentRestrictionSets(self: AvailObject): A_Tuple

o_ArgumentsListNode

open override fun o_ArgumentsListNode(self: AvailObject): A_Phrase

o_ArgumentsTuple

open override fun o_ArgumentsTuple(self: AvailObject): A_Tuple

o_AsBigInteger

open override fun o_AsBigInteger(self: AvailObject): BigInteger

o_AsNativeString

open override fun o_AsNativeString(self: AvailObject): String

Construct a Java string from the given Avail StringDescriptor.

o_AsSet

open override fun o_AsSet(self: AvailObject): A_Set

Construct a Java set from the given TupleDescriptor.

o_AsTuple

open override fun o_AsTuple(self: AvailObject): A_Tuple

Construct a TupleDescriptor from the given SetDescriptor. Element ordering in the tuple will be arbitrary and unstable.

o_AtomicAddToMap

open override fun o_AtomicAddToMap( self: AvailObject, key: A_BasicObject, value: A_BasicObject)

o_AtomicRemoveFromMap

open override fun o_AtomicRemoveFromMap(self: AvailObject, key: A_BasicObject)

o_AtomName

open override fun o_AtomName(self: AvailObject): A_String

o_AvailLoader

open override fun o_AvailLoader(self: AvailObject): AvailLoader?

o_BinElementAt

open override fun o_BinElementAt(self: AvailObject, index: Int): AvailObject

o_BinElementsAreAllInstancesOfKind

open override fun o_BinElementsAreAllInstancesOfKind(self: AvailObject, kind: A_Type): Boolean

o_BinHasElementWithHash

open override fun o_BinHasElementWithHash( self: AvailObject, elementObject: A_BasicObject, elementObjectHash: Int): Boolean

o_BinUnionKind

open override fun o_BinUnionKind(self: AvailObject): A_Type

o_BitSet

open override fun o_BitSet( self: AvailObject, bitPosition: Int, value: Boolean, canDestroy: Boolean): A_Number

o_BitShift

open override fun o_BitShift( self: AvailObject, shiftFactor: A_Number, canDestroy: Boolean): A_Number

o_BitShiftLeftTruncatingToBits

open override fun o_BitShiftLeftTruncatingToBits( self: AvailObject, shiftFactor: A_Number, truncationBits: A_Number, canDestroy: Boolean): A_Number

o_BitsPerEntry

open override fun o_BitsPerEntry(self: AvailObject): Int

o_BitTest

open override fun o_BitTest(self: AvailObject, bitPosition: Int): Boolean

o_BitwiseAnd

open override fun o_BitwiseAnd( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BitwiseOr

open override fun o_BitwiseOr( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BitwiseXor

open override fun o_BitwiseXor( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BodyBlock

open override fun o_BodyBlock(self: AvailObject): A_Function

o_BodySignature

open override fun o_BodySignature(self: AvailObject): A_Type

o_BuildFilteredBundleTree

open override fun o_BuildFilteredBundleTree(self: AvailObject): A_BundleTree

o_Bundle

open override fun o_Bundle(self: AvailObject): A_Bundle

o_BundleAddMacro

open override fun o_BundleAddMacro( self: AvailObject, macro: A_Macro, ignoreSeals: Boolean)

o_BundleMethod

open override fun o_BundleMethod(self: AvailObject): A_Method

o_BundleOrCreate

open override fun o_BundleOrCreate(self: AvailObject): A_Bundle

o_BundleOrNil

open override fun o_BundleOrNil(self: AvailObject): A_Bundle

o_Bundles

open override fun o_Bundles(self: AvailObject): A_Set

o_ByteArray

open override fun o_ByteArray(self: AvailObject): ByteArray

o_ByteBuffer

open override fun o_ByteBuffer(self: AvailObject): ByteBuffer

o_Caller

open override fun o_Caller(self: AvailObject): A_Continuation

o_CaptureInDebugger

open override fun o_CaptureInDebugger(self: AvailObject, debugger: AvailDebuggerModel)

o_ChildAt

open override fun o_ChildAt(self: AvailObject, childIndex: Int): A_Tuple

o_ChildCount

open override fun o_ChildCount(self: AvailObject): Int

o_ChildrenDo

open override fun o_ChildrenDo(self: AvailObject, action: (A_Phrase) -> Unit)

Visit my child phrases with the action.

o_ChildrenMap

open override fun o_ChildrenMap(self: AvailObject, transformer: (A_Phrase) -> A_Phrase)

Map my children through the (destructive) transformation specified by aBlock.

o_ChooseBundle

open override fun o_ChooseBundle(self: AvailObject, currentModule: A_Module): A_Bundle

o_ClearGeneralFlag

open override fun o_ClearGeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag)

o_ClearLexingState

open override fun o_ClearLexingState(self: AvailObject)

o_ClearTraceFlag

open override fun o_ClearTraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag)

o_ClearValue

open override fun o_ClearValue(self: AvailObject)

o_Code

open override fun o_Code(self: AvailObject): A_RawFunction

o_CodePoint

open override fun o_CodePoint(self: AvailObject): Int

o_CompareAndSwapValues

open override fun o_CompareAndSwapValues( self: AvailObject, reference: A_BasicObject, newValue: A_BasicObject): Boolean

o_CompareAndSwapValuesNoCheck

open override fun o_CompareAndSwapValuesNoCheck( self: AvailObject, reference: A_BasicObject, newValue: A_BasicObject): Boolean

o_CompareFromToWithAnyTupleStartingAt

open override fun o_CompareFromToWithAnyTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given TupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithByteArrayTupleStartingAt

open override fun o_CompareFromToWithByteArrayTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteArrayTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithByteBufferTupleStartingAt

open override fun o_CompareFromToWithByteBufferTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteBufferTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithByteStringStartingAt

open override fun o_CompareFromToWithByteStringStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteString: A_String, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given ByteStringDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithByteTupleStartingAt

open override fun o_CompareFromToWithByteTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given ByteTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithIntegerIntervalTupleStartingAt

open override fun o_CompareFromToWithIntegerIntervalTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anIntegerIntervalTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given IntegerIntervalTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithIntTupleStartingAt

open override fun o_CompareFromToWithIntTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anIntTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithNybbleTupleStartingAt

open override fun o_CompareFromToWithNybbleTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aNybbleTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given NybbleTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithObjectTupleStartingAt

open override fun o_CompareFromToWithObjectTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anObjectTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given ObjectTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithRepeatedElementTupleStartingAt

open override fun o_CompareFromToWithRepeatedElementTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aRepeatedElementTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given RepeatedElementTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithSmallIntegerIntervalTupleStartingAt

open override fun o_CompareFromToWithSmallIntegerIntervalTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aSmallIntegerIntervalTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given SmallIntegerIntervalTupleDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithStartingAt

open override fun o_CompareFromToWithStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anotherObject: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of another object. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithTwoByteStringStartingAt

open override fun o_CompareFromToWithTwoByteStringStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aTwoByteString: A_String, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given TwoByteStringDescriptor. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_ComputeHashFromTo

open override fun o_ComputeHashFromTo( self: AvailObject, start: Int, end: Int): Int

o_ComputeInstanceTag

open override fun o_ComputeInstanceTag(self: AvailObject): TypeTag

o_ComputeSuperkind

open override fun o_ComputeSuperkind(self: AvailObject): A_Type

o_ComputeTypeTag

open override fun o_ComputeTypeTag(self: AvailObject): TypeTag

Compute this object's TypeTag, having failed to extract it from the descriptor directly in AvailObjectRepresentation.typeTag.

o_ConcatenateTuplesCanDestroy

open override fun o_ConcatenateTuplesCanDestroy(self: AvailObject, canDestroy: Boolean): A_Tuple

o_ConcatenateWith

open override fun o_ConcatenateWith( self: AvailObject, otherTuple: A_Tuple, canDestroy: Boolean): A_Tuple

o_ConstantBindings

open override fun o_ConstantBindings(self: AvailObject): A_Map

o_ConstantTypeAt

open override fun o_ConstantTypeAt(self: AvailObject, index: Int): A_Type

o_ContentType

open override fun o_ContentType(self: AvailObject): A_Type

o_Continuation

open override fun o_Continuation(self: AvailObject): A_Continuation

o_CopyAsMutableIntTuple

open override fun o_CopyAsMutableIntTuple(self: AvailObject): A_Tuple

o_CopyAsMutableLongTuple

open override fun o_CopyAsMutableLongTuple(self: AvailObject): A_Tuple

o_CopyAsMutableObjectTuple

open override fun o_CopyAsMutableObjectTuple(self: AvailObject): A_Tuple

o_CopyConcatenating

open override fun o_CopyConcatenating(self: AvailObject, newListPhrase: A_Phrase): A_Phrase

o_CopyMutablePhrase

open override fun o_CopyMutablePhrase(self: AvailObject): A_Phrase

o_CopyTupleFromToCanDestroy

open override fun o_CopyTupleFromToCanDestroy( self: AvailObject, start: Int, end: Int, canDestroy: Boolean): A_Tuple

o_CopyWith

open override fun o_CopyWith(self: AvailObject, newPhrase: A_Phrase): A_Phrase

o_CouldEverBeInvokedWith

open override fun o_CouldEverBeInvokedWith(self: AvailObject, argRestrictions: List<TypeRestriction>): Boolean

o_CountdownToReoptimize

open override fun o_CountdownToReoptimize(self: AvailObject, value: Long)

o_CreateLexicalScanner

open override fun o_CreateLexicalScanner(self: AvailObject): LexicalScanner

o_CurrentLexer

open override fun o_CurrentLexer(self: AvailObject): A_Lexer

o_CurrentLineNumber

open override fun o_CurrentLineNumber(self: AvailObject, topFrame: Boolean): Int

o_DebugLog

open override fun o_DebugLog(self: AvailObject): StringBuilder

Answer a fiber's internal debug log.

o_Declaration

open override fun o_Declaration(self: AvailObject): A_Phrase

o_DeclarationKind

open override fun o_DeclarationKind(self: AvailObject): DeclarationPhraseDescriptor.DeclarationKind

o_DeclarationNames

open override fun o_DeclarationNames(self: AvailObject): A_Tuple

o_DeclaredExceptions

open override fun o_DeclaredExceptions(self: AvailObject): A_Set

o_DeclaredType

open override fun o_DeclaredType(self: AvailObject): A_Type

o_DecreaseCountdownToReoptimizeFromPoll

open override fun o_DecreaseCountdownToReoptimizeFromPoll(self: AvailObject, delta: Long)

o_DecrementCountdownToReoptimize

open override fun o_DecrementCountdownToReoptimize(self: AvailObject, continuation: (Boolean) -> Unit): Boolean

o_DefaultType

open override fun o_DefaultType(self: AvailObject): A_Type

o_Definition

open override fun o_Definition(self: AvailObject): A_Definition

o_DefinitionBundle

open override fun o_DefinitionBundle(self: AvailObject): A_Bundle

o_DefinitionMethod

open override fun o_DefinitionMethod(self: AvailObject): A_Method

o_DefinitionModule

open override fun o_DefinitionModule(self: AvailObject): A_Module

o_DefinitionModuleName

open override fun o_DefinitionModuleName(self: AvailObject): A_String

o_DefinitionParsingPlans

open override fun o_DefinitionParsingPlans(self: AvailObject): A_Map

o_DefinitionsAtOrBelow

open override fun o_DefinitionsAtOrBelow(self: AvailObject, argRestrictions: List<TypeRestriction>): List<A_Definition>

Look up all method definitions that could match arguments satisfying the given TypeRestrictions. This should return the definitions that could be invoked at runtime at a call site with the given restrictions. This set is subject to change as new methods and types are created. If a restriction and the corresponding argument type of a definition have no possible intersection except bottom (⊥), then disallow the definition (it could never actually be invoked because bottom is uninstantiable). Answer a list of method definitions.

o_DefinitionsTuple

open override fun o_DefinitionsTuple(self: AvailObject): A_Tuple

o_DeoptimizeForDebugger

open override fun o_DeoptimizeForDebugger(self: AvailObject)

o_DescribeForDebugger

open override fun o_DescribeForDebugger(self: AvailObject): Array<AvailObjectFieldHelper>

Describe the object for the IntelliJ debugger.

o_DivideCanDestroy

open override fun o_DivideCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Divide the operands and answer the result.

o_DivideIntoDoubleCanDestroy

open override fun o_DivideIntoDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_DivideIntoFloatCanDestroy

open override fun o_DivideIntoFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_DivideIntoInfinityCanDestroy

open override fun o_DivideIntoInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Divide an infinity with the given sign by the object and answer the result.

o_DivideIntoIntegerCanDestroy

open override fun o_DivideIntoIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Divide the operands and answer the result.

o_EmitAllValuesOn

open override fun o_EmitAllValuesOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EmitEffectOn

open override fun o_EmitEffectOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EmitValueOn

open override fun o_EmitValueOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EnsureMutable

open override fun o_EnsureMutable(self: AvailObject): A_Continuation

o_EntryPoints

open override fun o_EntryPoints(self: AvailObject): A_Map

o_EnumerationIncludesInstance

open override fun o_EnumerationIncludesInstance(self: AvailObject, potentialInstance: AvailObject): Boolean

o_Equals

open override fun o_Equals(self: AvailObject, another: A_BasicObject): Boolean

Answer whether the arguments, both objects, are equal in value.

o_EqualsAnyTuple

open override fun o_EqualsAnyTuple(self: AvailObject, aTuple: A_Tuple): Boolean

Answer whether the arguments, an object and a TupleDescriptor, are equal in value.

o_EqualsByteArrayTuple

open override fun o_EqualsByteArrayTuple(self: AvailObject, aByteArrayTuple: A_Tuple): Boolean

o_EqualsByteBufferTuple

open override fun o_EqualsByteBufferTuple(self: AvailObject, aByteBufferTuple: A_Tuple): Boolean

o_EqualsByteString

open override fun o_EqualsByteString(self: AvailObject, aByteString: A_String): Boolean

Answer whether the arguments, an object and a ByteStringDescriptor, are equal in value.

o_EqualsByteTuple

open override fun o_EqualsByteTuple(self: AvailObject, aByteTuple: A_Tuple): Boolean

Answer whether the arguments, an object, and a ByteTupleDescriptor, are equal in value.

o_EqualsCharacterWithCodePoint

open override fun o_EqualsCharacterWithCodePoint(self: AvailObject, aCodePoint: Int): Boolean

Answer whether the receiver, an object, is a character with a code point equal to the integer argument.

o_EqualsCompiledCode

open override fun o_EqualsCompiledCode(self: AvailObject, aCompiledCode: A_RawFunction): Boolean

Answer whether the arguments, an object and a CompiledCodeDescriptor, are equal.

o_EqualsCompiledCodeType

open override fun o_EqualsCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): Boolean

o_EqualsContinuation

open override fun o_EqualsContinuation(self: AvailObject, aContinuation: A_Continuation): Boolean

o_EqualsContinuationType

open override fun o_EqualsContinuationType(self: AvailObject, aContinuationType: A_Type): Boolean

o_EqualsDouble

open override fun o_EqualsDouble(self: AvailObject, aDouble: Double): Boolean

o_EqualsEnumerationType

open override fun o_EqualsEnumerationType(self: AvailObject, another: A_BasicObject): Boolean

o_EqualsEnumerationWithSet

open override fun o_EqualsEnumerationWithSet(self: AvailObject, aSet: A_Set): Boolean

o_EqualsEqualityRawPojo

open override fun o_EqualsEqualityRawPojo( self: AvailObject, otherEqualityRawPojo: AvailObject, otherJavaObject: Any?): Boolean

o_EqualsFiberType

open override fun o_EqualsFiberType(self: AvailObject, aFiberType: A_Type): Boolean

Answer whether the arguments, an object and a FiberTypeDescriptor, are equal in value.

o_EqualsFloat

open override fun o_EqualsFloat(self: AvailObject, aFloat: Float): Boolean

o_EqualsFunction

open override fun o_EqualsFunction(self: AvailObject, aFunction: A_Function): Boolean

Answer whether the arguments, an object and a FunctionDescriptor, are equal in value.

o_EqualsFunctionType

open override fun o_EqualsFunctionType(self: AvailObject, aFunctionType: A_Type): Boolean

Answer whether the arguments, an object and a FunctionTypeDescriptor, are equal.

o_EqualsInfinity

open override fun o_EqualsInfinity(self: AvailObject, sign: AbstractNumberDescriptor.Sign): Boolean

Answer whether the receiver is an InfinityDescriptor with the specified Sign.

o_EqualsInstanceTypeFor

open override fun o_EqualsInstanceTypeFor(self: AvailObject, anObject: AvailObject): Boolean

o_EqualsInt

open override fun o_EqualsInt(self: AvailObject, theInt: Int): Boolean

o_EqualsInteger

open override fun o_EqualsInteger(self: AvailObject, anAvailInteger: AvailObject): Boolean

o_EqualsIntegerIntervalTuple

open override fun o_EqualsIntegerIntervalTuple(self: AvailObject, anIntegerIntervalTuple: A_Tuple): Boolean

o_EqualsIntegerRangeType

open override fun o_EqualsIntegerRangeType(self: AvailObject, another: A_Type): Boolean

o_EqualsIntTuple

open override fun o_EqualsIntTuple(self: AvailObject, anIntTuple: A_Tuple): Boolean

o_EqualsListNodeType

open override fun o_EqualsListNodeType(self: AvailObject, aListNodeType: A_Type): Boolean

o_EqualsLiteralTokenType

open override fun o_EqualsLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): Boolean

o_EqualsLongTuple

open override fun o_EqualsLongTuple(self: AvailObject, aLongTuple: A_Tuple): Boolean

o_EqualsMap

open override fun o_EqualsMap(self: AvailObject, aMap: A_Map): Boolean

o_EqualsMapType

open override fun o_EqualsMapType(self: AvailObject, aMapType: A_Type): Boolean

o_EqualsNybbleTuple

open override fun o_EqualsNybbleTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsObject

open override fun o_EqualsObject(self: AvailObject, anObject: AvailObject): Boolean

o_EqualsObjectTuple

open override fun o_EqualsObjectTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsObjectType

open override fun o_EqualsObjectType(self: AvailObject, anObjectType: AvailObject): Boolean

o_EqualsPhrase

open override fun o_EqualsPhrase(self: AvailObject, aPhrase: A_Phrase): Boolean

o_EqualsPhraseType

open override fun o_EqualsPhraseType(self: AvailObject, aPhraseType: A_Type): Boolean

o_EqualsPojo

open override fun o_EqualsPojo(self: AvailObject, aPojo: AvailObject): Boolean

o_EqualsPojoBottomType

open override fun o_EqualsPojoBottomType(self: AvailObject): Boolean

o_EqualsPojoField

open override fun o_EqualsPojoField( self: AvailObject, field: AvailObject, receiver: AvailObject): Boolean

o_EqualsPojoType

open override fun o_EqualsPojoType(self: AvailObject, aPojoType: AvailObject): Boolean

o_EqualsPrimitiveType

open override fun o_EqualsPrimitiveType(self: AvailObject, aPrimitiveType: A_Type): Boolean

o_EqualsRawPojoFor

open override fun o_EqualsRawPojoFor( self: AvailObject, otherRawPojo: AvailObject, otherJavaObject: Any?): Boolean

o_EqualsRepeatedElementTuple

open override fun o_EqualsRepeatedElementTuple(self: AvailObject, aRepeatedElementTuple: A_Tuple): Boolean

o_EqualsReverseTuple

open override fun o_EqualsReverseTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsSet

open override fun o_EqualsSet(self: AvailObject, aSet: A_Set): Boolean

o_EqualsSetType

open override fun o_EqualsSetType(self: AvailObject, aSetType: A_Type): Boolean

o_EqualsSmallIntegerIntervalTuple

open override fun o_EqualsSmallIntegerIntervalTuple(self: AvailObject, aSmallIntegerIntervalTuple: A_Tuple): Boolean

o_EqualsToken

open override fun o_EqualsToken(self: AvailObject, aToken: A_Token): Boolean

o_EqualsTokenType

open override fun o_EqualsTokenType(self: AvailObject, aTokenType: A_Type): Boolean

o_EqualsTupleType

open override fun o_EqualsTupleType(self: AvailObject, aTupleType: A_Type): Boolean

o_EqualsTwoByteString

open override fun o_EqualsTwoByteString(self: AvailObject, aString: A_String): Boolean

o_EqualsVariableType

open override fun o_EqualsVariableType(self: AvailObject, aType: A_Type): Boolean

o_ExecutionState

open override fun o_ExecutionState(self: AvailObject): FiberDescriptor.ExecutionState

o_Expand

open override fun o_Expand(self: AvailObject, module: A_Module)

o_ExportedNames

open override fun o_ExportedNames(self: AvailObject): A_Set

o_Expression

open override fun o_Expression(self: AvailObject): A_Phrase

o_ExpressionAt

open override fun o_ExpressionAt(self: AvailObject, index: Int): A_Phrase

o_ExpressionsSize

open override fun o_ExpressionsSize(self: AvailObject): Int

o_ExpressionsTuple

open override fun o_ExpressionsTuple(self: AvailObject): A_Tuple

o_ExtractBoolean

open override fun o_ExtractBoolean(self: AvailObject): Boolean

o_ExtractDouble

open override fun o_ExtractDouble(self: AvailObject): Double

o_ExtractDumpedLongAt

open override fun o_ExtractDumpedLongAt(self: AvailObject, index: Int): Long

o_ExtractDumpedObjectAt

open override fun o_ExtractDumpedObjectAt(self: AvailObject, index: Int): AvailObject

o_ExtractFloat

open override fun o_ExtractFloat(self: AvailObject): Float

o_ExtractInt

open override fun o_ExtractInt(self: AvailObject): Int

o_ExtractLong

open override fun o_ExtractLong(self: AvailObject): Long

Extract a 64-bit signed Java long from the specified Avail integer.

o_ExtractNybble

open override fun o_ExtractNybble(self: AvailObject): Byte

o_ExtractNybbleFromTupleAt

open override fun o_ExtractNybbleFromTupleAt(self: AvailObject, index: Int): Byte

o_ExtractSignedByte

open override fun o_ExtractSignedByte(self: AvailObject): Byte

o_ExtractSignedShort

open override fun o_ExtractSignedShort(self: AvailObject): Short

o_ExtractUnsignedByte

open override fun o_ExtractUnsignedByte(self: AvailObject): Short

o_ExtractUnsignedShort

open override fun o_ExtractUnsignedShort(self: AvailObject): Int

o_FailureContinuation

open override fun o_FailureContinuation(self: AvailObject): (Throwable) -> Unit

o_FetchAndAddValue

open override fun o_FetchAndAddValue(self: AvailObject, addend: A_Number): A_Number

o_FiberGlobals

open override fun o_FiberGlobals(self: AvailObject): A_Map

o_FiberHelper

open override fun o_FiberHelper(self: AvailObject): FiberDescriptor.FiberHelper

o_FiberName

open override fun o_FiberName(self: AvailObject): A_String

o_FiberNameSupplier

open override fun o_FiberNameSupplier(self: AvailObject, supplier: () -> A_String)

o_FiberResult

open override fun o_FiberResult(self: AvailObject): AvailObject

o_FiberResultType

open override fun o_FiberResultType(self: AvailObject): A_Type

o_FieldAt

open override fun o_FieldAt(self: AvailObject, field: A_Atom): AvailObject

o_FieldAtIndex

open override fun o_FieldAtIndex(self: AvailObject, index: Int): AvailObject

o_FieldAtOrNull

open override fun o_FieldAtOrNull(self: AvailObject, field: A_Atom): AvailObject?

o_FieldAtPuttingCanDestroy

open override fun o_FieldAtPuttingCanDestroy( self: AvailObject, field: A_Atom, value: A_BasicObject, canDestroy: Boolean): A_BasicObject

o_FieldMap

open override fun o_FieldMap(self: AvailObject): A_Map

o_FieldTuple

open override fun o_FieldTuple(self: AvailObject): A_Tuple

o_FieldTypeAt

open override fun o_FieldTypeAt(self: AvailObject, field: A_Atom): A_Type

o_FieldTypeAtIndex

open override fun o_FieldTypeAtIndex(self: AvailObject, index: Int): A_Type

o_FieldTypeAtOrNull

open override fun o_FieldTypeAtOrNull(self: AvailObject, field: A_Atom): A_Type?

o_FieldTypeMap

open override fun o_FieldTypeMap(self: AvailObject): A_Map

o_FieldTypeTuple

open override fun o_FieldTypeTuple(self: AvailObject): A_Tuple

o_FilterByTypes

open override fun o_FilterByTypes(self: AvailObject, argTypes: List<A_Type>): List<A_Definition>

Look up all method definitions that could match the given argument types. Answer a list of method definitions.

o_FlattenStatementsInto

open override fun o_FlattenStatementsInto(self: AvailObject, accumulatedStatements: MutableList<A_Phrase>)

o_ForEach

open override fun o_ForEach(self: AvailObject, action: (AvailObject, AvailObject) -> Unit)

o_ForEachInMapBin

open override fun o_ForEachInMapBin(self: AvailObject, action: (AvailObject, AvailObject) -> Unit)

o_FrameAt

open override fun o_FrameAt(self: AvailObject, index: Int): AvailObject

o_FrameAtPut

open override fun o_FrameAtPut( self: AvailObject, index: Int, value: AvailObject): AvailObject

o_Function

open override fun o_Function(self: AvailObject): A_Function

o_FunctionType

open override fun o_FunctionType(self: AvailObject): A_Type

o_GeneralFlag

open override fun o_GeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag): Boolean

o_GenerateInModule

open override fun o_GenerateInModule(self: AvailObject, module: A_Module): A_RawFunction

o_GeneratingLexer

open override fun o_GeneratingLexer(self: AvailObject): A_Lexer

o_GeneratingPhrase

open override fun o_GeneratingPhrase(self: AvailObject): A_Phrase

o_GetAndClearInterruptRequestFlag

open override fun o_GetAndClearInterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag): Boolean

o_GetAndClearReificationWaiters

open override fun o_GetAndClearReificationWaiters(self: AvailObject): List<(A_Continuation) -> Unit>

o_GetAndSetSynchronizationFlag

open override fun o_GetAndSetSynchronizationFlag( self: AvailObject, flag: FiberDescriptor.SynchronizationFlag, value: Boolean): Boolean

o_GetAndSetTupleOfBlockPhrases

open override fun o_GetAndSetTupleOfBlockPhrases(self: AvailObject, newValue: AvailObject): AvailObject

o_GetAndSetValue

open override fun o_GetAndSetValue(self: AvailObject, newValue: A_BasicObject): AvailObject

o_GetAtomProperty

open override fun o_GetAtomProperty(self: AvailObject, key: A_Atom): AvailObject

o_GetValue

open override fun o_GetValue(self: AvailObject): AvailObject

o_GetValueClearing

open override fun o_GetValueClearing(self: AvailObject): AvailObject

o_GetValueForDebugger

open override fun o_GetValueForDebugger(self: AvailObject): AvailObject

o_GlobalModule

open override fun o_GlobalModule(self: AvailObject): A_Module

o_GlobalName

open override fun o_GlobalName(self: AvailObject): A_String

o_GrammaticalRestrictions

open override fun o_GrammaticalRestrictions(self: AvailObject): A_Set

o_HasAncestor

open override fun o_HasAncestor(self: AvailObject, potentialAncestor: A_Module): Boolean

o_HasBackwardJump

open override fun o_HasBackwardJump(self: AvailObject): Boolean

o_HasElement

open override fun o_HasElement(self: AvailObject, elementObject: A_BasicObject): Boolean

Answer whether the receiver contains the specified element.

o_HasGrammaticalRestrictions

open override fun o_HasGrammaticalRestrictions(self: AvailObject): Boolean

o_Hash

open override fun o_Hash(self: AvailObject): Int

o_HashFromTo

open override fun o_HashFromTo( self: AvailObject, startIndex: Int, endIndex: Int): Int

o_HashOrZero

open override fun o_HashOrZero(self: AvailObject): Int

o_HasObjectInstance

open override fun o_HasObjectInstance(self: AvailObject, potentialInstance: AvailObject): Boolean

o_HasSuperCast

open override fun o_HasSuperCast(self: AvailObject): Boolean

o_HasValue

open override fun o_HasValue(self: AvailObject): Boolean

o_HeritableFiberGlobals

open override fun o_HeritableFiberGlobals(self: AvailObject): A_Map

o_HighlightPc

open override fun o_HighlightPc(self: AvailObject, topFrame: Boolean): Int

o_ImportedNames

open override fun o_ImportedNames(self: AvailObject): A_Map

o_IncludesDefinition

open override fun o_IncludesDefinition(self: AvailObject, definition: A_Definition): Boolean

Test if the definition is present within this method.

o_InitializationExpression

open override fun o_InitializationExpression(self: AvailObject): AvailObject

o_Instance

open override fun o_Instance(self: AvailObject): AvailObject

o_InstanceCount

open override fun o_InstanceCount(self: AvailObject): A_Number

o_Instances

open override fun o_Instances(self: AvailObject): A_Set

o_InstanceTag

open override fun o_InstanceTag(self: AvailObject): TypeTag

o_InterruptRequestFlag

open override fun o_InterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag): Boolean

o_IntroduceNewName

open override fun o_IntroduceNewName(self: AvailObject, trueName: A_Atom)

o_IsAbstract

open override fun o_IsAbstract(self: AvailObject): Boolean

o_IsAbstractDefinition

open override fun o_IsAbstractDefinition(self: AvailObject): Boolean

o_IsAtom

open override fun o_IsAtom(self: AvailObject): Boolean

Is the specified AvailObject an Avail atom?

o_IsAtomSpecial

open override fun o_IsAtomSpecial(self: AvailObject): Boolean

o_IsBackwardJump

open override fun o_IsBackwardJump(self: AvailObject): Boolean

o_IsBetterRepresentationThan

open override fun o_IsBetterRepresentationThan(self: AvailObject, anotherObject: A_BasicObject): Boolean

Given two objects that are known to be equal, is the first one in a better form (more compact, more efficient, older generation) than the second one?

o_IsBinSubsetOf

open override fun o_IsBinSubsetOf(self: AvailObject, potentialSuperset: A_Set): Boolean

Sets only use explicit bins for collisions, otherwise they store the element itself. This works because a bin can't be an element of a set.

o_IsBoolean

open override fun o_IsBoolean(self: AvailObject): Boolean

Is the specified AvailObject an Avail boolean?

o_IsBottom

open override fun o_IsBottom(self: AvailObject): Boolean

o_IsByteArrayTuple

open override fun o_IsByteArrayTuple(self: AvailObject): Boolean

o_IsByteBufferTuple

open override fun o_IsByteBufferTuple(self: AvailObject): Boolean

o_IsByteString

open override fun o_IsByteString(self: AvailObject): Boolean

o_IsByteTuple

open override fun o_IsByteTuple(self: AvailObject): Boolean

Is the specified AvailObject an Avail byte tuple?

o_IsCharacter

open override fun o_IsCharacter(self: AvailObject): Boolean

Is the specified AvailObject an Avail character?

o_IsDouble

open override fun o_IsDouble(self: AvailObject): Boolean

o_IsEnumeration

open override fun o_IsEnumeration(self: AvailObject): Boolean

o_IsExtendedInteger

open override fun o_IsExtendedInteger(self: AvailObject): Boolean

Is the specified AvailObject an Avail extended integer?

o_IsFinite

open override fun o_IsFinite(self: AvailObject): Boolean

o_IsFloat

open override fun o_IsFloat(self: AvailObject): Boolean

o_IsForwardDefinition

open override fun o_IsForwardDefinition(self: AvailObject): Boolean

o_IsFunction

open override fun o_IsFunction(self: AvailObject): Boolean

Is the specified AvailObject an Avail function?

o_IsGlobal

open override fun o_IsGlobal(self: AvailObject): Boolean

o_IsHashedMapBin

open override fun o_IsHashedMapBin(self: AvailObject): Boolean

o_IsInCurrentModule

open override fun o_IsInCurrentModule(self: AvailObject, currentModule: A_Module): Boolean

o_IsInitializedWriteOnceVariable

open override fun o_IsInitializedWriteOnceVariable(self: AvailObject): Boolean

o_IsInstanceMeta

open override fun o_IsInstanceMeta(self: AvailObject): Boolean

o_IsInstanceOf

open override fun o_IsInstanceOf(self: AvailObject, aType: A_Type): Boolean

o_IsInstanceOfKind

open override fun o_IsInstanceOfKind(self: AvailObject, aType: A_Type): Boolean

o_IsInt

open override fun o_IsInt(self: AvailObject): Boolean

o_IsIntegerIntervalTuple

open override fun o_IsIntegerIntervalTuple(self: AvailObject): Boolean

o_IsIntegerRangeType

open override fun o_IsIntegerRangeType(self: AvailObject): Boolean

o_IsIntTuple

open override fun o_IsIntTuple(self: AvailObject): Boolean

o_IsLastUse

open override fun o_IsLastUse(self: AvailObject): Boolean

open override fun o_IsLastUse(self: AvailObject, isLastUse: Boolean)

o_IsLiteralToken

open override fun o_IsLiteralToken(self: AvailObject): Boolean

o_IsLiteralTokenType

open override fun o_IsLiteralTokenType(self: AvailObject): Boolean

o_IsLong

open override fun o_IsLong(self: AvailObject): Boolean

o_IsLongTuple

open override fun o_IsLongTuple(self: AvailObject): Boolean

o_IsMacroSubstitutionNode

open override fun o_IsMacroSubstitutionNode(self: AvailObject): Boolean

o_IsMap

open override fun o_IsMap(self: AvailObject): Boolean

Is the specified AvailObject an Avail map?

o_IsMapType

open override fun o_IsMapType(self: AvailObject): Boolean

o_IsMethodDefinition

open override fun o_IsMethodDefinition(self: AvailObject): Boolean

o_IsMethodEmpty

open override fun o_IsMethodEmpty(self: AvailObject): Boolean

o_IsNumericallyIntegral

open override fun o_IsNumericallyIntegral(self: AvailObject): Boolean

o_IsNybble

open override fun o_IsNybble(self: AvailObject): Boolean

Is the specified AvailObject an Avail nybble?

o_IsPojo

open override fun o_IsPojo(self: AvailObject): Boolean

o_IsPojoArrayType

open override fun o_IsPojoArrayType(self: AvailObject): Boolean

o_IsPojoFusedType

open override fun o_IsPojoFusedType(self: AvailObject): Boolean

o_IsPojoSelfType

open override fun o_IsPojoSelfType(self: AvailObject): Boolean

o_IsPojoType

open override fun o_IsPojoType(self: AvailObject): Boolean

o_IsPositive

open override fun o_IsPositive(self: AvailObject): Boolean

o_IsRawPojo

open override fun o_IsRawPojo(self: AvailObject): Boolean

o_IsRepeatedElementTuple

open override fun o_IsRepeatedElementTuple(self: AvailObject): Boolean

o_IsSet

open override fun o_IsSet(self: AvailObject): Boolean

Is the specified AvailObject an Avail set?

o_IsSetBin

open override fun o_IsSetBin(self: AvailObject): Boolean

o_IsSetType

open override fun o_IsSetType(self: AvailObject): Boolean

o_IsSignedByte

open override fun o_IsSignedByte(self: AvailObject): Boolean

o_IsSignedShort

open override fun o_IsSignedShort(self: AvailObject): Boolean

o_IsSmallIntegerIntervalTuple

open override fun o_IsSmallIntegerIntervalTuple(self: AvailObject): Boolean

o_IsSourceOfCycle

open override fun o_IsSourceOfCycle(self: AvailObject): Boolean

open override fun o_IsSourceOfCycle(self: AvailObject, isSourceOfCycle: Boolean)

o_IsString

open override fun o_IsString(self: AvailObject): Boolean

Is the specified AvailObject an Avail string?

o_IsSubsetOf

open override fun o_IsSubsetOf(self: AvailObject, another: A_Set): Boolean

o_IsSubtypeOf

open override fun o_IsSubtypeOf(self: AvailObject, aType: A_Type): Boolean

o_IssuingModule

open override fun o_IssuingModule(self: AvailObject): A_Module

o_IsSupertypeOfCompiledCodeType

open override fun o_IsSupertypeOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): Boolean

o_IsSupertypeOfContinuationType

open override fun o_IsSupertypeOfContinuationType(self: AvailObject, aContinuationType: A_Type): Boolean

o_IsSupertypeOfEnumerationType

open override fun o_IsSupertypeOfEnumerationType(self: AvailObject, anEnumerationType: A_Type): Boolean

o_IsSupertypeOfFiberType

open override fun o_IsSupertypeOfFiberType(self: AvailObject, aType: A_Type): Boolean

o_IsSupertypeOfFunctionType

open override fun o_IsSupertypeOfFunctionType(self: AvailObject, aFunctionType: A_Type): Boolean

o_IsSupertypeOfIntegerRangeType

open override fun o_IsSupertypeOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): Boolean

o_IsSupertypeOfListNodeType

open override fun o_IsSupertypeOfListNodeType(self: AvailObject, aListNodeType: A_Type): Boolean

o_IsSupertypeOfLiteralTokenType

open override fun o_IsSupertypeOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): Boolean

o_IsSupertypeOfMapType

open override fun o_IsSupertypeOfMapType(self: AvailObject, aMapType: AvailObject): Boolean

o_IsSupertypeOfObjectType

open override fun o_IsSupertypeOfObjectType(self: AvailObject, anObjectType: AvailObject): Boolean

o_IsSupertypeOfPhraseType

open override fun o_IsSupertypeOfPhraseType(self: AvailObject, aPhraseType: A_Type): Boolean

o_IsSupertypeOfPojoBottomType

open override fun o_IsSupertypeOfPojoBottomType(self: AvailObject, aPojoType: A_Type): Boolean

o_IsSupertypeOfPojoType

open override fun o_IsSupertypeOfPojoType(self: AvailObject, aPojoType: A_Type): Boolean

o_IsSupertypeOfPrimitiveTypeEnum

open override fun o_IsSupertypeOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): Boolean

o_IsSupertypeOfSetType

open override fun o_IsSupertypeOfSetType(self: AvailObject, aSetType: A_Type): Boolean

o_IsSupertypeOfTokenType

open override fun o_IsSupertypeOfTokenType(self: AvailObject, aTokenType: A_Type): Boolean

o_IsSupertypeOfTupleType

open override fun o_IsSupertypeOfTupleType(self: AvailObject, aTupleType: A_Type): Boolean

o_IsSupertypeOfVariableType

open override fun o_IsSupertypeOfVariableType(self: AvailObject, aVariableType: A_Type): Boolean

o_IsTokenType

open override fun o_IsTokenType(self: AvailObject): Boolean

o_IsTop

open override fun o_IsTop(self: AvailObject): Boolean

o_IsTuple

open override fun o_IsTuple(self: AvailObject): Boolean

Is the specified AvailObject an Avail tuple?

o_IsTupleType

open override fun o_IsTupleType(self: AvailObject): Boolean

o_IsTwoByteString

open override fun o_IsTwoByteString(self: AvailObject): Boolean

o_IsType

open override fun o_IsType(self: AvailObject): Boolean

o_IsUnsignedByte

open override fun o_IsUnsignedByte(self: AvailObject): Boolean

Is the specified AvailObject an Avail unsigned byte?

o_IsUnsignedShort

open override fun o_IsUnsignedShort(self: AvailObject): Boolean

o_IsVacuousType

open override fun o_IsVacuousType(self: AvailObject): Boolean

o_Iterator

open override fun o_Iterator(self: AvailObject): Iterator<AvailObject>

Answer an iterator suitable for traversing the elements of the object with a Java foreach construct.

o_JavaAncestors

open override fun o_JavaAncestors(self: AvailObject): AvailObject

o_JavaClass

open override fun o_JavaClass(self: AvailObject): AvailObject

o_JavaObject

open override fun <T : Any> o_JavaObject(self: AvailObject): T?

Answer a pojo's java object. The type is not statically checkable in Java, but at least making it generic avoids an explicit cast expression at each call site.

o_JoiningFibers

open override fun o_JoiningFibers(self: AvailObject): A_Set

o_KeysAsSet

open override fun o_KeysAsSet(self: AvailObject): A_Set

o_KeyType

open override fun o_KeyType(self: AvailObject): A_Type

o_Kind

open override fun o_Kind(self: AvailObject): A_Type

o_LastExpression

open override fun o_LastExpression(self: AvailObject): A_Phrase

o_LatestBackwardJump

open override fun o_LatestBackwardJump(self: AvailObject): A_BundleTree

o_LazyActions

open override fun o_LazyActions(self: AvailObject): A_Map

o_LazyComplete

open override fun o_LazyComplete(self: AvailObject): A_Map

o_LazyIncomplete

open override fun o_LazyIncomplete(self: AvailObject): A_Map

o_LazyIncompleteCaseInsensitive

open override fun o_LazyIncompleteCaseInsensitive(self: AvailObject): A_Map

o_LazyPrefilterMap

open override fun o_LazyPrefilterMap(self: AvailObject): A_Map

o_LazyTypeFilterTree

open override fun o_LazyTypeFilterTree(self: AvailObject): LookupTree<A_Tuple, A_BundleTree>?

o_LevelTwoChunk

open override fun o_LevelTwoChunk(self: AvailObject): L2Chunk

o_LevelTwoOffset

open override fun o_LevelTwoOffset(self: AvailObject): Int

o_Lexer

open override fun o_Lexer(self: AvailObject): A_Lexer

o_LexerApplicability

open override fun o_LexerApplicability(self: AvailObject, codePoint: Int): Boolean?

o_LexerBodyFunction

open override fun o_LexerBodyFunction(self: AvailObject): A_Function

o_LexerFilterFunction

open override fun o_LexerFilterFunction(self: AvailObject): A_Function

o_LexerMethod

open override fun o_LexerMethod(self: AvailObject): A_Method

o_LineNumber

open override fun o_LineNumber(self: AvailObject): Int

o_LineNumberEncodedDeltas

open override fun o_LineNumberEncodedDeltas(self: AvailObject): A_Tuple

o_List

open override fun o_List(self: AvailObject): A_Phrase

o_Literal

open override fun o_Literal(self: AvailObject): AvailObject

o_LiteralAt

open override fun o_LiteralAt(self: AvailObject, index: Int): AvailObject

o_LiteralObject

open override fun o_LiteralObject(self: AvailObject): A_BasicObject

o_LiteralType

open override fun o_LiteralType(self: AvailObject): A_Type

o_LocalTypeAt

open override fun o_LocalTypeAt(self: AvailObject, index: Int): A_Type

o_Lock

open override fun <T> o_Lock(self: AvailObject, body: () -> T): T

o_LookupByTypesFromTuple

open override fun o_LookupByTypesFromTuple(self: AvailObject, argumentTypeTuple: A_Tuple): A_Definition

Look up the definition to invoke, given a tuple of argument types. Use the methodTestingTree to find the definition to invoke.

o_LookupByValuesFromList

open override fun o_LookupByValuesFromList(self: AvailObject, argumentList: List<A_BasicObject>): A_Definition

Look up the definition to invoke, given a List of argument values. Use the methodTestingTree to find the definition to invoke. Answer nil if a lookup error occurs.

o_LookupMacroByPhraseTuple

open override fun o_LookupMacroByPhraseTuple(self: AvailObject, argumentPhraseTuple: A_Tuple): A_Tuple

o_LowerBound

open override fun o_LowerBound(self: AvailObject): A_Number

o_LowerCaseString

open override fun o_LowerCaseString(self: AvailObject): A_String

o_LowerInclusive

open override fun o_LowerInclusive(self: AvailObject): Boolean

o_MacroOriginalSendNode

open override fun o_MacroOriginalSendNode(self: AvailObject): A_Phrase

o_MacrosTuple

open override fun o_MacrosTuple(self: AvailObject): A_Tuple

o_MakeImmutableInternal

open fun o_MakeImmutableInternal( self: AvailObject, queueToProcess: MutableList<AvailObject>, fixups: MutableList<() -> Unit>)

Given that the receiver is marked immutable, but its slots have not yet been made immutable, scan them now. For each slot found to be mutable, mark it immutable and add it to the supplied list.

o_MakeSharedInternal

open fun o_MakeSharedInternal( self: AvailObject, queueToProcess: MutableList<AvailObject>, fixups: MutableList<() -> Unit>)

Given that the receiver is marked shared, but its slots have not yet been shared, scan them now. For each slot found to be unshared, mark it and add it to the supplied list.

o_MakeSubobjectsImmutable

open override fun o_MakeSubobjectsImmutable(self: AvailObject): AvailObject

{@inheritDoc}

o_MakeSubobjectsShared

open override fun o_MakeSubobjectsShared(self: AvailObject): AvailObject

{@inheritDoc}

o_ManifestEntries

open override fun o_ManifestEntries(self: AvailObject): List<ModuleManifestEntry>

o_MapAtOrNull

open override fun o_MapAtOrNull(self: AvailObject, keyObject: A_BasicObject): AvailObject?

o_MapAtPuttingCanDestroy

open override fun o_MapAtPuttingCanDestroy( self: AvailObject, keyObject: A_BasicObject, newValueObject: A_BasicObject, canDestroy: Boolean): A_Map

o_MapAtReplacingCanDestroy

open override fun o_MapAtReplacingCanDestroy( self: AvailObject, key: A_BasicObject, notFoundValue: A_BasicObject, canDestroy: Boolean, transformer: (AvailObject, AvailObject) -> A_BasicObject): A_Map

o_MapBinAtHash

open override fun o_MapBinAtHash( self: AvailObject, key: A_BasicObject, keyHash: Int): AvailObject?

o_MapBinAtHashPutLevelCanDestroy

open override fun o_MapBinAtHashPutLevelCanDestroy( self: AvailObject, key: A_BasicObject, keyHash: Int, value: A_BasicObject, myLevel: Int, canDestroy: Boolean): A_MapBin

o_MapBinAtHashReplacingLevelCanDestroy

open override fun o_MapBinAtHashReplacingLevelCanDestroy( self: AvailObject, key: AvailObject, keyHash: Int, notFoundValue: AvailObject, myLevel: Int, canDestroy: Boolean, transformer: (AvailObject, AvailObject) -> A_BasicObject): A_MapBin

o_MapBinIterator

open override fun o_MapBinIterator(self: AvailObject): MapDescriptor.MapIterator

o_MapBinKeysHash

open override fun o_MapBinKeysHash(self: AvailObject): Int

o_MapBinKeyUnionKind

open override fun o_MapBinKeyUnionKind(self: AvailObject): A_Type

o_MapBinRemoveKeyHashCanDestroy

open override fun o_MapBinRemoveKeyHashCanDestroy( self: AvailObject, key: A_BasicObject, keyHash: Int, canDestroy: Boolean): A_MapBin

o_MapBinSize

open override fun o_MapBinSize(self: AvailObject): Int

o_MapBinValuesHash

open override fun o_MapBinValuesHash(self: AvailObject): Int

o_MapBinValueUnionKind

open override fun o_MapBinValueUnionKind(self: AvailObject): A_Type

o_MapIterable

open override fun o_MapIterable(self: AvailObject): Iterable<MapDescriptor.Entry>

o_MapSize

open override fun o_MapSize(self: AvailObject): Int

o_MapWithoutKeyCanDestroy

open override fun o_MapWithoutKeyCanDestroy( self: AvailObject, keyObject: A_BasicObject, canDestroy: Boolean): A_Map

o_MarkerValue

open override fun o_MarkerValue(self: AvailObject): A_BasicObject

o_MarshalToJava

open override fun o_MarshalToJava(self: AvailObject, classHint: Class<*>?): Any?

o_MaxStackDepth

open override fun o_MaxStackDepth(self: AvailObject): Int

o_MembershipChanged

open override fun o_MembershipChanged(self: AvailObject)

The membership of this method has changed. Invalidate anything that depended on the previous membership, including the methodTestingTree and any L2Chunks in the dependentChunksWeakSet.

o_Message

open override fun o_Message(self: AvailObject): A_Atom

o_MessagePart

open override fun o_MessagePart(self: AvailObject, index: Int): A_String

o_MessageParts

open override fun o_MessageParts(self: AvailObject): A_Tuple

o_MessageSplitter

open override fun o_MessageSplitter(self: AvailObject): MessageSplitter

o_MethodAddBundle

open override fun o_MethodAddBundle(self: AvailObject, bundle: A_Bundle)

o_MethodAddDefinition

open override fun o_MethodAddDefinition(self: AvailObject, definition: A_Definition)

Method manipulation takes place while all fibers are L1-precise and suspended. Use a global lock at the outermost calls to side-step deadlocks. Because no fiber is running, we don't have to protect subsystems like the L2Generator from these changes.

o_MethodDefinitions

open override fun o_MethodDefinitions(self: AvailObject): A_Set

o_MethodName

open override fun o_MethodName(self: AvailObject): A_String

o_MethodRemoveBundle

open override fun o_MethodRemoveBundle(self: AvailObject, bundle: A_Bundle)

o_MethodStylers

open override fun o_MethodStylers(self: AvailObject): A_Set

o_MinusCanDestroy

open override fun o_MinusCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_Module

open override fun o_Module(self: AvailObject): A_Module

o_ModuleAddDefinition

open override fun o_ModuleAddDefinition(self: AvailObject, definition: A_Definition)

o_ModuleAddGrammaticalRestriction

open override fun o_ModuleAddGrammaticalRestriction(self: AvailObject, grammaticalRestriction: A_GrammaticalRestriction)

Add a GrammaticalRestrictionDescriptor to the receiver.

o_ModuleAddMacro

open override fun o_ModuleAddMacro(self: AvailObject, macro: A_Macro)

o_ModuleAddSemanticRestriction

open override fun o_ModuleAddSemanticRestriction(self: AvailObject, semanticRestriction: A_SemanticRestriction)

o_ModuleAddStyler

open override fun o_ModuleAddStyler(self: AvailObject, styler: A_Styler)

o_ModuleName

open override fun o_ModuleName(self: AvailObject): A_String

o_ModuleNameNative

open override fun o_ModuleNameNative(self: AvailObject): String

o_ModuleState

open override fun o_ModuleState(self: AvailObject): ModuleDescriptor.State

o_ModuleStylers

open override fun o_ModuleStylers(self: AvailObject): A_Set

o_MultiplyByDoubleCanDestroy

open override fun o_MultiplyByDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_MultiplyByFloatCanDestroy

open override fun o_MultiplyByFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_MultiplyByInfinityCanDestroy

open override fun o_MultiplyByInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_MultiplyByIntegerCanDestroy

open override fun o_MultiplyByIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_NameForDebugger

open override fun o_NameForDebugger(self: AvailObject): String

o_NameHighlightingPc

open override fun o_NameHighlightingPc(self: AvailObject): String

o_NeededVariables

open override fun o_NeededVariables(self: AvailObject): A_Tuple

open override fun o_NeededVariables(self: AvailObject, neededVariables: A_Tuple)

o_NewNames

open override fun o_NewNames(self: AvailObject): A_Map

o_NextLexingState

open override fun o_NextLexingState(self: AvailObject): LexingState

o_NextLexingStatePojo

open override fun o_NextLexingStatePojo(self: AvailObject): AvailObject

o_NumArgs

open override fun o_NumArgs(self: AvailObject): Int

Answer how many arguments my instances expect. This is applicable to both methods and CompiledCodeDescriptor.

o_NumConstants

open override fun o_NumConstants(self: AvailObject): Int

o_NumericCompare

open override fun o_NumericCompare(self: AvailObject, another: A_Number): AbstractNumberDescriptor.Order

o_NumericCompareToDouble

open override fun o_NumericCompareToDouble(self: AvailObject, aDouble: Double): AbstractNumberDescriptor.Order

o_NumericCompareToInfinity

open override fun o_NumericCompareToInfinity(self: AvailObject, sign: AbstractNumberDescriptor.Sign): AbstractNumberDescriptor.Order

o_NumericCompareToInteger

open override fun o_NumericCompareToInteger(self: AvailObject, anInteger: AvailObject): AbstractNumberDescriptor.Order

o_NumLiterals

open override fun o_NumLiterals(self: AvailObject): Int

o_NumLocals

open override fun o_NumLocals(self: AvailObject): Int

o_NumNybbles

open override fun o_NumNybbles(self: AvailObject): Int

o_NumOuters

open override fun o_NumOuters(self: AvailObject): Int

o_NumOuterVars

open override fun o_NumOuterVars(self: AvailObject): Int

o_NumSlots

open override fun o_NumSlots(self: AvailObject): Int

o_Nybbles

open override fun o_Nybbles(self: AvailObject): A_Tuple

o_ObjectTypeVariant

open override fun o_ObjectTypeVariant(self: AvailObject): ObjectLayoutVariant

o_ObjectVariant

open override fun o_ObjectVariant(self: AvailObject): ObjectLayoutVariant

o_OptionallyNilOuterVar

open override fun o_OptionallyNilOuterVar(self: AvailObject, index: Int): Boolean

o_OriginatingPhrase

open override fun o_OriginatingPhrase(self: AvailObject): A_Phrase

o_OriginatingPhraseAtIndex

open override fun o_OriginatingPhraseAtIndex(self: AvailObject, index: Int): A_Phrase

o_OriginatingPhraseIndex

open override fun o_OriginatingPhraseIndex(self: AvailObject): Int

o_OuterTypeAt

open override fun o_OuterTypeAt(self: AvailObject, index: Int): A_Type

o_OuterVarAt

open override fun o_OuterVarAt(self: AvailObject, index: Int): AvailObject

o_OuterVarAtPut

open override fun o_OuterVarAtPut( self: AvailObject, index: Int, value: AvailObject)

o_OutputPhrase

open override fun o_OutputPhrase(self: AvailObject): A_Phrase

o_PackedDeclarationNames

open override fun o_PackedDeclarationNames(self: AvailObject): A_String

o_ParallelStream

open override fun o_ParallelStream(self: AvailObject): Stream<AvailObject>

o_Parent

open override fun o_Parent(self: AvailObject): A_BasicObject

o_ParsingInstructions

open override fun o_ParsingInstructions(self: AvailObject): A_Tuple

o_ParsingPc

open override fun o_ParsingPc(self: AvailObject): Int

o_ParsingPlan

open override fun o_ParsingPlan(self: AvailObject): A_DefinitionParsingPlan

o_ParsingSignature

open override fun o_ParsingSignature(self: AvailObject): A_Type

o_Pc

open override fun o_Pc(self: AvailObject): Int

o_Permutation

open override fun o_Permutation(self: AvailObject): A_Tuple

o_PhraseExpressionType

open override fun o_PhraseExpressionType(self: AvailObject): A_Type

o_PhraseKind

open override fun o_PhraseKind(self: AvailObject): PhraseTypeDescriptor.PhraseKind

o_PhraseKindIsUnder

open override fun o_PhraseKindIsUnder(self: AvailObject, expectedPhraseKind: PhraseTypeDescriptor.PhraseKind): Boolean

o_PhraseTypeExpressionType

open override fun o_PhraseTypeExpressionType(self: AvailObject): A_Type

o_PlusCanDestroy

open override fun o_PlusCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_PojoSelfType

open override fun o_PojoSelfType(self: AvailObject): A_Type

o_PrefixFunctions

open override fun o_PrefixFunctions(self: AvailObject): A_Tuple

o_Primitive

open override fun o_Primitive(self: AvailObject): Primitive?

o_Priority

open override fun o_Priority(self: AvailObject): Int

o_PrivateNames

open override fun o_PrivateNames(self: AvailObject): A_Map

o_RangeIncludesLong

open override fun o_RangeIncludesLong(self: AvailObject, aLong: Long): Boolean

o_RawByteForCharacterAt

open override fun o_RawByteForCharacterAt(self: AvailObject, index: Int): Short

o_RawPojo

open override fun o_RawPojo(self: AvailObject): AvailObject

o_RawSignedIntegerAt

open override fun o_RawSignedIntegerAt(self: AvailObject, index: Int): Int

o_RawSignedIntegerAtPut

open override fun o_RawSignedIntegerAtPut( self: AvailObject, index: Int, value: Int)

o_RawUnsignedIntegerAt

open override fun o_RawUnsignedIntegerAt(self: AvailObject, index: Int): Long

o_RawUnsignedIntegerAtPut

open override fun o_RawUnsignedIntegerAtPut( self: AvailObject, index: Int, value: Int)

o_ReadType

open override fun o_ReadType(self: AvailObject): A_Type

o_RecordBlockPhrase

open override fun o_RecordBlockPhrase(self: AvailObject, blockPhrase: A_Phrase): Int

o_RecordVariableAccess

open override fun o_RecordVariableAccess( self: AvailObject, variable: A_Variable, wasRead: Boolean)

o_RegisterDump

open override fun o_RegisterDump(self: AvailObject): AvailObject

o_ReleaseFromDebugger

open override fun o_ReleaseFromDebugger(self: AvailObject)

o_RemoveDefinition

open override fun o_RemoveDefinition(self: AvailObject, definition: A_Definition)

Remove the definition from me. Causes dependent chunks to be invalidated.

o_RemoveDependentChunk

open override fun o_RemoveDependentChunk(self: AvailObject, chunk: L2Chunk)

Remove the chunk from my set of dependent chunks because it has been invalidated by a new definition in either me or another method on which the chunk is contingent.

o_RemoveFrom

open override fun o_RemoveFrom( self: AvailObject, loader: AvailLoader, afterRemoval: () -> Unit)

o_RemoveGrammaticalRestriction

open override fun o_RemoveGrammaticalRestriction(self: AvailObject, obsoleteRestriction: A_GrammaticalRestriction)

o_RemoveMacro

open override fun o_RemoveMacro(self: AvailObject, macro: A_Macro)

o_RemovePlanForSendable

open override fun o_RemovePlanForSendable(self: AvailObject, sendable: A_Sendable)

o_RemovePlanInProgress

open override fun o_RemovePlanInProgress(self: AvailObject, planInProgress: A_ParsingPlanInProgress)

o_RemoveSealedArgumentsType

open override fun o_RemoveSealedArgumentsType(self: AvailObject, typeTuple: A_Tuple)

o_RemoveSemanticRestriction

open override fun o_RemoveSemanticRestriction(self: AvailObject, restriction: A_SemanticRestriction)

o_RemoveWriteReactor

open override fun o_RemoveWriteReactor(self: AvailObject, key: A_Atom)

o_ReplaceFirstChild

open override fun o_ReplaceFirstChild(self: AvailObject, newFirst: A_Tuple): A_Tuple

o_ReplacingCaller

open override fun o_ReplacingCaller(self: AvailObject, newCaller: A_Continuation): A_Continuation

o_RepresentationCostOfTupleType

open override fun o_RepresentationCostOfTupleType(self: AvailObject): Int

Given two objects that are known to be equal, the second of which is in the form of a tuple type, is the first one in a better form than the second one?

o_ResolveForward

open override fun o_ResolveForward(self: AvailObject, forwardDefinition: A_BasicObject)

o_RestrictedBundle

open override fun o_RestrictedBundle(self: AvailObject): A_Bundle

o_ResultContinuation

open override fun o_ResultContinuation(self: AvailObject): (AvailObject) -> Unit

o_ResultType

open override fun o_ResultType(self: AvailObject): A_Type

o_ReturneeCheckStat

open override fun o_ReturneeCheckStat(self: AvailObject): Statistic

o_ReturnerCheckStat

open override fun o_ReturnerCheckStat(self: AvailObject): Statistic

o_ReturnType

open override fun o_ReturnType(self: AvailObject): A_Type

o_ReturnTypeIfPrimitiveFails

open override fun o_ReturnTypeIfPrimitiveFails(self: AvailObject): A_Type

o_SealedArgumentsTypesTuple

open override fun o_SealedArgumentsTypesTuple(self: AvailObject): A_Tuple

o_SemanticRestrictions

open override fun o_SemanticRestrictions(self: AvailObject): A_Set

Return the method's tuple of FunctionDescriptor that statically restrict call sites by argument type.

o_Sequence

open override fun o_Sequence(self: AvailObject): A_Phrase

o_SerializedObjects

open override fun o_SerializedObjects(self: AvailObject, serializedObjects: A_Tuple)

o_SerializerOperation

open override fun o_SerializerOperation(self: AvailObject): SerializerOperation

o_SetAtomBundle

open override fun o_SetAtomBundle(self: AvailObject, bundle: A_Bundle)

o_SetAtomProperty

open override fun o_SetAtomProperty( self: AvailObject, key: A_Atom, value: A_BasicObject)

o_SetAvailLoader

open override fun o_SetAvailLoader(self: AvailObject, loader: AvailLoader?)

o_SetBinAddingElementHashLevelCanDestroy

open override fun o_SetBinAddingElementHashLevelCanDestroy( self: AvailObject, elementObject: A_BasicObject, elementObjectHash: Int, myLevel: Int, canDestroy: Boolean): A_SetBin

o_SetBinHash

open override fun o_SetBinHash(self: AvailObject): Int

o_SetBinIterator

open override fun o_SetBinIterator(self: AvailObject): SetDescriptor.SetIterator

o_SetBinSize

open override fun o_SetBinSize(self: AvailObject): Int

o_SetBinUnion

open override fun o_SetBinUnion( self: AvailObject, otherBin: A_SetBin, level: Int): A_SetBin

o_SetBinUnionWithHashedBin

open override fun o_SetBinUnionWithHashedBin( self: AvailObject, hashedBin: AvailObject, level: Int): A_SetBin

o_SetBinUnionWithLinearBin

open override fun o_SetBinUnionWithLinearBin( self: AvailObject, linearBin: AvailObject, level: Int): A_SetBin

o_SetContinuation

open override fun o_SetContinuation(self: AvailObject, value: A_Continuation)

o_SetCurrentModule

open override fun o_SetCurrentModule(self: AvailObject, currentModule: A_Module)

o_SetElementsAreAllInstancesOfKind

open override fun o_SetElementsAreAllInstancesOfKind(self: AvailObject, kind: AvailObject): Boolean

o_SetExecutionState

open override fun o_SetExecutionState(self: AvailObject, value: FiberDescriptor.ExecutionState)

o_SetFiberGlobals

open override fun o_SetFiberGlobals(self: AvailObject, globals: A_Map)

o_SetFiberResult

open override fun o_SetFiberResult(self: AvailObject, result: A_BasicObject)

o_SetGeneralFlag

open override fun o_SetGeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag)

o_SetHashOrZero

open override fun o_SetHashOrZero(self: AvailObject, value: Int)

o_SetHeritableFiberGlobals

open override fun o_SetHeritableFiberGlobals(self: AvailObject, globals: A_Map)

o_SetInterruptRequestFlag

open override fun o_SetInterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag)

o_SetIntersectionCanDestroy

open override fun o_SetIntersectionCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetIntersects

open override fun o_SetIntersects(self: AvailObject, otherSet: A_Set): Boolean

o_SetJoiningFibers

open override fun o_SetJoiningFibers(self: AvailObject, joiners: A_Set)

o_SetLexer

open override fun o_SetLexer(self: AvailObject, lexer: A_Lexer)

o_SetLexerApplicability

open override fun o_SetLexerApplicability( self: AvailObject, codePoint: Int, applicability: Boolean)

o_SetManifestEntriesIndex

open override fun o_SetManifestEntriesIndex(self: AvailObject, recordNumber: Long)

o_SetMethodName

open override fun o_SetMethodName(self: AvailObject, methodName: A_String)

o_SetMinusCanDestroy

open override fun o_SetMinusCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetModuleState

open override fun o_SetModuleState(self: AvailObject, newState: ModuleDescriptor.State)

o_SetNextLexingStateFromPrior

open override fun o_SetNextLexingStateFromPrior(self: AvailObject, priorLexingState: LexingState)

o_SetOriginatingPhraseIndex

open override fun o_SetOriginatingPhraseIndex(self: AvailObject, index: Int)

o_SetPriority

open override fun o_SetPriority(self: AvailObject, value: Int)

o_SetSize

open override fun o_SetSize(self: AvailObject): Int

o_SetStartingChunkAndReoptimizationCountdown

open override fun o_SetStartingChunkAndReoptimizationCountdown( self: AvailObject, chunk: L2Chunk, countdown: Long)

o_SetStylingRecordIndex

open override fun o_SetStylingRecordIndex(self: AvailObject, recordNumber: Long)

o_SetSuccessAndFailure

open override fun o_SetSuccessAndFailure( self: AvailObject, onSuccess: (AvailObject) -> Unit, onFailure: (Throwable) -> Unit)

o_SetSuspendingFunction

open override fun o_SetSuspendingFunction(self: AvailObject, suspendingFunction: A_Function)

o_SetTextInterface

open override fun o_SetTextInterface(self: AvailObject, textInterface: TextInterface)

o_SetTraceFlag

open override fun o_SetTraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag)

o_SetUnionCanDestroy

open override fun o_SetUnionCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetValue

open override fun o_SetValue(self: AvailObject, newValue: A_BasicObject)

o_SetValueNoCheck

open override fun o_SetValueNoCheck(self: AvailObject, newValue: A_BasicObject)

o_SetValueWasStablyComputed

open override fun o_SetValueWasStablyComputed(self: AvailObject, wasStablyComputed: Boolean)

o_SetWakeupTask

open override fun o_SetWakeupTask(self: AvailObject, task: TimerTask?)

o_SetWithElementCanDestroy

open override fun o_SetWithElementCanDestroy( self: AvailObject, newElementObject: A_BasicObject, canDestroy: Boolean): A_Set

o_SetWithoutElementCanDestroy

open override fun o_SetWithoutElementCanDestroy( self: AvailObject, elementObjectToExclude: A_BasicObject, canDestroy: Boolean): A_Set

o_ShortModuleNameNative

open override fun o_ShortModuleNameNative(self: AvailObject): String

o_ShowValueInNameForDebugger

open fun o_ShowValueInNameForDebugger(self: AvailObject): Boolean

o_SizeRange

open override fun o_SizeRange(self: AvailObject): A_Type

o_Spliterator

open override fun o_Spliterator(self: AvailObject): Spliterator<AvailObject>

o_StackAt

open override fun o_StackAt(self: AvailObject, slotIndex: Int): AvailObject

o_Stackp

open override fun o_Stackp(self: AvailObject): Int

o_Start

open override fun o_Start(self: AvailObject): Int

o_StartingChunk

open override fun o_StartingChunk(self: AvailObject): L2Chunk

o_StartingLineNumber

open override fun o_StartingLineNumber(self: AvailObject): Int

o_Statements

open override fun o_Statements(self: AvailObject): A_Tuple

o_StatementsDo

open override fun o_StatementsDo(self: AvailObject, continuation: (A_Phrase) -> Unit)

o_StatementsTuple

open override fun o_StatementsTuple(self: AvailObject): A_Tuple

o_Stream

open override fun o_Stream(self: AvailObject): Stream<AvailObject>

o_String

open override fun o_String(self: AvailObject): A_String

o_StripMacro

open override fun o_StripMacro(self: AvailObject): A_Phrase

o_StylerMethod

open override fun o_StylerMethod(self: AvailObject): A_Method

o_StylingRecord

open override fun o_StylingRecord(self: AvailObject): Repository.StylingRecord

o_SubexpressionsTupleType

open override fun o_SubexpressionsTupleType(self: AvailObject): A_Type

o_SubtractFromDoubleCanDestroy

open override fun o_SubtractFromDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_SubtractFromFloatCanDestroy

open override fun o_SubtractFromFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_SubtractFromInfinityCanDestroy

open override fun o_SubtractFromInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_SubtractFromIntegerCanDestroy

open override fun o_SubtractFromIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_SuperUnionType

open override fun o_SuperUnionType(self: AvailObject): A_Type

o_SuspendingFunction

open override fun o_SuspendingFunction(self: AvailObject): A_Function

o_SynthesizeCurrentLexingState

open override fun o_SynthesizeCurrentLexingState(self: AvailObject): LexingState

o_TallyInvocation

open override fun o_TallyInvocation(self: AvailObject)

o_TestingTree

open override fun o_TestingTree(self: AvailObject): LookupTree<A_Definition, A_Tuple>

o_TextInterface

open override fun o_TextInterface(self: AvailObject): TextInterface

o_TimesCanDestroy

open override fun o_TimesCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_Token

open override fun o_Token(self: AvailObject): A_Token

o_Tokens

open override fun o_Tokens(self: AvailObject): A_Tuple

o_TokenType

open override fun o_TokenType(self: AvailObject): TokenDescriptor.TokenType

o_TotalInvocations

open override fun o_TotalInvocations(self: AvailObject): Long

o_TraceFlag

open override fun o_TraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag): Boolean

o_TransferIntoByteBuffer

open override fun o_TransferIntoByteBuffer( self: AvailObject, startIndex: Int, endIndex: Int, outputByteBuffer: ByteBuffer)

o_Traversed

open override fun o_Traversed(self: AvailObject): AvailObject

o_TraversedWhileMakingImmutable

open override fun o_TraversedWhileMakingImmutable(self: AvailObject): AvailObject

o_TraversedWhileMakingShared

open override fun o_TraversedWhileMakingShared(self: AvailObject): AvailObject

o_TreeTupleLevel

open override fun o_TreeTupleLevel(self: AvailObject): Int

o_TrimExcessInts

open override fun o_TrimExcessInts(self: AvailObject)

o_TrimType

open override fun o_TrimType(self: AvailObject, typeToRemove: A_Type): A_Type

o_TrueNamesForStringName

open override fun o_TrueNamesForStringName(self: AvailObject, stringName: A_String): A_Set

o_TupleAt

open override fun o_TupleAt(self: AvailObject, index: Int): AvailObject

o_TupleAtPuttingCanDestroy

open override fun o_TupleAtPuttingCanDestroy( self: AvailObject, index: Int, newValueObject: A_BasicObject, canDestroy: Boolean): A_Tuple

o_TupleCodePointAt

open override fun o_TupleCodePointAt(self: AvailObject, index: Int): Int

o_TupleElementsInRangeAreInstancesOf

open override fun o_TupleElementsInRangeAreInstancesOf( self: AvailObject, startIndex: Int, endIndex: Int, type: A_Type): Boolean

o_TupleIntAt

open override fun o_TupleIntAt(self: AvailObject, index: Int): Int

o_TupleLongAt

open override fun o_TupleLongAt(self: AvailObject, index: Int): Long

o_TupleOfTypesFromTo

open override fun o_TupleOfTypesFromTo( self: AvailObject, startIndex: Int, endIndex: Int): A_Tuple

o_TupleReverse

open override fun o_TupleReverse(self: AvailObject): A_Tuple

o_TupleSize

open override fun o_TupleSize(self: AvailObject): Int

o_TypeAtIndex

open override fun o_TypeAtIndex(self: AvailObject, index: Int): A_Type

o_TypeExpression

open override fun o_TypeExpression(self: AvailObject): A_Phrase

o_TypeIntersection

open override fun o_TypeIntersection(self: AvailObject, another: A_Type): A_Type

o_TypeIntersectionOfCompiledCodeType

open override fun o_TypeIntersectionOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): A_Type

o_TypeIntersectionOfContinuationType

open override fun o_TypeIntersectionOfContinuationType(self: AvailObject, aContinuationType: A_Type): A_Type

o_TypeIntersectionOfFiberType

open override fun o_TypeIntersectionOfFiberType(self: AvailObject, aFiberType: A_Type): A_Type

o_TypeIntersectionOfFunctionType

open override fun o_TypeIntersectionOfFunctionType(self: AvailObject, aFunctionType: A_Type): A_Type

o_TypeIntersectionOfIntegerRangeType

open override fun o_TypeIntersectionOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): A_Type

o_TypeIntersectionOfListNodeType

open override fun o_TypeIntersectionOfListNodeType(self: AvailObject, aListNodeType: A_Type): A_Type

o_TypeIntersectionOfLiteralTokenType

open override fun o_TypeIntersectionOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): A_Type

o_TypeIntersectionOfMapType

open override fun o_TypeIntersectionOfMapType(self: AvailObject, aMapType: A_Type): A_Type

o_TypeIntersectionOfObjectType

open override fun o_TypeIntersectionOfObjectType(self: AvailObject, anObjectType: AvailObject): A_Type

o_TypeIntersectionOfPhraseType

open override fun o_TypeIntersectionOfPhraseType(self: AvailObject, aPhraseType: A_Type): A_Type

o_TypeIntersectionOfPojoFusedType

open override fun o_TypeIntersectionOfPojoFusedType(self: AvailObject, aFusedPojoType: A_Type): A_Type

o_TypeIntersectionOfPojoType

open override fun o_TypeIntersectionOfPojoType(self: AvailObject, aPojoType: A_Type): A_Type

o_TypeIntersectionOfPojoUnfusedType

open override fun o_TypeIntersectionOfPojoUnfusedType(self: AvailObject, anUnfusedPojoType: A_Type): A_Type

o_TypeIntersectionOfPrimitiveTypeEnum

open override fun o_TypeIntersectionOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): A_Type

o_TypeIntersectionOfSetType

open override fun o_TypeIntersectionOfSetType(self: AvailObject, aSetType: A_Type): A_Type

o_TypeIntersectionOfTokenType

open override fun o_TypeIntersectionOfTokenType(self: AvailObject, aTokenType: A_Type): A_Type

o_TypeIntersectionOfTupleType

open override fun o_TypeIntersectionOfTupleType(self: AvailObject, aTupleType: A_Type): A_Type

o_TypeIntersectionOfVariableType

open override fun o_TypeIntersectionOfVariableType(self: AvailObject, aVariableType: A_Type): A_Type

o_TypeTuple

open override fun o_TypeTuple(self: AvailObject): A_Tuple

o_TypeUnion

open override fun o_TypeUnion(self: AvailObject, another: A_Type): A_Type

o_TypeUnionOfCompiledCodeType

open override fun o_TypeUnionOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): A_Type

o_TypeUnionOfContinuationType

open override fun o_TypeUnionOfContinuationType(self: AvailObject, aContinuationType: A_Type): A_Type

o_TypeUnionOfFiberType

open override fun o_TypeUnionOfFiberType(self: AvailObject, aFiberType: A_Type): A_Type

o_TypeUnionOfFunctionType

open override fun o_TypeUnionOfFunctionType(self: AvailObject, aFunctionType: A_Type): A_Type

o_TypeUnionOfIntegerRangeType

open override fun o_TypeUnionOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): A_Type

o_TypeUnionOfListNodeType

open override fun o_TypeUnionOfListNodeType(self: AvailObject, aListNodeType: A_Type): A_Type

o_TypeUnionOfLiteralTokenType

open override fun o_TypeUnionOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): A_Type

o_TypeUnionOfMapType

open override fun o_TypeUnionOfMapType(self: AvailObject, aMapType: A_Type): A_Type

o_TypeUnionOfObjectType

open override fun o_TypeUnionOfObjectType(self: AvailObject, anObjectType: AvailObject): A_Type

o_TypeUnionOfPhraseType

open override fun o_TypeUnionOfPhraseType(self: AvailObject, aPhraseType: A_Type): A_Type

o_TypeUnionOfPojoFusedType

open override fun o_TypeUnionOfPojoFusedType(self: AvailObject, aFusedPojoType: A_Type): A_Type

o_TypeUnionOfPojoType

open override fun o_TypeUnionOfPojoType(self: AvailObject, aPojoType: A_Type): A_Type

o_TypeUnionOfPojoUnfusedType

open override fun o_TypeUnionOfPojoUnfusedType(self: AvailObject, anUnfusedPojoType: A_Type): A_Type

o_TypeUnionOfPrimitiveTypeEnum

open override fun o_TypeUnionOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): A_Type

o_TypeUnionOfSetType

open override fun o_TypeUnionOfSetType(self: AvailObject, aSetType: A_Type): A_Type

o_TypeUnionOfTokenType

open override fun o_TypeUnionOfTokenType(self: AvailObject, aTokenType: A_Type): A_Type

o_TypeUnionOfTupleType

open override fun o_TypeUnionOfTupleType(self: AvailObject, aTupleType: A_Type): A_Type

o_TypeUnionOfVariableType

open override fun o_TypeUnionOfVariableType(self: AvailObject, aVariableType: A_Type): A_Type

o_TypeVariables

open override fun o_TypeVariables(self: AvailObject): A_Map

o_UnionOfTypesAtThrough

open override fun o_UnionOfTypesAtThrough( self: AvailObject, startIndex: Int, endIndex: Int): A_Type

o_UniqueId

open override fun o_UniqueId(self: AvailObject): Long

o_UpdateForNewGrammaticalRestriction

open override fun o_UpdateForNewGrammaticalRestriction( self: AvailObject, planInProgress: A_ParsingPlanInProgress, treesToVisit: Deque<Pair<A_BundleTree, A_ParsingPlanInProgress>>)

o_UpdateStylers

open override fun o_UpdateStylers(self: AvailObject, updater: A_Set.() -> A_Set)

o_UpperBound

open override fun o_UpperBound(self: AvailObject): A_Number

o_UpperInclusive

open override fun o_UpperInclusive(self: AvailObject): Boolean

o_ValidateLocally

open override fun o_ValidateLocally(self: AvailObject)

o_ValidWriteReactorFunctions

open override fun o_ValidWriteReactorFunctions(self: AvailObject): A_Set

o_Value

open override fun o_Value(self: AvailObject): AvailObject

o_ValuesAsTuple

open override fun o_ValuesAsTuple(self: AvailObject): A_Tuple

o_ValueType

open override fun o_ValueType(self: AvailObject): A_Type

o_ValueWasStablyComputed

open override fun o_ValueWasStablyComputed(self: AvailObject): Boolean

o_Variable

open override fun o_Variable(self: AvailObject): A_Phrase

o_VariableBindings

open override fun o_VariableBindings(self: AvailObject): A_Map

o_VariableMapHasKey

open override fun o_VariableMapHasKey(self: AvailObject, key: A_BasicObject): Boolean

o_VariablesReadBeforeWritten

open override fun o_VariablesReadBeforeWritten(self: AvailObject): A_Set

o_VariablesWritten

open override fun o_VariablesWritten(self: AvailObject): A_Set

o_Versions

open override fun o_Versions(self: AvailObject): A_Set

o_VisibleNames

open override fun o_VisibleNames(self: AvailObject): A_Set

o_WakeupTask

open override fun o_WakeupTask(self: AvailObject): TimerTask?

o_WhenContinuationIsAvailableDo

open override fun o_WhenContinuationIsAvailableDo(self: AvailObject, whenReified: (A_Continuation) -> Unit)

o_WhichPowerOfTwo

open override fun o_WhichPowerOfTwo(self: AvailObject): Int

o_WriteSummaryTo

open override fun o_WriteSummaryTo(self: AvailObject, writer: JSONWriter)

o_WriteTo

open override fun o_WriteTo(self: AvailObject, writer: JSONWriter)

o_WriteType

open override fun o_WriteType(self: AvailObject): A_Type

printObjectOnAvoidingIndent

open override fun printObjectOnAvoidingIndent( self: AvailObject, builder: StringBuilder, recursionMap: IdentityHashMap<A_BasicObject, Void>, indent: Int)

Print the object to the StringBuilder. By default show it as the descriptor's name and a line-by-line list of fields. If the indent is beyond the maximumIndent, indicate it's too deep without recursing. If the object is in the specified recursion list, indicate a recursive print and return.

shared

~~open~~ ~~override~~ ~~fun~~ ~~shared~~(): Nothing

Answer the shared version of this descriptor.

toString

open override fun toString(): String

unsupportedOperation

fun unsupportedOperation(): Nothing

Throw an AvailUnsupportedOperationException suitable to be thrown by the sender.

Properties

allocationStat

val allocationStat: Statistic

A Statistic that records the number and size of each allocation.

debugIntegerSlots

val debugIntegerSlots: Array<Array<IntegerSlotsEnum>?>

Used for quickly checking integer fields when AvailObjectRepresentation.shouldCheckSlots is enabled.

debugObjectSlots

val debugObjectSlots: Array<Array<ObjectSlotsEnum>?>

Used for quickly checking object fields when AvailObjectRepresentation.shouldCheckSlots is enabled.

isMutable

val isMutable: Boolean

Are objects using this descriptor mutable?

isShared

val isShared: Boolean

Are objects using this descriptor shared?

mutability

val mutability: Mutability

The mutability of my instances.

numberOfFixedIntegerSlots

val numberOfFixedIntegerSlots: Int

The minimum number of integer slots an AvailObject can have if it uses this descriptor. Does not include indexed slots possibly at the end. Populated automatically by the constructor.

numberOfFixedObjectSlots

val numberOfFixedObjectSlots: Int

The minimum number of object slots an AvailObject can have if it uses this descriptor. Does not include indexed slots possibly at the end. Populated automatically by the constructor.

owningBundles

@Volatile

var owningBundles: AtomicReference<A_Set>

A set of message bundles that name this method. The method itself has no intrinsic name, as its bundles completely determine what it is called in various modules (based on the module scope of the bundles' atomic names).

typeTag

val typeTag: TypeTag

Every descriptor has this field, and clients can access it directly to quickly determine the basic type of any value having that descriptor. This is purely an optimization for fast type checking and dispatching.

unsupported

val unsupported: Nothing

This read-only property can be used in place of unsupportedOperation. Using the getter produces almost the same diagnostic stack trace when executed, but is a much shorter expression.