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

    • CPP_PACKAGE_SEPARATOR

      public static final String CPP_PACKAGE_SEPARATOR
      C++ package separator.
      See Also:

    • CPP_TEMPLATE_REGEXP

      public static final Pattern CPP_TEMPLATE_REGEXP
      C++ template detection pattern.

    • keywords

      public static final Set<String> keywords
      Reserved native type keywords.

    • TYPESOURCE_INUSE

      public static final int TYPESOURCE_INUSE
      Retrieve types currently in use.
      See Also:

    • TYPESOURCE_TYPELIBS

      public static final int TYPESOURCE_TYPELIBS
      Retrieve types from loaded type libraries.
      See Also:

    • TYPESOURCE_ALL

      public static final int TYPESOURCE_ALL
      Retrieve all available types.
      See Also:

  • Method Details

    • isKeyword

      public static boolean isKeyword(String s)
      Determine whether a string is a reserved keyword.
      Parameters:
      s - string to test
      Returns:
      true if the string is a keyword

    • isReservedLiteral

      public static boolean isReservedLiteral(String s)
      Determine whether a string is a reserved literal.
      Parameters:
      s - string to test
      Returns:
      true if the string is reserved

    • isValidPackageName

      public static boolean isValidPackageName(String s)
      Determine whether a package name is valid.
      Parameters:
      s - package name
      Returns:
      true if the package name is valid

    • isValidTypeName

      public static boolean isValidTypeName(String s)
      Determine whether a type name is valid.
      Parameters:
      s - type name
      Returns:
      true if the type name is valid

    • 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:
      true if the name is valid

    • splitCppName

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

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

      Parameters:
      fullName - full C++ name
      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<int>::pkg:titi, long' will be split into [std<int>::pkg:titi, long]

      Parameters:
      parameters - C++ parameter list
      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)
      Normalize a signature for quick parsing.
      Parameters:
      signature - signature to normalize
      Returns:
      never return null

    • buildFullyQualifiedTypeNameFromElements

      public static String buildFullyQualifiedTypeNameFromElements(List<String> elements)
      Build a fully qualified type name from name elements.
      Parameters:
      elements - name elements
      Returns:
      fully qualified type name

    • buildQuick

      public static INativeType buildQuick(ITypeManager typeman, String signature)
      Build a type or prototype from a simple signature.
      Parameters:
      typeman - type manager
      signature - type or prototype signature
      Returns:
      native type, or null

    • 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 - type manager
      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 - type manager
      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)
      Determine if a type is primitive.
      Parameters:
      t - type
      Returns:
      true if primitive

    • isReference

      public static boolean isReference(INativeType t)
      Determine if a type is a reference.
      Parameters:
      t - type
      Returns:
      true if reference

    • isPrototype

      public static boolean isPrototype(INativeType t)
      Determine if a type is a prototype.
      Parameters:
      t - type
      Returns:
      true if prototype

    • isSimple

      public static boolean isSimple(INativeType t)
      Determine if a type is a simple type.
      Parameters:
      t - type
      Returns:
      true if primitive, reference, or prototype

    • isAlias

      public static boolean isAlias(INativeType t)
      Determine if a type is an alias.
      Parameters:
      t - type
      Returns:
      true if alias

    • getNonAlias

      public static INativeType getNonAlias(INativeType t)
      Retrieve the non-aliased type.
      Parameters:
      t - type
      Returns:
      non-aliased type

    • getNonAlias

      public static <T extends INativeType> T getNonAlias(INativeType t, Class<T> expected)
      Retrieve the non-aliased type and cast it to an expected type.
      Type Parameters:
      T - expected type
      Parameters:
      t - type
      expected - expected class
      Returns:
      non-aliased type

    • 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)
      Determine if a type can be used for bitfields.
      Parameters:
      t - type
      Returns:
      true if bitfield-compatible

    • areBitfielTypesEquivalent

      public static boolean areBitfielTypesEquivalent(INativeType a, INativeType b)
      Determine if two bitfield types are equivalent.
      Parameters:
      a - first type
      b - second type
      Returns:
      true if equivalent

    • isPointer

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

    • isPointerToPointer

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

    • isCompositeType

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

    • 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 - type
      Returns:
      true if the type is a function pointer

    • 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)
      Determine if a type is void.
      Parameters:
      t - type
      Returns:
      true if void

    • isVoidPointer

      public static boolean isVoidPointer(INativeType t)
      Determine if a type is a pointer to void.
      Parameters:
      t - type
      Returns:
      true if pointer to void

    • isCharacter

      public static boolean isCharacter(INativeType t)
      Determine if a type is a character type.
      Parameters:
      t - type
      Returns:
      true if character

    • isInteger

      public static boolean isInteger(INativeType t)
      Determine if a type is an integer type.
      Parameters:
      t - type
      Returns:
      true if integer

    • isSignedInteger

      public static boolean isSignedInteger(INativeType t)
      Determine if a type is a signed integer type.
      Parameters:
      t - type
      Returns:
      true if signed integer

    • isUnsignedInteger

      public static boolean isUnsignedInteger(INativeType t)
      Determine if a type is an unsigned integer type.
      Parameters:
      t - type
      Returns:
      true if unsigned integer

    • isFloat

      public static boolean isFloat(INativeType t)
      Determine if a type is a floating-point type.
      Parameters:
      t - type
      Returns:
      true if floating-point

    • collectTypes

      public static List<INativeType> collectTypes(IPrototypeItem proto)
      Collect the native types referenced by a prototype.
      Parameters:
      proto - prototype
      Returns:
      return and parameter types

    • 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 - type
      Returns:
      first simple type, or null

    • 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 - 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 - type manager
      protoString - see format above
      Returns:
      a prototype item, null on error
      See Also:

    • retrieveAvailableTypes

      public static List<INativeType> retrieveAvailableTypes(INativeCodeUnit<?> unit, int sourceFlags)
      Retrieve available types.
      Parameters:
      unit - native code unit
      sourceFlags - type source flags
      Returns:
      available types

    • retrieveAvailableTypes

      public static List<INativeType> retrieveAvailableTypes(INativeCodeUnit<?> unit, int sourceFlags, ISimpleFilter<INativeType> filter)
      Retrieve available types.
      Parameters:
      unit - native code unit
      sourceFlags - type source flags
      filter - optional type filter
      Returns:
      available types

    • generateRoutineSignature

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

    • same

      public static boolean same(INativeType a, INativeType b)
      Determine whether two types are equal after alias resolution.
      Parameters:
      a - first type
      b - second type
      Returns:
      true if the types are the same

    • getLayoutInfo

      public static TypeLayoutInfo getLayoutInfo(INativeType t)
      Get type layout information.
      Parameters:
      t - type
      Returns:
      layout information

    • clearCache

      public static void clearCache()
      Clear internal caches.

    • 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