text: /*=========================================================================
  
    Program:   Visualization Toolkit
    Module:    vtkParseType.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.
  
  =========================================================================*/
  
  #ifndef vtkParseType_h
  #define vtkParseType_h
  
  /**
   * The parser identifies VTK types with 32-bit hexadecimal numbers:
   *
   * - One byte is for the base type.
   * - One byte is indirection i.e. & and * and "* const"
   * - One byte is for qualifiers like const and static.
   * - The final byte is reserved.
   *
   * There is some type information that cannot be stored within
   * this bitfield.  This info falls into three categories:
   *
   * 1) Function pointers are stored in a FunctionInfo struct.
   *    However, if the type is VTK_PARSE_FUNCTION with no POINTER,
   *    it is guaranteed to be "void func(void *)" which is the
   *    old VTK-style callback.
   *
   * 2) Multi-dimensional arrays are stored in a char *[MAX_ARRAY_DIMS]
   *    array with a NULL pointer indicating there are no more brackets.
   *    If the type is a pointer and the first value is not NULL, then
   *    that value gives the array size for that pointer.  The reason
   *    that "char *" is used is because the sizes might be template
   *    parameters or constants defined elsewhere.  However, most often
   *    the sizes are integer literals, and the first size will be
   *    stored as an int in ArgCounts.
   *
   * 3) The ID for VTK_PARSE_OBJECT is stored in ArgClasses.
   *
   */
  
  /**
   * Mask for removing everything but the base type
   */
  #define VTK_PARSE_BASE_TYPE 0x000000FF
  
  /**
   * Mask for checking signed/unsigned
   */
  #define VTK_PARSE_UNSIGNED 0x00000010
  
  /**
   * Mask for pointers and references
   */
  #define VTK_PARSE_INDIRECT 0x0000FF00
  
  /**
   * Qualifiers
   */
  #define VTK_PARSE_QUALIFIER 0x00FF0000
  #define VTK_PARSE_CONST 0x00010000
  #define VTK_PARSE_STATIC 0x00020000
  #define VTK_PARSE_VIRTUAL 0x00040000
  #define VTK_PARSE_EXPLICIT 0x00080000
  #define VTK_PARSE_MUTABLE 0x00100000
  #define VTK_PARSE_VOLATILE 0x00200000
  #define VTK_PARSE_RVALUE 0x00400000
  #define VTK_PARSE_THREAD_LOCAL 0x00800000
  
  /**
   * Attributes (used for hints)
   */
  #define VTK_PARSE_ATTRIBUTES 0x07000000
  #define VTK_PARSE_NEWINSTANCE 0x01000000
  #define VTK_PARSE_ZEROCOPY 0x02000000
  #define VTK_PARSE_WRAPEXCLUDE 0x04000000
  
  /**
   * Special
   */
  #define VTK_PARSE_SPECIALS 0x70000000
  #define VTK_PARSE_TYPEDEF 0x10000000
  #define VTK_PARSE_FRIEND 0x20000000
  #define VTK_PARSE_PACK 0x40000000
  
  /**
   * Mask for removing qualifiers
   */
  #define VTK_PARSE_QUALIFIED_TYPE 0x03FFFFFF
  #define VTK_PARSE_UNQUALIFIED_TYPE 0x0000FFFF
  
  /**
   * Indirection, contained in VTK_PARSE_INDIRECT
   *
   * Indirection of types works as follows:
   * type **(**&val[n])[m]
   * Pointers on the left, arrays on the right,
   * and optionally a set of parentheses and a ref.
   *
   * The 'type' may be preceded or followed by const,
   * which is handled by the VTK_PARSE_CONST flag.
   *
   * The array dimensionality and sizes is stored
   * elsewhere, it isn't stored in the bitfield.
   *
   * The leftmost [] is converted to a pointer, unless
   * it is outside the parenthesis.
   * So "type val[n][m]"  becomes  "type (*val)[m]",
   * these two types are identical in C and C++.
   *
   * Any pointer can be followed by const, and any pointer
   * can be preceded by a parenthesis. However, you will
   * never see a parenthesis anywhere except for just before
   * the leftmost pointer.
   *
   * These are good: "(*val)[n]", "**(*val)[n]", "(*&val)[n]"
   * Not so good: "(**val)[n]" (is actually like (*val)[][n])
   *
   * The Ref needs 1 bit total, and each pointer needs 2 bits:
   *
   *  0 = nothing
   *  1 = '*'       = VTK_PARSE_POINTER
   *  2 = '[]'      = VTK_PARSE_ARRAY
   *  3 = '* const' = VTK_PARSE_CONST_POINTER
   *
   * The VTK_PARSE_ARRAY flag means "this pointer is actually
   * the first bracket in a multi-dimensional array" with the array
   * info stored separately.
   */
  #define VTK_PARSE_BAD_INDIRECT 0xFF00
  #define VTK_PARSE_POINTER_MASK 0xFE00
  #define VTK_PARSE_POINTER_LOWMASK 0x0600
  #define VTK_PARSE_REF 0x0100
  #define VTK_PARSE_POINTER 0x0200
  #define VTK_PARSE_POINTER_REF 0x0300
  #define VTK_PARSE_ARRAY 0x0400
  #define VTK_PARSE_ARRAY_REF 0x0500
  #define VTK_PARSE_CONST_POINTER 0x0600
  #define VTK_PARSE_CONST_POINTER_REF 0x0700
  #define VTK_PARSE_POINTER_POINTER 0x0A00
  #define VTK_PARSE_POINTER_POINTER_REF 0x0B00
  #define VTK_PARSE_POINTER_CONST_POINTER 0x0E00
  
  /**
   * Basic types contained in VTK_PARSE_BASE_TYPE
   *
   * The lowest two hex digits describe the basic type,
   * where bit 0x10 is used to indicate unsigned types,
   * value 0x8 is used for unrecognized types, and
   * value 0x9 is used for types that start with "vtk".
   *
   * The bit 0x10 is reserved for "unsigned", and it
   * may only be present in unsigned types.
   *
   * Do not rearrange these types, they are hard-coded
   * into the hints file.
   */
  #define VTK_PARSE_FLOAT 0x01
  #define VTK_PARSE_VOID 0x02
  #define VTK_PARSE_CHAR 0x03
  #define VTK_PARSE_UNSIGNED_CHAR 0x13
  #define VTK_PARSE_INT 0x04
  #define VTK_PARSE_UNSIGNED_INT 0x14
  #define VTK_PARSE_SHORT 0x05
  #define VTK_PARSE_UNSIGNED_SHORT 0x15
  #define VTK_PARSE_LONG 0x06
  #define VTK_PARSE_UNSIGNED_LONG 0x16
  #define VTK_PARSE_DOUBLE 0x07
  #define VTK_PARSE_UNKNOWN 0x08
  #define VTK_PARSE_OBJECT 0x09
  #define VTK_PARSE_LONG_LONG 0x0B
  #define VTK_PARSE_UNSIGNED_LONG_LONG 0x1B
  #define VTK_PARSE___INT64 0x0C
  #define VTK_PARSE_UNSIGNED___INT64 0x1C
  #define VTK_PARSE_SIGNED_CHAR 0x0D
  #define VTK_PARSE_BOOL 0x0E
  #define VTK_PARSE_SSIZE_T 0x0F
  #define VTK_PARSE_SIZE_T 0x1F
  #define VTK_PARSE_STRING 0x21
  #define VTK_PARSE_UNICODE_STRING 0x22
  #define VTK_PARSE_OSTREAM 0x23
  #define VTK_PARSE_ISTREAM 0x24
  #define VTK_PARSE_FUNCTION 0x25
  #define VTK_PARSE_QOBJECT 0x26
  #define VTK_PARSE_LONG_DOUBLE 0x27
  #define VTK_PARSE_WCHAR_T 0x28
  #define VTK_PARSE_CHAR16_T 0x29
  #define VTK_PARSE_CHAR32_T 0x2A
  #define VTK_PARSE_NULLPTR_T 0x2B
  
  /**
   * Basic pointer types
   */
  #define VTK_PARSE_FLOAT_PTR 0x201
  #define VTK_PARSE_VOID_PTR 0x202
  #define VTK_PARSE_CHAR_PTR 0x203
  #define VTK_PARSE_UNSIGNED_CHAR_PTR 0x213
  #define VTK_PARSE_INT_PTR 0x204
  #define VTK_PARSE_UNSIGNED_INT_PTR 0x214
  #define VTK_PARSE_SHORT_PTR 0x205
  #define VTK_PARSE_UNSIGNED_SHORT_PTR 0x215
  #define VTK_PARSE_LONG_PTR 0x206
  #define VTK_PARSE_UNSIGNED_LONG_PTR 0x216
  #define VTK_PARSE_DOUBLE_PTR 0x207
  #define VTK_PARSE_UNKNOWN_PTR 0x208
  #define VTK_PARSE_OBJECT_PTR 0x209
  #define VTK_PARSE_LONG_LONG_PTR 0x20B
  #define VTK_PARSE_UNSIGNED_LONG_LONG_PTR 0x21B
  #define VTK_PARSE___INT64_PTR 0x20C
  #define VTK_PARSE_UNSIGNED___INT64_PTR 0x21C
  #define VTK_PARSE_SIGNED_CHAR_PTR 0x20D
  #define VTK_PARSE_BOOL_PTR 0x20E
  #define VTK_PARSE_SSIZE_T_PTR 0x20F
  #define VTK_PARSE_SIZE_T_PTR 0x21F
  #define VTK_PARSE_STRING_PTR 0x221
  #define VTK_PARSE_UNICODE_STRING_PTR 0x222
  #define VTK_PARSE_OSTREAM_PTR 0x223
  #define VTK_PARSE_ISTREAM_PTR 0x224
  #define VTK_PARSE_FUNCTION_PTR 0x225
  #define VTK_PARSE_QOBJECT_PTR 0x226
  #define VTK_PARSE_LONG_DOUBLE_PTR 0x227
  #define VTK_PARSE_WCHAR_T_PTR 0x228
  #define VTK_PARSE_CHAR16_T_PTR 0x229
  #define VTK_PARSE_CHAR32_T_PTR 0x22A
  #define VTK_PARSE_NULLPTR_T_PTR 0x22B
  
  /**
   * Basic reference types
   */
  #define VTK_PARSE_FLOAT_REF 0x101
  #define VTK_PARSE_VOID_REF 0x102
  #define VTK_PARSE_CHAR_REF 0x103
  #define VTK_PARSE_UNSIGNED_CHAR_REF 0x113
  #define VTK_PARSE_INT_REF 0x104
  #define VTK_PARSE_UNSIGNED_INT_REF 0x114
  #define VTK_PARSE_SHORT_REF 0x105
  #define VTK_PARSE_UNSIGNED_SHORT_REF 0x115
  #define VTK_PARSE_LONG_REF 0x106
  #define VTK_PARSE_UNSIGNED_LONG_REF 0x116
  #define VTK_PARSE_DOUBLE_REF 0x107
  #define VTK_PARSE_UNKNOWN_REF 0x108
  #define VTK_PARSE_OBJECT_REF 0x109
  #define VTK_PARSE_LONG_LONG_REF 0x10B
  #define VTK_PARSE_UNSIGNED_LONG_LONG_REF 0x11B
  #define VTK_PARSE___INT64_REF 0x10C
  #define VTK_PARSE_UNSIGNED___INT64_REF 0x11C
  #define VTK_PARSE_SIGNED_CHAR_REF 0x10D
  #define VTK_PARSE_BOOL_REF 0x10E
  #define VTK_PARSE_SSIZE_T_REF 0x10F
  #define VTK_PARSE_SIZE_T_REF 0x11F
  #define VTK_PARSE_STRING_REF 0x121
  #define VTK_PARSE_UNICODE_STRING_REF 0x122
  #define VTK_PARSE_OSTREAM_REF 0x123
  #define VTK_PARSE_ISTREAM_REF 0x124
  #define VTK_PARSE_QOBJECT_REF 0x126
  #define VTK_PARSE_LONG_DOUBLE_REF 0x127
  #define VTK_PARSE_WCHAR_T_REF 0x128
  #define VTK_PARSE_CHAR16_T_REF 0x129
  #define VTK_PARSE_CHAR32_T_REF 0x12A
  #define VTK_PARSE_NULLPTR_T_REF 0x12B
  
  /**
   * For backwards compatibility
   */
  #ifndef VTK_PARSE_LEGACY_REMOVE
  #define VTK_PARSE_VTK_OBJECT VTK_PARSE_OBJECT
  #define VTK_PARSE_VTK_OBJECT_PTR VTK_PARSE_OBJECT_PTR
  #define VTK_PARSE_VTK_OBJECT_REF VTK_PARSE_OBJECT_REF
  #define VTK_PARSE_ID_TYPE 0x0A
  #define VTK_PARSE_UNSIGNED_ID_TYPE 0x1A
  #define VTK_PARSE_ID_TYPE_PTR 0x20A
  #define VTK_PARSE_UNSIGNED_ID_TYPE_PTR 0x21A
  #define VTK_PARSE_ID_TYPE_REF 0x10A
  #define VTK_PARSE_UNSIGNED_ID_TYPE_REF 0x11A
  #endif
  
  #endif
  /* VTK-HeaderTest-Exclude: vtkParseType.h */
  