public class

TypeStringParser

extends Object
java.lang.Object
   ↳ com.pnfsoftware.jeb.core.units.code.asm.type.TypeStringParser

Class Overview

A parser for C declarations, types, prototypes and routine signatures.

Examples: 

 ITypeManager typeman = ...;
 IStructureType tHouse = typeman.createStructure("House");
 typeman.addStructureField(tHouse, "field0", typeman.getType("int"));
 
 TypeStringParser parser = new TypeStringParser(typeman);
 parser.parseType("int a;");         // name is optional; semicolon is also optional
 parser.parseType("int");            // name optional; semicolon optional
 parser.parseType("House*");
 parser.parseType("void (*f)()");    // for function pointers, a name (which will be discarded) is mandatory; semicolon is optional
 parser.parseType("char* __cdecl f(int, double);");
 
 // the format for anonymous prototypes is the following (no name; again, final semi-colon optional)
 // anonymous prototypes follow a JEB-custom format: their calling convention precedes the return type, and is stored in angled brackets
 // prototype attributes are not supported
 parser.parsePrototype("void()");
 parser.parsePrototype("int();");
 parser.parsePrototype("int(void)");
 parser.parsePrototype("<__cdecl> int(int)");
 parser.parsePrototype("<__cdecl> int(int, int)");
 parser.parsePrototype("<__cdecl> int(int, char*, ...)");
 
 // signatures: standard C signatures with support for MSVC- and GCC-style attributes
 parser.parseSignature("void __cdecl f()");
 parser.parseSignature("void f(void)");
 parser.parseSignature("void f(int a)");
 parser.parseSignature("void f(unsigned, unsigned int *)");
 parser.parseSignature("void f(int a, void __cdecl (*pf[4])(int a))");
 parser.parseSignature("void f(int a, ...)");
 parser.parseSignature("void f(int a[3])");
 parser.parseSignature("void __attribute__((noreturn)) exit(int code)");  //GCC no-return attribute
 parser.parseSignature("void __cdecl __declspec(noreturn) exit(int)");  //MSVC no-return attribute

Summary

Nested Classes
class TypeStringParser.Decl  
Constants
int DECL
int PROTO
int SIG
int TYPE
Public Constructors
TypeStringParser(ITypeManager typeman)
Create a type parser.
Public Methods
static String massageForDeclaration(String s)
static String massageForType(String s)
static String massageSingleDeclaration(String declstring, boolean discardCppTemplates)
TypeStringParser.Decl parseDeclaration(String s)
Parse a C declaration.
TypeStringParser.Decl parseDeclaration(String s, boolean discardCppTemplates)
Parse a C declaration.
IPrototypeItem parsePrototype(String s)
This method is deprecated. It is recommended to use parseSignature(String) instead.
IPrototypeItem parseSignature(String s, boolean discardCppTemplates)
Parse a C function signature.
IPrototypeItem parseSignature(String s)
Parse a C function signature.
INativeType parseType(String s)
Parse a non-complex C type.
List<INativeType> parseTypesRaw(String s)
Parse any C type or types.
static String removeCppTemplates(String s)
static void verify(int what, String cstr, boolean discardCppTemplates)
This static method can be used to verify that the provided argument looks like a valid C declaration.
static void verifyDeclaration(String declstr, boolean discardCppTemplates)
Basic verification to ensure that the provided string looks like a declaration string.
static void verifySignature(String sigstr, boolean discardCppTemplates)
Basic verification to ensure that the provided string looks like a signature string.
static void verifyType(String typestr, boolean discardCppTemplates)
Basic verification to ensure that the provided string looks like a type string.
[Expand]
Inherited Methods
From class java.lang.Object

Constants

public static final int DECL

Constant Value: 3 (0x00000003)

public static final int PROTO

Constant Value: 1 (0x00000001)

public static final int SIG

Constant Value: 2 (0x00000002)

public static final int TYPE

Constant Value: 0 (0x00000000)

Public Constructors

public TypeStringParser (ITypeManager typeman)

Create a type parser.

Parameters
typeman the type manager to be used as a source of existing types and recipient of newly-parsed types

Public Methods

public static String massageForDeclaration (String s)

public static String massageForType (String s)

public static String massageSingleDeclaration (String declstring, boolean discardCppTemplates)

Throws
TypeStringParseException

public TypeStringParser.Decl parseDeclaration (String s)

Parse a C declaration.

A declaration specifies a type and a name. If you need to parse a pure type, see parseType(String).

Parameters
s declaration, e.g unsigned int a or char* array[3] or void __cdecl (*pf)(int) (a function pointer named pf)
Returns
  • a declaration object (type, name)
Throws
TypeStringParseException

public TypeStringParser.Decl parseDeclaration (String s, boolean discardCppTemplates)

Parse a C declaration.

A declaration specifies a type and a name. If you need to parse a pure type, see parseType(String).

Parameters
s declaration, e.g unsigned int a or char* array[3] or void __cdecl (*pf)(int) (a function pointer named pf)
Returns
  • a declaration (type, name)
Throws
TypeStringParseException

public IPrototypeItem parsePrototype (String s)

This method is deprecated.
It is recommended to use parseSignature(String) instead.

Parse an anonymous prototype written using the following style: 

 <calling-convention> returnType(paramType1 _)
 <calling-convention> returnType(paramType1, paramType2)
 <calling-convention> returnType(paramType1, paramType2, ...)

Parameters
s a JEB-style prototype string
Returns
  • a prototype object
Throws
TypeStringParseException

public IPrototypeItem parseSignature (String s, boolean discardCppTemplates)

Parse a C function signature.

Parameters
s a signature, e.g. int __cdecl foo(int a, unsigned char * b)
discardCppTemplates if true, templated types "<...>" will be erased, thereby making the type potentially parsable as a C type
Returns
  • a prototype item also holding the routine name and parameter names
Throws
TypeStringParseException

public IPrototypeItem parseSignature (String s)

Parse a C function signature.

Parameters
s a signature, e.g. int __cdecl foo(int a, unsigned char * b)
Returns
  • a prototype item also holding the routine name and parameter names
Throws
TypeStringParseException

public INativeType parseType (String s)

Parse a non-complex C type. It is recommended to use parseDeclaration(String) instead when possible.

Parameters
s a type string, e.g unsigned int or char.
Returns
  • never null
Throws
TypeStringParseException

public List<INativeType> parseTypesRaw (String s)

Parse any C type or types.

Parameters
s a string buffer defining types
Returns
  • the list of parsed types
Throws
TypeStringParseException

public static String removeCppTemplates (String s)

Parameters
s a C or C++ declaration or type, possibly with templates
Returns
  • the same C or C++ declaration or type, without templates information

public static void verify (int what, String cstr, boolean discardCppTemplates)

This static method can be used to verify that the provided argument looks like a valid C declaration.

Parameters
what TYPE or SIG
cstr a C declaration or type
discardCppTemplates if true, templated types "<...>" will be erased, thereby making the type potentially parsable as a C type
Throws
TypeStringParseException a parsing error occurred

public static void verifyDeclaration (String declstr, boolean discardCppTemplates)

Basic verification to ensure that the provided string looks like a declaration string.

Throws
TypeStringParseException

public static void verifySignature (String sigstr, boolean discardCppTemplates)

Basic verification to ensure that the provided string looks like a signature string.

Throws
TypeStringParseException

public static void verifyType (String typestr, boolean discardCppTemplates)

Basic verification to ensure that the provided string looks like a type string.

Throws
TypeStringParseException