.. java:import:: fr.inria.tapenade.utils ILLang

.. java:import:: fr.inria.tapenade.utils TapPair

.. java:import:: fr.inria.tapenade.utils TapTriplet

.. java:import:: fr.inria.tapenade.utils ToBool

.. java:import:: fr.inria.tapenade.utils ToObject

.. java:import:: fr.inria.tapenade.utils Tree

TypeSpec
========

.. java:package:: fr.inria.tapenade.representation
   :noindex:

.. java:type:: public abstract class TypeSpec

   Abstract class, parent of all classes that actually specify a type. All type classes derive from TypeSpec.

Fields
------
TARGET
^^^^^^

.. java:field:: public static final String TARGET
   :outertype: TypeSpec

compare_debug_indent
^^^^^^^^^^^^^^^^^^^^

.. java:field:: protected static int compare_debug_indent
   :outertype: TypeSpec

   Current indentation in debug display of the progress of comparesWith() comparison.

diffFromTypeDecl
^^^^^^^^^^^^^^^^

.. java:field:: public TypeDecl diffFromTypeDecl
   :outertype: TypeSpec

diffTypeDeclSymbolHolder
^^^^^^^^^^^^^^^^^^^^^^^^

.. java:field:: public NewSymbolHolder diffTypeDeclSymbolHolder
   :outertype: TypeSpec

   When this TypeSpec is in fact a differentiated type, this field holds the NewSymbolHolder of the name of this differentiated type.

diffTypeSpec
^^^^^^^^^^^^

.. java:field:: public WrapperTypeSpec diffTypeSpec
   :outertype: TypeSpec

Constructors
------------
TypeSpec
^^^^^^^^

.. java:constructor:: protected TypeSpec(int kind)
   :outertype: TypeSpec

   Creation.

   :param kind: The kind of this type, may be in strange cases UNKNOWNTYPE, ACTUALTYPE, METATYPE, WRAPPERTYPE, also still bizarre NAMEDTYPE but this may disappear, otherwise belonging to {VOIDTYPE, LABELTYPE, PRIMITIVETYPE, MODIFIEDTYPE, ENUMTYPE, POINTERTYPE, ARRAYTYPE, COMPOSITETYPE, FUNCTIONTYPE}.

Methods
-------
acceptsMultiDirDimension
^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean acceptsMultiDirDimension()
   :outertype: TypeSpec

   :return: true when the new dimension added by multiDirMode can apply to this typeSpec, instead of at some deeper level e.g. included in composite or pointer types.

addDeclaratorModifiers
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public static Tree addDeclaratorModifiers(Tree declaratorTree, TapList<String> modifiers)
   :outertype: TypeSpec

   Utility for generateTree(): modifies and/or returns declaratorTree to add the given modifiers.

addDiffTypeSpec
^^^^^^^^^^^^^^^

.. java:method:: protected void addDiffTypeSpec(SymbolTable symbolTable, SymbolTable srcSymbolTable)
   :outertype: TypeSpec

   Only for association by address.

addInTypeDeclNames
^^^^^^^^^^^^^^^^^^

.. java:method:: public void addInTypeDeclNames(Unit unit, String name)
   :outertype: TypeSpec

addMultiDirDimension
^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec addMultiDirDimension(ArrayDim dimension)
   :outertype: TypeSpec

addTypeModifiers
^^^^^^^^^^^^^^^^

.. java:method:: public static Tree addTypeModifiers(Tree typeTree, TapList<Tree> modifiers)
   :outertype: TypeSpec

   Utility for generateTree(): modifies and/or returns typeTree to add the given modifiers.

addUsedSymbolsInType
^^^^^^^^^^^^^^^^^^^^

.. java:method:: public void addUsedSymbolsInType(TapList<SymbolDecl> dependsOn, SymbolTable symbolTable)
   :outertype: TypeSpec

   Augments the given (hatted) list dependsOn with the SymbolDecl's of all symbols used in this type.

baseTypeName
^^^^^^^^^^^^

.. java:method:: protected abstract String baseTypeName()
   :outertype: TypeSpec

   :return: a name for the base type of this type, when this makes sense.

baseTypeSpec
^^^^^^^^^^^^

.. java:method:: public WrapperTypeSpec baseTypeSpec(boolean stopOnPointer)
   :outertype: TypeSpec

   :param stopOnPointer: when false, will also go down into pointers destination type
   :return: the base type found.

