// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen // SPDX-FileCopyrightText: Copyright (c) 2011 David Gobbi // SPDX-License-Identifier: BSD-3-Clause /** * This file contains extra utilities for parsing and wrapping. */ #ifndef vtkParseExtras_h #define vtkParseExtras_h #include "vtkParseData.h" #include "vtkWrappingToolsModule.h" #include /* Flags for selecting what info to print for declarations */ #define VTK_PARSE_NAMES 0x00000010 #define VTK_PARSE_VALUES 0x00000020 #define VTK_PARSE_RETURN_VALUE 0x00000040 #define VTK_PARSE_PARAMETER_LIST 0x00000080 #define VTK_PARSE_SPECIFIERS 0x00FF0000 #define VTK_PARSE_TRAILERS 0x0F000000 #define VTK_PARSE_TEMPLATES 0xF0000000 #define VTK_PARSE_EVERYTHING 0xFFFFFFFF #ifdef __cplusplus extern "C" { #endif /** * Skip over a sequence of characters that begin with an alphabetic * character or an underscore, and include only alphanumeric * characters or underscores. Return the number of characters. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_IdentifierLength(const char* text); /** * Skip over a name, including any namespace prefixes and * any template arguments. Return the number of characters. * Examples are "name", "::name", "name", "name::name2", * "::name::name2". */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_NameLength(const char* text); /** * Skip over a name, including any template arguments, but stopping * if a '::' is encountered. Return the number of characters. * Examples are "name" and "name" */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_UnscopedNameLength(const char* text); /** * Skip over a literal, which may be a number, a char in single * quotes, a string in double quotes, or a name, or a name followed * by arguments in parentheses. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_LiteralLength(const char* text); /** * Get a type from a type name, and return the number of characters used. * If the "classname" argument is not NULL, then it is used to return * the short name for the type, e.g. "long int" becomes "long", while * typedef names and class names are returned unchanged. If "const" * appears in the type name, then the const bit flag is set for the * type, but "const" will not appear in the returned classname. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_BasicTypeFromString( const char* text, unsigned int* type, const char** classname, size_t* classname_len); /** * Generate a ValueInfo by parsing the type from the provided text. * Only simple text strings are supported, e.g. "const T **". * Returns the number of characters consumed. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_ValueInfoFromString(ValueInfo* val, StringCache* cache, const char* text); /** * Generate a C++ declaration string from a ValueInfo struct. * * The resulting string can represent a parameter declaration, a variable * or type declaration, or a function return value. To use this function, * you should call it twice: first, call it with "text" set to NULL, and * it will return a lower bound on the length of the string that will be * produced. Next, allocate at least length+1 bytes for the string, and * and call it again with "text" set to the allocated string. The number * of bytes written to the string (not including the terminating null) will * be returned. * * The flags provide a mask that controls what information will be included, * for example VTK_PARSE_CONST|VTK_PARSE_VOLATILE is needed to include the * 'const' or 'volatile' qualifiers. Use VTK_PARSE_EVERYTHING to generate * the entire declaration for a variable or parameter. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_ValueInfoToString(ValueInfo* data, char* text, unsigned int flags); /** * Generate a C++ function signature from a FunctionInfo struct. * * See vtkParse_ValueInfoToString() for basic usage. The flags can be set * to VTK_PARSE_RETURN_VALUE to print only the return value for the function, * or VTK_PARSE_PARAMETER_LIST to print only the parameter list. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_FunctionInfoToString(FunctionInfo* func, char* text, unsigned int flags); /** * Generate a C++ template declaration from a TemplateInfo struct. * * See vtkParse_ValueInfoToString() for basic usage. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_TemplateInfoToString(TemplateInfo* func, char* text, unsigned int flags); /** * Compare two C++ functions to see if they have the same signature. * * The following are the possible return values. Any non-zero return value * means that the parameters match. If the 2nd bit is also set, then the * function return value also matches. If the 3rd bit is set, then the * parameters match and both methods are members of the same class, and * the constness of the functions match. This means that the signatures * are not identical unless the return value is 7 or higher (. */ VTKWRAPPINGTOOLS_EXPORT int vtkParse_CompareFunctionSignature(const FunctionInfo* func1, const FunctionInfo* func2); /** * Expand a typedef within a variable, parameter, or typedef declaration. * The expansion is done in-place. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_ExpandTypedef(ValueInfo* valinfo, ValueInfo* typedefinfo); /** * Expand any unrecognized types within a variable, parameter, or typedef * that match any of the supplied typedefs. The expansion is done in-place. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_ExpandTypedefs(ValueInfo* valinfo, StringCache* cache, int n, const char* name[], const char* val[], ValueInfo* typedefinfo[]); /** * Wherever one of the specified names exists inside a Value or inside * a Dimension size, replace it with the corresponding val string. * This is used to replace constants with their values. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_ExpandValues( ValueInfo* valinfo, StringCache* cache, int n, const char* name[], const char* val[]); /** * Search and replace, return the initial string if no replacements * occurred, else return a new string allocated with malloc. */ VTKWRAPPINGTOOLS_EXPORT const char* vtkParse_StringReplace( const char* str1, int n, const char* name[], const char* val[]); /** * Extract the class name and template args from a templated * class type ID. Returns the full number of characters that * were consumed during the decomposition. */ VTKWRAPPINGTOOLS_EXPORT size_t vtkParse_DecomposeTemplatedType( const char* text, const char** classname, int n, const char*** args, const char* defaults[]); /** * Free the list of strings returned by ExtractTemplateArgs. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_FreeTemplateDecomposition(const char* classname, int n, const char** args); /** * Instantiate a class template by substituting the provided arguments * for the template parameters. If "n" is less than the number of template * parameters, then default parameter values (if present) will be used. * If an error occurs, the error will be printed to stderr and NULL will * be returned. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_InstantiateClassTemplate( ClassInfo* data, StringCache* cache, int n, const char* args[]); /** * Instantiate a function or class method template by substituting the * provided arguments for the template parameters. If "n" is less than * the number of template parameters, then default parameter values * (if present) will be used. If an error occurs, the error will be * printed to stderr and NULL will be returned. */ VTKWRAPPINGTOOLS_EXPORT void vtkParse_IntantiateFunctionTemplate(FunctionInfo* data, int n, const char* args[]); /** * Get a zero-terminated array of the types in vtkTemplateMacro. */ VTKWRAPPINGTOOLS_EXPORT const char** vtkParse_GetTemplateMacroTypes(void); /** * Get a zero-terminated array of the types in vtkArray. */ VTKWRAPPINGTOOLS_EXPORT const char** vtkParse_GetArrayTypes(void); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* VTK-HeaderTest-Exclude: vtkParseExtras.h */