Package com.pnfsoftware.jeb.core.units.code.asm.type

Class TypeUtil

java.lang.Object
com.pnfsoftware.jeb.core.units.code.asm.type.TypeUtil
public class TypeUtil extends Object
Utility routines for native types.

  • Field Details

  • Constructor Details

    • TypeUtil

      public TypeUtil()

  • Method Details

    • isKeyword

      public static boolean isKeyword(String s)

    • isReservedLiteral

      public static boolean isReservedLiteral(String s)

    • isValidPackageName

      public static boolean isValidPackageName(String s)

    • isValidTypeName

      public static boolean isValidTypeName(String s)

    • containsCppSeparator

      public static boolean containsCppSeparator(String name)
      Fast check, equivalent to string.contains(CPP_PACKAGE_SEPARATOR).
      Parameters:
      name - Potential CPP name with pacakges
      Returns:
      true if string contains a CPP package separator. See splitCppName(String) to retrieve CPP elements.

    • isValidFullyQualifiedName

      public static boolean isValidFullyQualifiedName(String basesig, List<String> elements, String[] aname)
      Parse and validate the elements of a normalized signature (aka fully-qualified name).
      Parameters:
      basesig - normalized signature, dimension-less, reference-less
      elements - optional (output elements)
      aname - optional (output name)
      Returns:

    • splitCppName

      public static List<String> splitCppName(String fullName)
      Split a C++ name using CPP_PACKAGE_SEPARATOR as separator.

      For example, 'std::pkg:titi' will be split into [std, pkg, titi]

      Parameters:
      fullName -
      Returns:
      list of names, never null

    • splitCppParameters

      public static List<String> splitCppParameters(String parameters)
      Split a list of C++ parameters separated by comma. Start/End Parentheses are optional.

      For example, 'std::pkg:titi, long' will be split into ['std::pkg:titi, long]

      Parameters:
      parameters -
      Returns:
      list of parameters, never null

    • processSignature

      public static String processSignature(String signature, int[] counts)
      Process non array or single-dimension arrays of reference or non-reference types.
      Parameters:
      signature - a pre-normalized signature of the type
      counts - optional output array, contains the reference count (0 if none) and the single-dimension array count (-1 if none)
      Returns:
      the base signature (reference-less, dimension-less) of the base type; null on error

    • normalizeSignature

      public static String normalizeSignature(boolean alreadyPreNormalized, String signature, List<String> elements, int[] counts)
      Normalize a type signature (including reference types).

      What it does: Make sure the type separator is "::" (not '.' or '/'). Remove header and trailer whitespace. Remove header "::" if any. Validate signature elements.

      Parameters:
      alreadyPreNormalized - true if the signature has been pre-normalized
      signature - a non-canonical type signature
      elements - optional output list to hold the signature elements of the base type signature
      counts - optional output two-element array, will hold the reference count and the dimension count of the provided signature; refer to processSignature(String, int[])
      Returns:
      the normalized signature, null on error

    • preNormalizeSignature

      public static String preNormalizeSignature(String signature)
      Parameters:
      signature -
      Returns:
      never return null

    • buildFullyQualifiedTypeNameFromElements

      public static String buildFullyQualifiedTypeNameFromElements(List<String> elements)

    • buildQuick

      public static INativeType buildQuick(ITypeManager typeman, String signature)
      Parameters:
      typeman -
      signature -
      Returns:

    • buildQuickType

      public static INativeType buildQuickType(ITypeManager typeman, String signature)
      Create an array or reference type using an existing base type. This method is for convenience only, and by no means exhaustive. Proper type building requires adequate parsing; refer to TLGen. (TODO: bindings to support string type parsing provided by TLGen).
      Parameters:
      typeman -
      signature - accepted signatures: abc, abc*, abc**, abc[6], abc*[10], abc**[20]; other type signatures are not accepted (eg, abc[2][4], abc[4]*, abc**[12], etc.)
      Returns:
      the type item, null on error

    • buildArrayType

      public static INativeType buildArrayType(ITypeManager typeman, String lowestElementSignature, int... dimensions)
      Convenience routine to create an array type, possibly multi-dimensional.
      Parameters:
      typeman -
      lowestElementSignature - finest element type (ideally, should be a non-array)
      dimensions - highest dimensions first, eg, (2, 3, 4) -> type[2][3][4]
      Returns:
      the type

    • isPrimitive

      public static boolean isPrimitive(INativeType t)

    • isReference

      public static boolean isReference(INativeType t)

    • isPrototype

      public static boolean isPrototype(INativeType t)

    • isSimple

      public static boolean isSimple(INativeType t)

    • isAlias

      public static boolean isAlias(INativeType t)

    • getNonAlias

      public static INativeType getNonAlias(INativeType t)

    • getNonAlias

      public static <T extends INativeType> T getNonAlias(INativeType t, Class<T> expected)

    • checkAliasedType

      public static boolean checkAliasedType(INativeType t, INativeType expectedType)
      Check if a type aliases another type.
      Parameters:
      t - the type to be checked
      expectedType - the other type, supposedly aliased by the first parameter
      Returns:
      true or false

    • isBitfieldCompatible

      public static boolean isBitfieldCompatible(INativeType t)

    • areBitfielTypesEquivalent

      public static boolean areBitfielTypesEquivalent(INativeType a, INativeType b)

    • isPointer

      public static boolean isPointer(INativeType t)
      Determine if the (unaliased) type is a reference type.
      Parameters:
      t -
      Returns:

    • isPointerToPointer

      public static boolean isPointerToPointer(INativeType t)
      Determine if the (unaliased) type is a reference to a reference type.
      Parameters:
      t -
      Returns:

    • isCompositeType

      public static boolean isCompositeType(INativeType t)
      Determine if the (unaliased) type is an array or a structure type.
      Parameters:
      t -
      Returns:

    • isFunctionPointer

      public static boolean isFunctionPointer(INativeType t)
      Determine if the provided type is a function pointer, that is, a reference (aliased or not) to a prototype item.
      Parameters:
      t -
      Returns:

    • isFunctionPointer

      public static boolean isFunctionPointer(INativeType t, IPrototypeItem[] aproto)
      Determine if the provided type is a function pointer, that is, a reference (aliased or not) to a prototype item.
      Parameters:
      t - input type
      aproto - optional 1-element array receiving the prototype object on success
      Returns:
      success indicator

    • isVoid

      public static boolean isVoid(INativeType t)

    • isVoidPointer

      public static boolean isVoidPointer(INativeType t)

    • isCharacter

      public static boolean isCharacter(INativeType t)

    • isInteger

      public static boolean isInteger(INativeType t)

    • isSignedInteger

      public static boolean isSignedInteger(INativeType t)

    • isUnsignedInteger

      public static boolean isUnsignedInteger(INativeType t)

    • isFloat

      public static boolean isFloat(INativeType t)

    • collectTypes

      public static List<INativeType> collectTypes(IPrototypeItem proto)

    • findType

      public static List<INativeType> findType(Collection<? extends INativeType> types, String pattern, boolean earlyExitOnFirstMatch)
      Find a type by pattern (partial name or signature, original or effective). Does not include primitives.
      Parameters:
      types - input types
      pattern - type "pattern" (partial name or signature)
      earlyExitOnFirstMatch - exit on first match: the returned list will contain one element
      Returns:
      the list of candidates, possibly empty

    • structureInStructure

      public static boolean structureInStructure(IStructureType structType, INativeType type)
      Detect structure cycles: Determine if the second parameter type is or contains the structure type provided as the first parameter.
      Parameters:
      structType - the input structure
      type - the type to be vetted against the provided structure
      Returns:
      true if a cycle was detected (the test type contains the structure type); false otherwise

    • getFirstSimpleType

      public static INativeType getFirstSimpleType(INativeType type)
      Get the first simple type embedded in the given type.
      Parameters:
      type -
      Returns:

    • getBaseType

      public static INativeType getBaseType(INativeType type)
      Provide the base type of a type. The base type of a pointer type is its non-pointer type; the base type of an array type is its dimension-less type. Primitive, class, structure, union, enumeration and alias types, as well as prototypes, are all considered base types.
      Parameters:
      type -
      Returns:
      the base type of type

    • getStructureField

      public static IStructureTypeField getStructureField(INativeType t, String fieldName)
      Given a structure type (or an alias to one), retrieve the field with the provided name.
      Parameters:
      t - a type whose non-alias should be a structure
      fieldName - a field name
      Returns:
      null if not found or on error

    • getStructureField

      public static IStructureTypeField getStructureField(INativeType t, int fieldStartOffset)
      Given a structure type (or an alias to one), retrieve the field at the provided offset.
      Parameters:
      t - a type whose non-alias should be a structure
      fieldStartOffset - a field offset
      Returns:
      null if not found or on error

    • buildQuickPrototype

      public static IPrototypeItem buildQuickPrototype(ITypeManager typeman, String protoString)
      Generate a simple prototype item from a prototype string. Complex prototypes cannot be parsed by this routine. Prototypes attributes other than var-arg (via `...`) are not supported either. Refer to TypeStringParser for a full-blown C type and prototype parser.

      Format: 

       [<calling-convention>]returnType([param1Type[, param2Type[, ...]]])
      Examples: 
       void()
 int()
 unsigned int(char)
 <cdecl>char(int, int, int)
      Parameters:
      typeman -
      protoString - see format above
      Returns:
      a prototype item, null on error
      See Also:

    • retrieveAvailableTypes

      public static List<INativeType> retrieveAvailableTypes(INativeCodeUnit<?> unit, int sourceFlags)

    • retrieveAvailableTypes

      public static List<INativeType> retrieveAvailableTypes(INativeCodeUnit<?> unit, int sourceFlags, ISimpleFilter<INativeType> filter)

    • generateRoutineSignature

      public static String generateRoutineSignature(String name, IPrototypeItem proto)
      Generate a routine signature given a prototype and a routine name.
      Parameters:
      name -
      proto -
      Returns:

    • same

      public static boolean same(INativeType a, INativeType b)
      Parameters:
      a -
      b -
      Returns:

    • getLayoutInfo

      public static TypeLayoutInfo getLayoutInfo(INativeType t)

    • findShorterForm

      public static INativeType findShorterForm(INativeType _t)
      Attempt to retrieve a type equivalent to the provided input type, but whose string representation is shorter.
      Parameters:
      _t - an input type
      Returns:
      shorter form of the type (e.g. an existing alias), or the same input type if nothing was found