# The Support Kit: Constants and Defined Types

This section lists the constants and types defined by the Support Kit and used throughout the entire Be operating system. Not included here are constants used as `status_t` values (error codes). They're listed in The Support Kit: Error Codes .

## Constants

### Boolean Constants

Constant | Value
`false` | 0
`true` | 1

These constants are defined as values for the `bool` type (described in the next section). The BeOS defines them for C code only. Because they match the boolean symbols that are part of the C++ language, they let you use the same `bool` type and `true` and `false` values when programming in both languages.

See also: `bool`

### Byte Swapping Constants

Constant | Description
`B_SWAP_HOST_TO_LENDIAN` | Convert from host byte order to little endian
`B_SWAP_HOST_TO_BENDIAN` | Convert from host byte order to big endian
`B_SWAP_LENDIAN_TO_HOST` | Convert from little endian to host byte order
`B_SWAP_BENDIAN_TO_HOST` | Convert from big endian to host byte order
`B_SWAP_ALWAYS` | Always convert endianness

These constants define the action to be taken by the `swap_data()` general byte swapping function.

See also: `swap_data()`

### Encoding Conversion Constants

Constant
`B_ISO1_CONVERSION`
```B_ISO2_CONVERSION`
```B_ISO3_CONVERSION`
```B_ISO4_CONVERSION`
```B_ISO5_CONVERSION`
```B_ISO6_CONVERSION`
```B_ISO7_CONVERSION`
```B_ISO8_CONVERSION`
```B_ISO9_CONVERSION`
```B_ISO10_CONVERSION`
```B_MAC_ROMAN_CONVERSION`
```B_SJIS_CONVERSION`
```B_EUC_CONVERSION`

These constants identify character encodings to the `convert_to_utf8()` and `convert_from_utf8()` functions, which convert text to and from the standard UTF8 character encoding assumed by the BeOS. The identify the source encoding for a conversion to UTF-8 and the destination encoding for a conversion from UTF-8.

See also: `convert_to_utf8()`, the BFont class in the Interface Kit

### Empty String

          const char *B_EMPTY_STRING

This constant provides a global pointer to an empty string ("").

### NULL and NIL

Constant | Value
`NIL` | 0
`NULL` | 0

These constants represent "empty" values. They're synonyms that can be used interchangeably.

### Type Codes

Constant | Meaning
`B_CHAR_TYPE` | A single character
`B_INT8_TYPE` | An 8-bit integer
`B_INT16_TYPE` | A 16-bit integer
`B_INT32_TYPE` | A 32-bit integer
`B_INT64_TYPE` | A 64-bit integer
`B_UINT8_TYPE` | An unsigned 8-bit integer
`B_UINT16_TYPE` | An unsigned 16-bit integer
`B_UINT32_TYPE` | An unsigned 32-bit integer
`B_UINT64_TYPE` | An unsigned 64-bit integer
`B_FLOAT_TYPE` | A `float`
```B_DOUBLE_TYPE` | A `double`
```B_BOOL_TYPE` | A boolean value (the `bool` type)
`B_OFF_T_TYPE` | An `off_t` value
`B_SIZE_T_TYPE` | A `size_t` value
`B_SSIZE_T_TYPE` | An `ssize_t` value
`B_POINTER_TYPE` | A pointer of some kind (including `void *`)
`B_OBJECT_TYPE` | An object pointer (such as BMessage *)
`B_MESSAGE_TYPE` | A BMessage object (not BMessage *)
`B_MESSENGER_TYPE` | A BMessenger object
`B_POINT_TYPE` | A BPoint object
`B_RECT_TYPE` | A BRect object
`B_PATH_TYPE` | A BPath object
`B_REF_TYPE` | An `entry_ref` structure
`B_RGB_COLOR_TYPE` | An `rgb_color` structure
`B_PATTERN_TYPE` | A `pattern` structure
`B_ASCII_TYPE` | Text in ASCII format
`B_STRING_TYPE` | A null-terminated character string
`B_MONOCHROME_1_BIT_TYPE` | Raw data for a monochrome bitmap (1 bit/pixel)
`B_GRAYSCALE_8_BIT_TYPE` | Raw data for a grayscale bitmap (8 bits per pixel)
`B_COLOR_8_BIT_TYPE` | Raw bitmap data in the `B_COLOR_8_BIT` color space
`B_RGB_32_BIT_TYPE` | Raw bitmap data in the `B_RGB_32_BIT` color space
`B_TIME_TYPE` | 64-bit microsecond `time_t` data
`B_RAW_TYPE` | Raw, untyped data--a stream of bytes
`B_MIME_TYPE` | The type is specified by a MIME string.
`B_ANY_TYPE` | The type can be any type.

