| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** Clownfish::CFC::Type - A variable's type. |
| */ |
| |
| #ifndef H_CFCTYPE |
| #define H_CFCTYPE |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef struct CFCType CFCType; |
| struct CFCParcel; |
| |
| #define CFCTYPE_CONST 0x00000001 |
| #define CFCTYPE_NULLABLE 0x00000002 |
| #define CFCTYPE_VOID 0x00000004 |
| #define CFCTYPE_INCREMENTED 0x00000008 |
| #define CFCTYPE_DECREMENTED 0x00000010 |
| #define CFCTYPE_OBJECT 0x00000020 |
| #define CFCTYPE_PRIMITIVE 0x00000040 |
| #define CFCTYPE_INTEGER 0x00000080 |
| #define CFCTYPE_FLOATING 0x00000100 |
| #define CFCTYPE_STRING_TYPE 0x00000200 |
| #define CFCTYPE_VA_LIST 0x00000400 |
| #define CFCTYPE_ARBITRARY 0x00000800 |
| #define CFCTYPE_COMPOSITE 0x00001000 |
| |
| /** Generic constructor. |
| * |
| * @param flags Flags which apply to the Type. Supplying incompatible flags |
| * will trigger an error. |
| * @param parcel A Clownfish::CFC::Parcel. |
| * @param specifier The C name for the type, not including any indirection or |
| * array subscripts. |
| * @param indirection integer indicating level of indirection. Example: the C |
| * type "float**" has a specifier of "float" and indirection 2. |
| * @param c_string The C representation of the type. |
| */ |
| CFCType* |
| CFCType_new(int flags, struct CFCParcel *parcel, const char *specifier, |
| int indirection, const char *c_string); |
| |
| CFCType* |
| CFCType_init(CFCType *self, int flags, struct CFCParcel *parcel, |
| const char *specifier, int indirection, const char *c_string); |
| |
| /** Return a Type representing an integer primitive. |
| * |
| * Support is limited to a subset of the standard C integer types: |
| * |
| * int8_t |
| * int16_t |
| * int32_t |
| * int64_t |
| * uint8_t |
| * uint16_t |
| * uint32_t |
| * uint64_t |
| * char |
| * short |
| * int |
| * long |
| * size_t |
| * |
| * Many others are not supported: "signed" or "unsigned" anything, "long |
| * long", "ptrdiff_t", "off_t", etc. |
| * |
| * The following Charmonizer typedefs are supported: |
| * |
| * bool_t |
| * |
| * @param flags Allowed flags: CONST, INTEGER, PRIMITIVE. |
| * @param specifier Must match one of the supported types. |
| */ |
| CFCType* |
| CFCType_new_integer(int flags, const char *specifier); |
| |
| /** Return a Type representing a floating point primitive. |
| * |
| * @param flags Allowed flags: CONST, FLOATING, PRIMITIVE. |
| * @param specifier Must be either 'float' or 'double'. |
| */ |
| CFCType* |
| CFCType_new_float(int flags, const char *specifier); |
| |
| /** Create a Type representing an object. |
| * |
| * The supplied <code>specifier</code> must match the last component of the |
| * class name -- i.e. for the class "Crustacean::Lobster" it must be |
| * "Lobster". |
| * |
| * The Parcel's prefix will be prepended to the specifier by new_object(). |
| * |
| * @param flags Allowed flags: OBJECT, STRING_TYPE, CONST, NULLABLE, |
| * INCREMENTED, DECREMENTED. |
| * @param parcel A Clownfish::CFC::Parcel. |
| * @param specifier Required. Must follow the rules for Clownfish::CFC::Class |
| * class name components. |
| * @param indirection Level of indirection. Must be 1 if supplied. |
| */ |
| CFCType* |
| CFCType_new_object(int flags, struct CFCParcel *parcel, const char *specifier, |
| int indirection); |
| |
| /** Constructor for a composite type which is made up of repetitions of a |
| * single, uniform subtype. |
| * |
| * @param flags Allowed flags: COMPOSITE, NULLABLE |
| * @param child The Clownfish::CFC::Type which the composite is comprised of. |
| * @param indirection integer indicating level of indirection. Example: the C type |
| * "float**" has indirection 2. |
| * @param array A string describing an array postfix. |
| */ |
| CFCType* |
| CFCType_new_composite(int flags, CFCType *child, int indirection, |
| const char *array); |
| |
| /** Return a Clownfish::CFC::Type representing a the 'void' keyword in C. It can |
| * be used either for a void return type, or in conjuction with with |
| * new_composite() to support the <code>void*</code> opaque pointer type. |
| * |
| * @param is_const Should be true if the type is const. (Useful in the |
| * context of <code>const void*</code>). |
| */ |
| CFCType* |
| CFCType_new_void(int is_const); |
| |
| /** Create a Type representing C's va_list, from stdarg.h. |
| */ |
| CFCType* |
| CFCType_new_va_list(void); |
| |
| /** "Arbitrary" types are a hack that spares us from having to support C types |
| * with complex declaration syntaxes -- such as unions, structs, enums, or |
| * function pointers -- from within Clownfish itself. |
| * |
| * The only constraint is that the <code>specifier</code> must end in "_t". |
| * This allows us to create complex types in a C header file... |
| * |
| * typedef union { float f; int i; } floatint_t; |
| * |
| * ... pound-include the C header, then use the resulting typedef in a |
| * Clownfish header file and have it parse as an "arbitrary" type. |
| * |
| * floatint_t floatint; |
| * |
| * If <code>parcel</code> is supplied and <code>specifier</code> begins with a |
| * capital letter, the Parcel's prefix will be prepended to the specifier: |
| * |
| * foo_t -> foo_t # no prefix prepending |
| * Lobster_foo_t -> crust_Lobster_foo_t # prefix prepended |
| * |
| * @param specifier The name of the type, which must end in "_t". |
| * @param parcel A Clownfish::CFC::Parcel. |
| */ |
| CFCType* |
| CFCType_new_arbitrary(struct CFCParcel *parcel, const char *specifier); |
| |
| void |
| CFCType_destroy(CFCType *self); |
| |
| /** Returns true if two Clownfish::CFC::Type objects are equivalent. |
| */ |
| int |
| CFCType_equals(CFCType *self, CFCType *other); |
| |
| /** Weak checking of type which allows for covariant return types. Calling |
| * this method on anything other than an object type is an error. |
| */ |
| int |
| CFCType_similar(CFCType *self, CFCType *other); |
| |
| void |
| CFCType_set_specifier(CFCType *self, const char *specifier); |
| |
| const char* |
| CFCType_get_specifier(CFCType *self); |
| |
| /** Return the name of the VTable variable which corresponds to the object |
| * type. Returns NULL for non-object types. |
| */ |
| const char* |
| CFCType_get_vtable_var(CFCType *self); |
| |
| int |
| CFCType_get_indirection(CFCType *self); |
| |
| struct CFCParcel* |
| CFCType_get_parcel(CFCType *self); |
| |
| /** Set the C representation of the Type. |
| */ |
| void |
| CFCType_set_c_string(CFCType *self, const char *c_string); |
| |
| /** Return the C representation of the type. |
| */ |
| const char* |
| CFCType_to_c(CFCType *self); |
| |
| size_t |
| CFCType_get_width(CFCType *self); |
| |
| const char* |
| CFCType_get_array(CFCType *self); |
| |
| int |
| CFCType_const(CFCType *self); |
| |
| void |
| CFCType_set_nullable(CFCType *self, int nullable); |
| |
| int |
| CFCType_nullable(CFCType *self); |
| |
| /** Returns true if the Type is incremented. Only applicable to object Types. |
| */ |
| int |
| CFCType_incremented(CFCType *self); |
| |
| /** Returns true if the Type is decremented. Only applicable to object Types. |
| */ |
| int |
| CFCType_decremented(CFCType *self); |
| |
| int |
| CFCType_is_void(CFCType *self); |
| |
| int |
| CFCType_is_object(CFCType *self); |
| |
| int |
| CFCType_is_primitive(CFCType *self); |
| |
| int |
| CFCType_is_integer(CFCType *self); |
| |
| int |
| CFCType_is_floating(CFCType *self); |
| |
| /** Returns true if $type represents a Clownfish type which holds unicode |
| * strings. |
| */ |
| int |
| CFCType_is_string_type(CFCType *self); |
| |
| int |
| CFCType_is_va_list(CFCType *self); |
| |
| int |
| CFCType_is_arbitrary(CFCType *self); |
| |
| int |
| CFCType_is_composite(CFCType *self); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* H_CFCTYPE */ |
| |