You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 lines
13 KiB
C
442 lines
13 KiB
C
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkParseData.h
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
/*-------------------------------------------------------------------------
|
|
Copyright (c) 2010 David Gobbi.
|
|
|
|
Contributed to the VisualizationToolkit by the author in May 2010
|
|
under the terms of the Visualization Toolkit 2008 copyright.
|
|
-------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
Data structures used by vtkParse.
|
|
*/
|
|
|
|
#ifndef vtkParseData_h
|
|
#define vtkParseData_h
|
|
|
|
#include "vtkParseString.h"
|
|
#include "vtkParseType.h"
|
|
#include "vtkWrappingToolsModule.h"
|
|
|
|
/* legacy */
|
|
#ifndef VTK_PARSE_LEGACY_REMOVE
|
|
#define MAX_ARGS 20
|
|
#endif
|
|
|
|
/**
|
|
* Access flags
|
|
*/
|
|
typedef enum _parse_access_t
|
|
{
|
|
VTK_ACCESS_PUBLIC = 0,
|
|
VTK_ACCESS_PROTECTED = 1,
|
|
VTK_ACCESS_PRIVATE = 2
|
|
} parse_access_t;
|
|
|
|
/**
|
|
* Comment type constants
|
|
*/
|
|
typedef enum _parse_dox_t
|
|
{
|
|
DOX_COMMAND_OTHER = 0,
|
|
DOX_COMMAND_DEF,
|
|
DOX_COMMAND_CATEGORY,
|
|
DOX_COMMAND_INTERFACE,
|
|
DOX_COMMAND_PROTOCOL,
|
|
DOX_COMMAND_CLASS,
|
|
DOX_COMMAND_ENUM,
|
|
DOX_COMMAND_STRUCT,
|
|
DOX_COMMAND_UNION,
|
|
DOX_COMMAND_NAMESPACE,
|
|
DOX_COMMAND_TYPEDEF,
|
|
DOX_COMMAND_FN,
|
|
DOX_COMMAND_PROPERTY,
|
|
DOX_COMMAND_VAR,
|
|
DOX_COMMAND_NAME,
|
|
DOX_COMMAND_DEFGROUP,
|
|
DOX_COMMAND_ADDTOGROUP,
|
|
DOX_COMMAND_WEAKGROUP,
|
|
DOX_COMMAND_EXAMPLE,
|
|
DOX_COMMAND_FILE,
|
|
DOX_COMMAND_DIR,
|
|
DOX_COMMAND_MAINPAGE,
|
|
DOX_COMMAND_PAGE,
|
|
DOX_COMMAND_SUBPAGE,
|
|
DOX_COMMAND_INTERNAL,
|
|
DOX_COMMAND_PACKAGE,
|
|
DOX_COMMAND_PRIVATESECTION,
|
|
DOX_COMMAND_PROTECTEDSECTION,
|
|
DOX_COMMAND_PUBLICSECTION,
|
|
} parse_dox_t;
|
|
|
|
/**
|
|
* ItemType constants
|
|
*/
|
|
typedef enum _parse_item_t
|
|
{
|
|
VTK_NAMESPACE_INFO = 1,
|
|
VTK_CLASS_INFO = 2,
|
|
VTK_STRUCT_INFO = 3,
|
|
VTK_UNION_INFO = 4,
|
|
VTK_ENUM_INFO = 5,
|
|
VTK_FUNCTION_INFO = 6,
|
|
VTK_VARIABLE_INFO = 7,
|
|
VTK_CONSTANT_INFO = 8,
|
|
VTK_TYPEDEF_INFO = 9,
|
|
VTK_USING_INFO = 10
|
|
} parse_item_t;
|
|
|
|
/**
|
|
* ItemInfo just contains an index
|
|
*/
|
|
typedef struct _ItemInfo
|
|
{
|
|
parse_item_t Type;
|
|
int Index;
|
|
} ItemInfo;
|
|
|
|
/* forward declarations */
|
|
struct _ValueInfo;
|
|
struct _FunctionInfo;
|
|
struct _FileInfo;
|
|
typedef struct _ValueInfo ValueInfo;
|
|
typedef struct _FunctionInfo FunctionInfo;
|
|
typedef struct _FileInfo FileInfo;
|
|
|
|
/**
|
|
* CommentInfo is for storing comments by category
|
|
* This is for comments that cannot be immediately attached to an item,
|
|
* for example class comments that come at the top of the header file
|
|
* rather than immediately before the class that they document.
|
|
*/
|
|
typedef struct _CommentInfo
|
|
{
|
|
parse_dox_t Type;
|
|
const char* Comment;
|
|
const char* Name;
|
|
} CommentInfo;
|
|
|
|
/**
|
|
* TemplateInfo holds template definitions
|
|
*/
|
|
typedef struct _TemplateInfo
|
|
{
|
|
int NumberOfParameters;
|
|
ValueInfo** Parameters;
|
|
} TemplateInfo;
|
|
|
|
/**
|
|
* ValueInfo is for typedefs, constants, variables,
|
|
* function parameters, and return values
|
|
*
|
|
* Note that Dimensions is an array of char pointers, in
|
|
* order to support dimensions that are sized according to
|
|
* template parameter values or according to named constants.
|
|
*/
|
|
struct _ValueInfo
|
|
{
|
|
parse_item_t ItemType;
|
|
parse_access_t Access;
|
|
const char* Name;
|
|
const char* Comment;
|
|
const char* Value; /* for vars or default parameters values */
|
|
unsigned int Type; /* as defined in vtkParseType.h */
|
|
const char* Class; /* classname for type */
|
|
int Count; /* total number of values, if known */
|
|
const char* CountHint; /* hint about how to get the count */
|
|
int NumberOfDimensions; /* dimensionality for arrays */
|
|
const char** Dimensions; /* dimensions for arrays */
|
|
FunctionInfo* Function; /* for function pointer values */
|
|
TemplateInfo* Template; /* template parameters, or NULL */
|
|
int IsStatic; /* for class variables only */
|
|
int IsEnum; /* for constants only */
|
|
int IsPack; /* for pack expansions */
|
|
};
|
|
|
|
/**
|
|
* FunctionInfo is for functions and methods
|
|
*/
|
|
struct _FunctionInfo
|
|
{
|
|
parse_item_t ItemType;
|
|
parse_access_t Access;
|
|
const char* Name;
|
|
const char* Comment;
|
|
const char* Class; /* class name for methods */
|
|
const char* Signature; /* function signature as text */
|
|
TemplateInfo* Template; /* template parameters, or NULL */
|
|
int NumberOfParameters;
|
|
ValueInfo** Parameters;
|
|
ValueInfo* ReturnValue; /* NULL for constructors and destructors */
|
|
int NumberOfPreconds;
|
|
const char** Preconds; /* preconditions */
|
|
const char* Macro; /* the macro that defined this function */
|
|
const char* SizeHint; /* hint the size e.g. for operator[] */
|
|
int IsOperator;
|
|
int IsVariadic;
|
|
int IsLegacy; /* marked as a legacy method or function */
|
|
int IsExcluded; /* marked as excluded from wrapping */
|
|
int IsStatic; /* methods only */
|
|
int IsVirtual; /* methods only */
|
|
int IsPureVirtual; /* methods only */
|
|
int IsConst; /* methods only */
|
|
int IsDeleted; /* methods only */
|
|
int IsFinal; /* methods only */
|
|
int IsOverride; /* methods only */
|
|
int IsExplicit; /* constructors only */
|
|
#ifndef VTK_PARSE_LEGACY_REMOVE
|
|
int NumberOfArguments; /* legacy */
|
|
unsigned int ArgTypes[MAX_ARGS]; /* legacy */
|
|
const char* ArgClasses[MAX_ARGS]; /* legacy */
|
|
int ArgCounts[MAX_ARGS]; /* legacy */
|
|
unsigned int ReturnType; /* legacy */
|
|
const char* ReturnClass; /* legacy */
|
|
int HaveHint; /* legacy */
|
|
int HintSize; /* legacy */
|
|
int ArrayFailure; /* legacy */
|
|
int IsPublic; /* legacy */
|
|
int IsProtected; /* legacy */
|
|
#endif
|
|
};
|
|
|
|
/**
|
|
* UsingInfo is for using directives
|
|
*/
|
|
typedef struct _UsingInfo
|
|
{
|
|
parse_item_t ItemType;
|
|
parse_access_t Access;
|
|
const char* Name; /* null for using whole namespace */
|
|
const char* Comment;
|
|
const char* Scope; /* the namespace or class */
|
|
} UsingInfo;
|
|
|
|
/**
|
|
* ClassInfo is for classes, structs, unions, and namespaces
|
|
*/
|
|
typedef struct _ClassInfo
|
|
{
|
|
parse_item_t ItemType;
|
|
parse_access_t Access;
|
|
const char* Name;
|
|
const char* Comment;
|
|
TemplateInfo* Template;
|
|
int NumberOfSuperClasses;
|
|
const char** SuperClasses;
|
|
int NumberOfItems;
|
|
ItemInfo* Items;
|
|
int NumberOfClasses;
|
|
struct _ClassInfo** Classes;
|
|
int NumberOfFunctions;
|
|
FunctionInfo** Functions;
|
|
int NumberOfConstants;
|
|
ValueInfo** Constants;
|
|
int NumberOfVariables;
|
|
ValueInfo** Variables;
|
|
int NumberOfEnums;
|
|
struct _ClassInfo** Enums;
|
|
int NumberOfTypedefs;
|
|
ValueInfo** Typedefs;
|
|
int NumberOfUsings;
|
|
UsingInfo** Usings;
|
|
int NumberOfNamespaces;
|
|
struct _ClassInfo** Namespaces;
|
|
int NumberOfComments;
|
|
CommentInfo** Comments;
|
|
int IsAbstract;
|
|
int IsFinal;
|
|
int HasDelete;
|
|
int IsExcluded;
|
|
} ClassInfo;
|
|
|
|
/**
|
|
* EnumInfo is for enums
|
|
* For scoped enums, the constants are in the enum itself, but for
|
|
* standard enums, the constants are at the same level as the enum.
|
|
*/
|
|
typedef struct _ClassInfo EnumInfo;
|
|
|
|
/**
|
|
* Namespace is for namespaces
|
|
*/
|
|
typedef struct _ClassInfo NamespaceInfo;
|
|
|
|
/**
|
|
* FileInfo is for header files
|
|
*/
|
|
struct _FileInfo
|
|
{
|
|
const char* FileName;
|
|
const char* NameComment;
|
|
const char* Description;
|
|
const char* Caveats;
|
|
const char* SeeAlso;
|
|
|
|
int NumberOfIncludes;
|
|
struct _FileInfo** Includes;
|
|
ClassInfo* MainClass;
|
|
NamespaceInfo* Contents;
|
|
StringCache* Strings;
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
/**
|
|
* Initializer methods
|
|
*/
|
|
/*@{*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitFile(FileInfo* file_info);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitNamespace(NamespaceInfo* namespace_info);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitClass(ClassInfo* cls);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitFunction(FunctionInfo* func);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitValue(ValueInfo* val);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitEnum(EnumInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitUsing(UsingInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitTemplate(TemplateInfo* arg);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_InitComment(CommentInfo* arg);
|
|
/*@}*/
|
|
|
|
/**
|
|
* Copy methods
|
|
*
|
|
* Strings are not deep-copied, they are assumed to be persistent.
|
|
*/
|
|
/*@{*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyNamespace(NamespaceInfo* data, const NamespaceInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyClass(ClassInfo* data, const ClassInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyFunction(FunctionInfo* data, const FunctionInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyValue(ValueInfo* data, const ValueInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyEnum(EnumInfo* data, const EnumInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyUsing(UsingInfo* data, const UsingInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyTemplate(TemplateInfo* data, const TemplateInfo* orig);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_CopyComment(CommentInfo* data, const CommentInfo* orig);
|
|
/*@}*/
|
|
|
|
/**
|
|
* Free methods
|
|
*
|
|
* Strings are not freed, they are assumed to be persistent.
|
|
*/
|
|
/*@{*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeFile(FileInfo* file_info);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeNamespace(NamespaceInfo* namespace_info);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeClass(ClassInfo* cls);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeFunction(FunctionInfo* func);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeValue(ValueInfo* val);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeEnum(EnumInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeUsing(UsingInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeTemplate(TemplateInfo* arg);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_FreeComment(CommentInfo* arg);
|
|
/*@}*/
|
|
|
|
/**
|
|
* Add a string to an array of strings, grow array as necessary.
|
|
*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddStringToArray(const char*** valueArray, int* count, const char* value);
|
|
|
|
/**
|
|
* Expand the Item array for classes and namespaces.
|
|
*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddItemToArray(ItemInfo** valueArray, int* count, parse_item_t type, int idx);
|
|
|
|
/**
|
|
* Add various items to the structs.
|
|
*/
|
|
/*@{*/
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddIncludeToFile(FileInfo* info, FileInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddClassToClass(ClassInfo* info, ClassInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddFunctionToClass(ClassInfo* info, FunctionInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddEnumToClass(ClassInfo* info, EnumInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddConstantToClass(ClassInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddVariableToClass(ClassInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddTypedefToClass(ClassInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddUsingToClass(ClassInfo* info, UsingInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddCommentToClass(ClassInfo* info, CommentInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddNamespaceToNamespace(NamespaceInfo* info, NamespaceInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddClassToNamespace(NamespaceInfo* info, ClassInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddFunctionToNamespace(NamespaceInfo* info, FunctionInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddEnumToNamespace(NamespaceInfo* info, EnumInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddConstantToNamespace(NamespaceInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddVariableToNamespace(NamespaceInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddTypedefToNamespace(NamespaceInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddUsingToNamespace(NamespaceInfo* info, UsingInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddCommentToNamespace(NamespaceInfo* info, CommentInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddParameterToFunction(FunctionInfo* info, ValueInfo* item);
|
|
VTKWRAPPINGTOOLS_EXPORT
|
|
void vtkParse_AddParameterToTemplate(TemplateInfo* info, ValueInfo* item);
|
|
/*@}*/
|
|
|
|
/**
|
|
* Add default constructors to a class if they do not already exist
|
|
*/
|
|
void vtkParse_AddDefaultConstructors(ClassInfo* data, StringCache* cache);
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif
|
|
|
|
#endif
|
|
/* VTK-HeaderTest-Exclude: vtkParseData.h */
|