These constants describe the types of data held by BMessage objects (the Application Kit) and as resources and file system attributes (the Storage Kit). `B_ANY_TYPE` refers to all types; it indicates that the exact type doesn't matter. `B_MIME_TYPE` indicates that the name of the data in the BMessage is a MIME string that specifies its true data type. The other constants refer only to a particular type. The `type_code` defined type marks where these constants are used in the API.

Applications can define their own type codes for data types not found on this list. All the codes the BeOS defines have values formed by concatenating four uppercase letters into a multicharacter constant. For example, `B_MESSENGER_TYPE` is 'MSNG' and `B_SIZE_T_TYPE` is 'SIZT'.

See also: `type_code`

## Defined Types

### bigtime_t

          typedef int64 bigtime_t

This type records the time in microseconds as a 64-bit integer. Typically, a `bigtime_t` variable measures the system time, the number of microseconds since 12:00:00 AM January 1, 1970, UTC (Coordinated Universal Time).

See also: `system_time()`

### bool

          typedef unsigned char bool

The C++ language defines `bool` as its basic boolean type. The BeOS extends the definition to C code, so you can use the same type in both languages. The `true` and `false` constants (listed above) are defined as boolean values.

### Function Pointers

          typedef int (*B_PFI)()
             typedef long (*B_PFL)()
             typedef void (*B_PFV)()

These types define pointers to functions that return `int`, `long`, and `void` values respectively.

### instantiation_func

          typedef BArchivable *(*instantiation_func) (BMessage *)

This type is a pointer to a function that can instantiate an object from a BMessage archive and return a pointer to the new object. The `Instantiate()` member function of `BArchivable` is such a function.

See also: the BArchivable class, `find_instantiation_func()`

### Integer Types

          typedef unsigned char uchar

          typedef signed char int8
             typedef unsigned char uint8
             typedef volatile signed char vint8
             typedef volatile unsigned char vuint8

          typedef short int16
             typedef unsigned short uint16
             typedef volatile short vint16
             typedef volatile unsigned short vuint16

          typedef long int32
             typedef unsigned long uint32
             typedef volatile long vint32
             typedef volatile unsigned long vuint32

          typedef long long int64
             typedef unsigned long long uint64
             typedef volatile long long vint64
             typedef volatile unsigned long long vuint64

These type names are defined as convenient shorthands for standard integers of various sizes. They're used in place of `int`, `short`, and `long` throughout the BeOS API.

The number at the end of the type name indicates the size of the integer. For example, a `uint32` is an unsigned 32-bit value. The type is guaranteed to be defined to its stated size for all platforms (thus their exact definitions may vary from platform to platform).

Using these types will make the code you write more portable. They'll help avoid problems as the operating system and your application move to other platforms.

### status_t

          typedef int32 status_t

This type indicates an error code; it's used mainly for function return values.

See also: "Error Codes"

### type_code

          typedef uint32 type_code

This type is used for the integer codes that indicate a particular data type. The codes--such as `B_UINT32_TYPE` and `B_MIME_TYPE`--mark the type of data added to a message or stored as a resource and also appear in other contexts.

See also: Type Codes, the BMessage class in the Application Kit, the BResource class in the Storage Kit

The Be Book, in lovely HTML, for BeOS Release 3.

Copyright © 1998 Be, Inc. All rights reserved.

Last modified March 26, 1998.