build
^^^^^

.. java:method:: public static WrapperTypeSpec build(Tree typeTree, SymbolTable symbolTable, Instruction instruction, TapList<SymbolDecl> toTypeUsedSymbols, TapList<String> toSymbolDeclInfos, TapList<String> toSymbolDeclAccess, ToBool isPointer, WrapperTypeSpec currentBuiltTypeSpec)
   :outertype: TypeSpec

   Build a TypeSpec from a tree.

   :param typeTree: tree representing a type.
   :param symbolTable: current symbolTable.
   :param instruction: Instruction containing the type definition.
   :param toTypeUsedSymbols: types used in the definition.
   :param toSymbolDeclInfos: type modifiers.
   :param toSymbolDeclAccess: type access modifiers.
   :param isPointer: pointer or not pointer.
   :param currentBuiltTypeSpec: for recursive type definition.
   :return: a typeSpec.

buildConstantOne
^^^^^^^^^^^^^^^^

.. java:method:: public Tree buildConstantOne()
   :outertype: TypeSpec

   :return: a Tree that is a "one" of this type, whenever it is defined.

buildConstantZero
^^^^^^^^^^^^^^^^^

.. java:method:: public Tree buildConstantZero()
   :outertype: TypeSpec

   :return: a Tree that is a "zero" of this type, whenever it is defined. For pointer type, this is the null pointer.

canCompare
^^^^^^^^^^

.. java:method:: protected static boolean canCompare(WrapperTypeSpec type1, WrapperTypeSpec type2)
   :outertype: TypeSpec

checkTypeSpecValidity
^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected boolean checkTypeSpecValidity(TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   Checks that this type is valid, i.e. contains no gaping hole and is not circular.

cloneAsUndefinedNumeric
^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec cloneAsUndefinedNumeric(boolean undefined)
   :outertype: TypeSpec

   :return: a copy of this type with "undefinedNumeric" in its numeric leaf type set to the given boolean "undefined".

collectUsedTrees
^^^^^^^^^^^^^^^^

.. java:method:: public void collectUsedTrees(TapList<Tree> toUsedTrees, TapList<TypeSpec> toDejaVu)
   :outertype: TypeSpec

   Collects into toUsedTrees all the symbol Trees used in this type.

combineWith
^^^^^^^^^^^

.. java:method:: protected TypeSpec combineWith(TypeSpec newActualTypeSpec, SymbolTable symbolTable)
   :outertype: TypeSpec

   Combination of two TypeSpec's. Combines, when possible, this current TypeSpec with a new one "newActualTypeSpec". If the combination succeeds, returns the combined TypeSpec. Otherwise returns null. Warning, both this and newActualTypeSpec may be modified. Warning: source language dependent!!!!

comparesWith
^^^^^^^^^^^^

.. java:method:: public boolean comparesWith(TypeSpec other, int comparison, TypeSpec toThis, TypeSpec toOther, TapList<TapPair<TypeSpec, TypeSpec>> dejaVu)
   :outertype: TypeSpec

   Perform "comparison" of this type with an "other" type, with possible type inference by side-effect.

   :param other: The other type, with respect to which comparison is made.
   :param comparison: the comparison performed. See possible comparisons in the comments around showComparison() If comparison allows for type inference, then the types wrapped immediately around this and other should be provided in toThis and toOther, otherwise type inference will not be done at the top level of types.
   :param toThis: the TypeSpec immediately containing this type. Useful only if type inference is requested, otherwise may be null.
   :param toOther: the TypeSpec immediately containing the other type. Useful only if type inference is requested, otherwise may be null.
   :param dejaVu: the list of type pairs already being compared as "this" vs. "other", and being the destination of some pointer type. This classically avoids infinite loops in cycles of types.
   :return: true if this type compares well according to "comparison" with the "other" type.

computeSize
^^^^^^^^^^^

.. java:method:: protected int computeSize()
   :outertype: TypeSpec

   Utility for size(). Use size() instead.

containsAPointer
^^^^^^^^^^^^^^^^

.. java:method:: public boolean containsAPointer()
   :outertype: TypeSpec

   :return: true if this type is a pointer or at least contains a pointer field.

containsArray
^^^^^^^^^^^^^

.. java:method:: public boolean containsArray()
   :outertype: TypeSpec

containsMetaType
^^^^^^^^^^^^^^^^

.. java:method:: protected boolean containsMetaType(TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   :param dejaVu: List of dejaVu sub-types, to avoid looping. Pass null at call.
   :return: true when some component of this type is an unsolved TypeSpec, because it contains either a MetaTypeSpec or an unknown array (or pointer) dimension.

containsUndefinedType
^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean containsUndefinedType()
   :outertype: TypeSpec

containsUnknownDimension
^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean containsUnknownDimension()
   :outertype: TypeSpec

   :return: true when this type has at least one dimension which is not known explicitly.

copy
^^^^

.. java:method:: public TypeSpec copy()
   :outertype: TypeSpec

   :return: a copy of this type, copying recursively inside the nested types tree structure, but stopping copy (i.e. returning the same objects) for the fields of a CompositeTypeSpec, the sub-types of a FunctionTypeSpec, or for MetaTypeSpec, EnumTypeSpec, NamedTypeSpec, VoidTypeSpec.

copyStopOnComposite
^^^^^^^^^^^^^^^^^^^

.. java:method:: public abstract TypeSpec copyStopOnComposite(Unit publishedUnit)
   :outertype: TypeSpec

   :param publishedUnit: when non-null, remove from this type all information that relates to local data of publishedUnit, i.e. that is not visible from outside publishedUnit
   :return: a copy of this type, copying recursively inside the nested types tree structure, but stopping copy (i.e. returning the same objects) for (WrapperTypeSpec's on) CompositeTypeSpec, the sub-types of a FunctionTypeSpec, or for MetaTypeSpec, EnumTypeSpec, NamedTypeSpec, VoidTypeSpec

createOrGetDiffTypeDeclSymbolHolder
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected void createOrGetDiffTypeDeclSymbolHolder(SymbolTable diffSymbolTable, WrapperTypeSpec diffTypeSpec, String fSuffix)
   :outertype: TypeSpec

   only for association By Address.

cumulActiveParts
^^^^^^^^^^^^^^^^

.. java:method:: protected void cumulActiveParts(TapList diffInfos, SymbolTable symbolTable)
   :outertype: TypeSpec

   Accumulates into this type and into its sub-types, the given information about which types parts (e.g. named types, record fields..) are used as active, which implies that they must have a differentiated counterpart in the differentiate type of this type.

differentiateTypeSpec
^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public WrapperTypeSpec differentiateTypeSpec(SymbolTable symbolTable, SymbolTable srcSymbolTable, int diffUnitSort, String fSuffix, boolean localDecl, boolean multiDirMode, ArrayDim multiDirDimensionMax, String hintArrayNameInText, String hintArrayNameInIdent, Tree hintArrayNameTree, Tree nameTree)
   :outertype: TypeSpec

   :return: the differentiated counterpart of this type, which is assumed differentiable. Returning null means that the differentiated counterpart is exactly the same as this type. The returned type is different from "this" either if the differentiated element type is different, or if dimensions must change, e.g. vector mode, or F90 using dimension "*" which must be replaced by ":" in the diff type.

dispatchModifiers
^^^^^^^^^^^^^^^^^

.. java:method:: protected static int dispatchModifiers(Tree[] modifiersTrees, Tree modifiedTree, TapPair<Tree, ArrayDim[]> sizeAndDims, ToBool isPointer, TapList<String> toSymbolDeclInfos, TapList<String> toSymbolDeclAccess, TapList<SymbolDecl> toTypeUsedSymbols, Tree typeTree, Instruction instruction, SymbolTable symbolTable)
   :outertype: TypeSpec

   Dispatch modifiers: -- "type size" modifiers are combined into one "sizeTypeModifier", that will be stored eventually in the returned ModifiedTypeSpec -- "signed" and "unsigned" modifiers are collected into int "typeSign" (default 0) which will be stored eventually in the returned ModifiedTypeSpec (similarly to "type size" modifiers) -- "dimension" modifiers are collected into "dimensions" and used eventually to build an ArrayTypeSpec layer in the returned ModifiedTypeSpec -- "pointer" modifiers sets boolean "isPointer", that will be used eventually to add a pointer layer at the appropriate location in the SymbolDecl's type. -- "accessDecl(bind,...)" modifiers are directly attached to the Instruction.tree -- "restrict", "const"... modifiers are collected into "toSymbolDeclAccess" and will be stored eventually into the "subAccessInfo" of the enclosing TypeSpec or of the SymbolDecl -- all other modifiers are collected into "toSymbolDeclInfos", that will be stored eventually into the "extraInfo" of the SymbolDecl (but maybe they should all be treated like "const" etc ?)

doUpdateAfterImports
^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected void doUpdateAfterImports(SymbolTable symbolTable, TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   Utility for updateAfterImports(). Don't use otherwise!

dump
^^^^

.. java:method:: public void dump() throws java.io.IOException
   :outertype: TypeSpec

   Prints in detail the contents of this type, onto TapEnv.curOutputStream().

elementType
^^^^^^^^^^^

.. java:method:: public WrapperTypeSpec elementType()
   :outertype: TypeSpec

   :return: the type of the elements of the deepest array type in this type.

equalsCompilDep
^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsCompilDep(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is equal to the other, in a rather laxist way since this uses knowledge about the specific compiler/platform default choices.

equalsCompilDepNeglectLengthes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsCompilDepNeglectLengthes(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is equal to the other, in a laxist way that compares the number of dimensions but not their lengthes, and additionally accepts vectorial notation (i.e. array:this vs scalar:other), and in the "compile-dep" way regarding primitive type sizes.

equalsCompilIndep
^^^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsCompilIndep(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is equal to the other, in a rather strict way since equality must remain whatever the specific compiler/platform default choices.

equalsLiterally
^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsLiterally(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is litterally equal to the other. When dimensions are given after a dimension of some reference array (ArrayDim.refArrayTree), equality is true iff the reference array and dimension are the same.

equalsNeglectSizes
^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsNeglectSizes(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is equal to the other, in a very laxist way since we don't care about different type precision at the leaf primitive types, and additionally accept vectorial notation (i.e. array:this vs scalar:other).

equalsNeglectSizesNeglectLengthes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean equalsNeglectSizesNeglectLengthes(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type is equal to the other, in a laxist way that compares the number of dimensions but not their lengthes and additionally accepts vectorial notation (i.e. array:this vs scalar:other), and not caring about different type precision at the leaf primitive types.

findAlreadyCopiedType
^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec findAlreadyCopiedType(TapList<TapTriplet<TypeSpec, TypeSpec, Boolean>> toAlreadyCopied, ToBool containsMeta)
   :outertype: TypeSpec

findFunctionTypeSpecUnderTypeSpec
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static FunctionTypeSpec findFunctionTypeSpecUnderTypeSpec(WrapperTypeSpec typeSpec)
   :outertype: TypeSpec

findShortName
^^^^^^^^^^^^^

.. java:method:: protected String findShortName(TapList<SymbolDecl> dependsOn, TapList<SymbolDecl> shortNames)
   :outertype: TypeSpec

   Utility for generateTree(): finds a short name for this type, if it exists.

genTypeDeclName
^^^^^^^^^^^^^^^

.. java:method:: protected String genTypeDeclName()
   :outertype: TypeSpec

generateDeclaratorTree
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public static Tree generateDeclaratorTree(WrapperTypeSpec stoppingTypeSpec, TapList<SymbolDecl> declaredTypes, Tree declarator, WrapperTypeSpec typeSpec)
   :outertype: TypeSpec

   :return: a declarator tree built by wrapping declarator layers around the given declarator tree "declarator", each added declarator layer corresponding to the successive nested type layers in "typeSpec", but stopping when reaching the type layer "stoppingTypeSpec".

generateTree
^^^^^^^^^^^^

.. java:method:: public Tree generateTree(SymbolTable symbolTable, TapList<SymbolDecl> dependsOn, TapList<SymbolDecl> shortNames, boolean useShortNames, TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   Generate a Tree for this type.

   :param symbolTable: The SymbolTable context where the generated Tree will appear.
   :param dependsOn: ?used during findShortName()?
   :param shortNames: The list of types that have a short name.
   :param useShortNames: When true, if this type has a short name in "shortNames", the generated Tree will simply use that name. Set it to false to avoid silly "typedef truc=truc ;".
   :return: A Tree that stands for this type.

getAllDimensions
^^^^^^^^^^^^^^^^

.. java:method:: public TapList<ArrayDim> getAllDimensions()
   :outertype: TypeSpec

   :return: the list of all dimensions of this type and its nested types, in the C-like order i.e. outside/slow dimensions first. Doesn't go into pointers nor into function or composite types.

getRenamedTypeDeclName
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public static String getRenamedTypeDeclName(TapList<TapPair<Unit, String>> typeDeclNames, Unit inUnit)
   :outertype: TypeSpec

getRenamedTypeDeclName
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public String getRenamedTypeDeclName(Unit inUnit)
   :outertype: TypeSpec

hasUndefinedSize
^^^^^^^^^^^^^^^^

.. java:method:: protected boolean hasUndefinedSize()
   :outertype: TypeSpec

ignoreTypeDeclName
^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean ignoreTypeDeclName(String typeDeclName)
   :outertype: TypeSpec

intToReal
^^^^^^^^^

.. java:method:: public TypeSpec intToReal(TapList<TapPair<TypeSpec, TypeSpec>> dejaVu, SymbolTable symbolTable)
   :outertype: TypeSpec

   When this type is non-differentiable (e.g. integer), returns a copied type with integers replaced with reals. Otherwise returns the original type.

   :param dejaVu: List of dejaVu sub-types, to avoid looping. Pass null at call.

isA
^^^

.. java:method:: public static boolean isA(TypeSpec type, int kind)
   :outertype: TypeSpec

   :param kind: may be ACTUALTYPE, ARRAYTYPE, FUNCTIONTYPE, LABELTYPE MOFIFIEDTYPE, PRIMITIVETYPE, COMPOSITETYPE, POINTERTYPE, VOIDTYPE, METATYPE (defined in SymbolTableConstants).
   :return: true when this TypeSpec is of the given kind "testKind" Skips over layers of WrapperTypeSpec's.

isAnIOTypeSpec
^^^^^^^^^^^^^^

.. java:method:: protected boolean isAnIOTypeSpec(SymbolTable symbolTable)
   :outertype: TypeSpec

   :return: true when this type is the C predefined type FILE or IO_FILE.

isArray
^^^^^^^

.. java:method:: public boolean isArray()
   :outertype: TypeSpec

   :return: true if this is an array type.

isAugmentedDoubleBase
^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean isAugmentedDoubleBase()
   :outertype: TypeSpec

   :return: true if the base of this type is the augmented type for overloading-based AD.

isBooleanBase
^^^^^^^^^^^^^

.. java:method:: public boolean isBooleanBase()
   :outertype: TypeSpec

   :return: true if the base of this type is "boolean".

isCharacter
^^^^^^^^^^^

.. java:method:: public boolean isCharacter()
   :outertype: TypeSpec

   :return: true if this type is a character type.

isComplexBase
^^^^^^^^^^^^^

.. java:method:: public boolean isComplexBase()
   :outertype: TypeSpec

   :return: true if the base of this type is "complex".

isDifferentiablePlainType
^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean isDifferentiablePlainType()
   :outertype: TypeSpec

   :return: true if this type is a PRIMITIVETYPE, possibly wrapped in MODIFIEDTYPE's, and its primitive type is differentiable.

isDifferentiableType
^^^^^^^^^^^^^^^^^^^^

.. java:method:: public static boolean isDifferentiableType(TypeSpec actualTypeSpec)
   :outertype: TypeSpec

   True if the given type is possibly differentiable i.e. contains some continuous component such as a float. This is weaker than isDifferentiated(), which checks that at least one variable of this type has been found active.

   :param actualTypeSpec: the given type
   :return: true if the given "actualTypeSpec" is possibly differentiable.

isDifferentiated
^^^^^^^^^^^^^^^^

.. java:method:: public boolean isDifferentiated(TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   :param dejaVu: List of dejaVu sub-types, to avoid looping. Pass null at call.
   :return: true if at least one variable with this type has at least one active part. This is stronger than isDifferentiableType() i.e. this.isDifferentiated() ⇒ isDifferentiableType(this).

isFunction
^^^^^^^^^^

.. java:method:: public boolean isFunction()
   :outertype: TypeSpec

   :return: true if this type is a function type.

isIntegerBase
^^^^^^^^^^^^^

.. java:method:: public boolean isIntegerBase()
   :outertype: TypeSpec

   :return: true if the base of this type is "integer".

isNamedType
^^^^^^^^^^^

.. java:method:: public boolean isNamedType()
   :outertype: TypeSpec

   :return: true if this is a plain named type, i.e. a placeholder for a type that should be defined elsewhere, later during building the representation.

isNumericBase
^^^^^^^^^^^^^

.. java:method:: public boolean isNumericBase()
   :outertype: TypeSpec

   :return: true if the base of this type is numeric, which means either integer or real or complex (or boolean or char in C).

isPointer
^^^^^^^^^

.. java:method:: public boolean isPointer()
   :outertype: TypeSpec

   :return: true if this type is a pointer type.

isProbablyRealOrComplexBase
^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method::  boolean isProbablyRealOrComplexBase()
   :outertype: TypeSpec

   :return: true if the base of this type is either "float" or "complex" or a yet undefined type which can/will be only "float" or "complex".

isRealBase
^^^^^^^^^^

.. java:method:: public boolean isRealBase()
   :outertype: TypeSpec

   :return: true if the base of this type is "float".

isRealOrComplexBase
^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean isRealOrComplexBase()
   :outertype: TypeSpec

   :return: true if the base of this type is either "float" or "complex", which means a type that may be differentiated.

isScalar
^^^^^^^^

.. java:method:: public boolean isScalar()
   :outertype: TypeSpec

isString
^^^^^^^^

.. java:method:: public boolean isString()
   :outertype: TypeSpec

   :return: true if this type is a string type, i.e. a one-dimensional array of characters.

isTarget
^^^^^^^^

.. java:method:: public boolean isTarget()
   :outertype: TypeSpec

   :return: true if this type is declared as a pointer "target".

isUndefinedNumeric
^^^^^^^^^^^^^^^^^^

.. java:method:: protected boolean isUndefinedNumeric()
   :outertype: TypeSpec

kind
^^^^

.. java:method:: public int kind()
   :outertype: TypeSpec

   The particular type sub-kind of this TypeSpec.

localize
^^^^^^^^

.. java:method:: protected TypeSpec localize(TapList<TapTriplet<TypeSpec, TypeSpec, Boolean>> toAlreadyCopied, ToBool containsMeta)
   :outertype: TypeSpec

   :param toAlreadyCopied: the hatted A-list from each original sub-type to its copy plus a boolean which is true iff the original sub-type contains a meta Type.
   :param containsMeta: contains true upon return iff this type contains a Meta sub-type. We assume containsMeta is initialized upon false upon call.
   :return: the copied type.

modifiedBaseTypeSpec
^^^^^^^^^^^^^^^^^^^^

.. java:method:: public WrapperTypeSpec modifiedBaseTypeSpec()
   :outertype: TypeSpec

   :return: the ModifiedTypeSpec around the base of this type. If no ModifiedTypeSpec around, returns the same as baseTypeSpec(false).

needsADiffType
^^^^^^^^^^^^^^

.. java:method:: public boolean needsADiffType(TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   :param dejaVu: TapList of TypeSpec
   :return: true iff there must be a differentiated type for this type, different from this type. For instance a record with all fields passive need no diff type, and a record with all fields completely active, do not need a diff type either because the original type also works as well. Also note that in modes associationByAddress, float types and also records with all fields completely active DO need a diff type, because float type is replaced by a special type aka "aDouble".

nestedLevelType
^^^^^^^^^^^^^^^

.. java:method:: public TypeSpec nestedLevelType()
   :outertype: TypeSpec

   :return: the nested type, or null when there is no meaningful nested type.

peelArrayDimsAroundComposite
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static TapPair<WrapperTypeSpec, ArrayDim[]> peelArrayDimsAroundComposite(WrapperTypeSpec typeSpec)
   :outertype: TypeSpec

   Peels all array dimensions around the given type, until it reaches a composite type or a leaf type.

   :return: a TapPair of (1) the bottom composite or leaf type found and of (2) the array of ArrayDim objects that were found on the way.

peelDimensionsTo
^^^^^^^^^^^^^^^^

.. java:method:: public TypeSpec peelDimensionsTo(TypeSpec type, TypeSpec toType, TapList<ArrayDim> toDimensions)
   :outertype: TypeSpec

peelPointer
^^^^^^^^^^^

.. java:method:: protected TypeSpec peelPointer()
   :outertype: TypeSpec

   Assuming that this type is a pointer type,

   :return: the inside pointed type.

peelSizeModifier
^^^^^^^^^^^^^^^^

.. java:method:: public static WrapperTypeSpec peelSizeModifier(WrapperTypeSpec typeSpec, ToObject<ModifiedTypeSpec> toModifiedType)
   :outertype: TypeSpec

peelSizeModifiersTo
^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec peelSizeModifiersTo(TypeSpec type, TypeSpec toType, ToObject<Tree> toModifierTree, ToObject<ModifiedTypeSpec> toModifiedTypeSpec, boolean remainLitteral)
   :outertype: TypeSpec

   :param toModifiedTypeSpec: when given non-null, contains upon exit the deepest ModifiedTypeSpec found.

peelWrapperAndModified
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec peelWrapperAndModified(TypeSpec typeSpec)
   :outertype: TypeSpec

peelWrapperAndModifiedTo
^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec peelWrapperAndModifiedTo(TypeSpec type, TypeSpec toType)
   :outertype: TypeSpec

peelWrapperTo
^^^^^^^^^^^^^

.. java:method:: protected TypeSpec peelWrapperTo(TypeSpec type, TypeSpec toType)
   :outertype: TypeSpec

preciseDimensions
^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec preciseDimensions(TypeSpec complementType, TapList<TapPair<TypeSpec, TypeSpec>> dejaVu, SymbolTable symbolTable)
   :outertype: TypeSpec

   Try and refine the dimension information inside this type, by matching it with the given complementType, which has the same structure.

   :param dejaVu: List of dejaVu sub-types, to avoid looping. Pass null at call.

precisionSize
^^^^^^^^^^^^^

.. java:method:: public int precisionSize()
   :outertype: TypeSpec

   :return: the size in bytes of this numeric type, or -1 for unknown, or -2, -3, or -4 for double,short,or quadruple.

realToComplex
^^^^^^^^^^^^^

.. java:method:: protected TypeSpec realToComplex(TapList<TapPair<TypeSpec, TypeSpec>> dejaVu, WrapperTypeSpec complexTypeSpec)
   :outertype: TypeSpec

receives
^^^^^^^^

.. java:method:: public boolean receives(TypeSpec other, TypeSpec toThis, TypeSpec toOther)
   :outertype: TypeSpec

   Test that this type can receive a value of the other type, performing type inference if needed and possible, and allowing array operations in the style of F90.

receivesNoInferenceNoVector
^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean receivesNoInferenceNoVector(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type can receive a value of the other type, but without allowing type inference and without allowing F90-style array notation.

receivesNoVector
^^^^^^^^^^^^^^^^

.. java:method:: public boolean receivesNoVector(TypeSpec other, TypeSpec toThis, TypeSpec toOther)
   :outertype: TypeSpec

   :return: true it this type can receive a value of the other type, performing type inference if needed and possible, but without allowing array operations in the style of F90.

receivesNoVectorNeglectSizes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean receivesNoVectorNeglectSizes(TypeSpec other, TypeSpec toThis, TypeSpec toOther)
   :outertype: TypeSpec

   :return: true it this type can receive a value of the other type, performing type inference if needed and possible, and not caring about different type precision at the leaf primitive types, but without allowing array operations in the style of F90.

receivesVectorNeglectSizes
^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: public boolean receivesVectorNeglectSizes(TypeSpec other)
   :outertype: TypeSpec

   :return: true if this type can receive a value of the other type, without trying type inference, neglecting mismatches of array length and allowing array operations in the style of F90.

setHasUndefinedSize
^^^^^^^^^^^^^^^^^^^

.. java:method:: protected void setHasUndefinedSize(boolean val)
   :outertype: TypeSpec

setOrAddTypeDeclName
^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected void setOrAddTypeDeclName(String name)
   :outertype: TypeSpec

setTypeDeclName
^^^^^^^^^^^^^^^

.. java:method:: protected void setTypeDeclName(String name)
   :outertype: TypeSpec

setTypeDeclNames
^^^^^^^^^^^^^^^^

.. java:method:: public void setTypeDeclNames(TapList<TapPair<Unit, String>> tDeclNames)
   :outertype: TypeSpec

setUndefinedNumeric
^^^^^^^^^^^^^^^^^^^

.. java:method:: protected void setUndefinedNumeric(boolean value)
   :outertype: TypeSpec

setWrappedType
^^^^^^^^^^^^^^

.. java:method:: public void setWrappedType(TypeSpec type)
   :outertype: TypeSpec

shareActiveFields
^^^^^^^^^^^^^^^^^

.. java:method:: protected void shareActiveFields(TypeSpec referenceType)
   :outertype: TypeSpec

   Make sure that this type shares the activity information of the given reference type. This is needed e.g when actual type and formal type of a procedure call are two a priori different types (of course such that formalType can "receives" actualType), and they both contain structs: the actual type must share the field activity information of the formal.

showComparison
^^^^^^^^^^^^^^

.. java:method:: public static String showComparison(int comparison)
   :outertype: TypeSpec

showType
^^^^^^^^

.. java:method:: public String showType()
   :outertype: TypeSpec

   :return: a String that shows this type, with the usual syntax of the current language.

size
^^^^

.. java:method:: public int size()
   :outertype: TypeSpec

   :return: (and stores for later reference) the memory size in bytes occupied by objects of this type.

testAcceptsUnspecified
^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testAcceptsUnspecified(int comparison)
   :outertype: TypeSpec

testAllowsVectorial
^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testAllowsVectorial(int comparison)
   :outertype: TypeSpec

testComparesWith
^^^^^^^^^^^^^^^^

.. java:method:: protected abstract boolean testComparesWith(TypeSpec other, int comparison, TypeSpec toThis, TypeSpec toOther, TapList<TapPair<TypeSpec, TypeSpec>> dejaVu)
   :outertype: TypeSpec

   Really does the work of comparison at the current type level of "this".

testHasInference
^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testHasInference(int comparison)
   :outertype: TypeSpec

testIsEquals
^^^^^^^^^^^^

.. java:method:: protected static boolean testIsEquals(int comparison)
   :outertype: TypeSpec

testIsReceives
^^^^^^^^^^^^^^

.. java:method:: protected static boolean testIsReceives(int comparison)
   :outertype: TypeSpec

testIsReceivesWithInference
^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testIsReceivesWithInference(int comparison)
   :outertype: TypeSpec

testLooksDimensionLength
^^^^^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testLooksDimensionLength(int comparison)
   :outertype: TypeSpec

testSetEquals
^^^^^^^^^^^^^

.. java:method:: protected static int testSetEquals(int comparison)
   :outertype: TypeSpec

testTypesCompilDep
^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testTypesCompilDep(int comparison)
   :outertype: TypeSpec

testTypesLitteral
^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testTypesLitteral(int comparison)
   :outertype: TypeSpec

testTypesWithoutSize
^^^^^^^^^^^^^^^^^^^^

.. java:method:: protected static boolean testTypesWithoutSize(int comparison)
   :outertype: TypeSpec

testUnsetInference
^^^^^^^^^^^^^^^^^^

.. java:method:: protected static int testUnsetInference(int comparison)
   :outertype: TypeSpec

toString
^^^^^^^^

.. java:method:: @Override public String toString()
   :outertype: TypeSpec

typeDeclName
^^^^^^^^^^^^

.. java:method:: public String typeDeclName()
   :outertype: TypeSpec

typeDeclNames
^^^^^^^^^^^^^

.. java:method:: public TapList<TapPair<Unit, String>> typeDeclNames()
   :outertype: TypeSpec

updateAfterImports
^^^^^^^^^^^^^^^^^^

.. java:method:: public void updateAfterImports(SymbolTable symbolTable, TapList<TypeSpec> dejaVu)
   :outertype: TypeSpec

   Updates this type with the full information available from the given "symbolTable" and from the other symbol tables that it imports. Example: a type may use a variable name (for size, dimension...) that was not known before all symbols from USE'd Modules have been imported.

weakenForInference
^^^^^^^^^^^^^^^^^^

.. java:method:: protected TypeSpec weakenForInference(int comparison)
   :outertype: TypeSpec

   :return: a copy of this type where some details are left unspecified because type inference is unable to determine them for sure (for this sort of comparison).

wrappedType
^^^^^^^^^^^

.. java:method:: public TypeSpec wrappedType()
   :outertype: TypeSpec

   :return: wrappedType or elementType or destinationType or returnType.