1 #ifndef __FM__ 2 #define __FM__ 3 4 #if defined(__cplusplus) || defined(c_plusplus) 5 extern "C" { 6 #endif 7 typedef struct _FMContextStruct *FMContext; 8 9 extern FMContext create_FMcontext(); 10 extern FMContext create_local_FMcontext(); 11 extern void free_FMcontext(); 12 extern void add_ref_FMcontext(); 13 extern void FMcontext_allow_self_formats(FMContext fmc); 14 extern int 15 FMcontext_get_format_server_identifier(FMContext fmc); 16 17 18 #ifndef FMOffset 19 #define FMOffset(p_type,field) \ 20 ((int) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL))) 21 #if defined(__STDC__) || defined(__ANSI_CPP__) || defined(_MSC_VER) 22 #define FMstr(s) #s 23 #else 24 #define FMstr(s) "s" 25 #endif 26 #define FMArrayDecl(type, size) FMstr(type[size]) 27 #define FMArrayDecl2(type, size, size2) FMstr(type[size][size2]) 28 29 #define FMDefaultDecl(name, val) FMstr(name(val)) 30 31 typedef struct _FMField { 32 const char *field_name; /* Field name */ 33 const char *field_type; /* Representation type desired */ 34 int field_size; /* Size in bytes of representation */ 35 int field_offset; /* Offset from base to put field value */ 36 } FMField, *FMFieldList; 37 38 typedef struct _FMOptInfo { 39 int info_type; 40 int info_len; 41 const char *info_block; 42 } FMOptInfo; 43 44 /*! 45 * A structure to hold Format Name / Field List associations. 46 * 47 * 48 * This is used to associate names with field lists. Together these define 49 * a structure that can be composed into larger structures. 50 */ 51 typedef struct _FMformat_list { 52 /*! the name to be associated with this structure */ 53 char *format_name; 54 /*! the FFS-style list of fields within this structure */ 55 FMFieldList field_list; 56 int struct_size; 57 FMOptInfo *opt_info; 58 }FMFormatRec, *FMFormatList, FMStructDescRec, *FMStructDescList; 59 #endif 60 61 typedef enum { 62 Format_Unknown= 0, Format_IEEE_754_bigendian = 1, 63 Format_IEEE_754_littleendian = 2, Format_IEEE_754_mixedendian = 3 64 } FMfloat_format; 65 66 typedef enum { 67 Format_Integer_Unknown = 0, Format_Integer_bigendian = 1, 68 Format_Integer_littleendian = 2 69 } FMinteger_format; 70 71 typedef enum { 72 unknown_type, integer_type, unsigned_type, float_type, 73 char_type, string_type, enumeration_type, boolean_type 74 } FMdata_type; 75 76 typedef struct _FMFormatBody *FMFormatBodyPtr; 77 typedef FMFormatBodyPtr FMFormat; 78 79 extern char * 80 get_server_rep_FMformat(FMFormat ioformat, int *rep_length); 81 82 extern char * 83 get_server_ID_FMformat(FMFormat ioformat, int *id_length); 84 85 extern FMContext 86 FMContext_from_FMformat(FMFormat ioformat); 87 88 extern int 89 get_rep_len_format_ID(void *format_ID); 90 91 extern void 92 set_array_order_FMContext(FMContext iofile, int column_major); 93 94 FMFormat 95 FMformat_from_ID(FMContext iocontext, char *buffer); 96 97 int 98 FMformat_index(FMFormat f); 99 100 FMFormat 101 FMformat_by_index(FMContext c, int index); 102 103 extern FMFormat 104 load_external_format_FMcontext(FMContext iocontext, char *server_id, 105 int id_size, char *server_rep); 106 107 extern void 108 add_opt_info_FMformat(FMFormat format, int typ, int len, void *block); 109 110 extern FMFormat 111 FMregister_simple_format(FMContext context, char *format_name, FMFieldList field_list, int struct_size); 112 113 extern FMFormat 114 register_data_format(FMContext context, FMStructDescList struct_list); 115 116 extern FMFormat 117 FMregister_data_format(FMContext context, FMStructDescList struct_list); 118 119 extern void free_FMfield_list(FMFieldList list); 120 121 /*! 122 * lookup the FMFormat associated with a particular FMStructDescList 123 * 124 * FMlookup_format() addresses a specific problem particular to libraries. 125 * FFSwrite() requires a FMFormat value that results from a 126 * register_data_format() call. Efficiency would dictate that the 127 * register_data_format() be performed once and the FMFormat value used 128 * repeatedly for multiple writes. However, libraries which want to avoid 129 * the use of static variables, or which wish to support multiple 130 * FFS/FMContext values per process have no convenient way to store the 131 * FMFormat values for reuse. CMlookup_format() exploits the fact that 132 * field_lists are often constants with fixed addresses (I.E. their memory 133 * is not reused for other field lists later in the application). This call 134 * quickly looks up the FMFormat value in an FMcontext by searching for a 135 * matching format_list address. 136 * 137 * \warning You should *not* use this convenience routine if you cannot 138 * guarantee that all field lists used to register formats have a unique 139 * address. Normally if you use static format lists, the addresses will 140 * be unique. 141 */ 142 extern FMFormat 143 FMlookup_format(FMContext context, FMStructDescList struct_list); 144 145 typedef enum {Format_Less, Format_Greater, Format_Equal, 146 Format_Incompatible} FMformat_order; 147 148 FMformat_order FMformat_cmp(FMFormat format1, FMFormat format2); 149 150 typedef struct compat_formats { 151 FMFormat prior_format; 152 char *xform_code; 153 } *FMcompat_formats; 154 155 extern FMcompat_formats 156 FMget_compat_formats(FMFormat ioformat); 157 158 extern char * 159 name_of_FMformat(FMFormat format); 160 161 extern FMStructDescList 162 format_list_of_FMFormat(FMFormat format); 163 164 extern void 165 FMlocalize_structs(FMStructDescList list); 166 167 extern char * 168 global_name_of_FMFormat(FMFormat format); 169 170 extern FMFieldList 171 copy_field_list(FMFieldList list); 172 173 extern FMStructDescList 174 FMcopy_struct_list(FMStructDescList list); 175 176 extern void 177 FMfree_struct_list(FMStructDescList list); 178 179 extern int 180 FMstruct_size_field_list(FMFieldList list, int pointer_size); 181 182 extern FMStructDescList 183 FMlocalize_formats(FMStructDescList list); 184 185 extern int 186 count_FMfield(FMFieldList list); 187 188 extern void print_server_ID(unsigned char *ID); 189 extern void print_format_ID(FMFormat ioformat); 190 extern void fprint_server_ID(void * file,unsigned char *ID); 191 192 extern int FMformatID_len(char *buffer); 193 194 extern int 195 FMdump_data(FMFormat format, void *data, int character_limit); 196 197 extern int 198 FMdump_encoded_data(FMFormat format, void *data, int character_limit); 199 200 extern void 201 FMdump_XML(FMFormat format, void *data, int encoded); 202 203 extern void 204 FMdump_encoded_XML(FMContext c, void *data, int character_limit); 205 206 extern int 207 FMfdump_data(void *file, FMFormat format, void *data, int character_limit); 208 209 extern int 210 FMfdump_encoded_data(void *file, FMFormat format, void *data, int character_limit); 211 212 extern void 213 FMfdump_XML(void *file, FMFormat format, void *data, int encoded); 214 215 extern void 216 FMfdump_encoded_XML(void *file, FMContext c, void *data, int character_limit); 217 218 extern char* 219 FMunencoded_to_XML_string(FMContext fmcontext, FMFormat format, void *data); 220 221 extern void 222 FMfree_var_rec_elements(FMFormat format, void *data); 223 224 extern char *FMbase_type(const char *field_type); 225 226 #define XML_OPT_INFO 0x584D4C20 227 #define COMPAT_OPT_INFO 0x45564F4C 228 #define COMPAT_OPT_INFO_FMFILE 0x45564F4D 229 230 typedef struct _FMgetFieldStruct *FMFieldPtr; 231 extern FMFieldPtr get_FMfieldPtrFromList(FMFieldList field_list, 232 const char *fieldname); 233 234 extern void * 235 get_FMfieldAddr_by_name(FMFieldList field_list, const char *fieldname, void *data); 236 extern void * 237 get_FMPtrField_by_name(FMFieldList field_list, const char *fieldname, void *data, int encode); 238 extern int 239 set_FMPtrField_by_name(FMFieldList field_list, const char *fieldname, void *data, void *ptr_value); 240 extern int 241 get_FMfieldInt_by_name(FMFieldList field_list, const char *fieldname, void *data); 242 extern long 243 get_FMfieldLong_by_name(FMFieldList field_list, const char *fieldname, void *data); 244 245 extern void * FMheader_skip(FMContext c, void *data); 246 extern char *get_FMstring_base(FMFieldPtr iofield, void *data, void *string_base); 247 extern void *get_FMFieldAddr(FMFieldPtr iofield, void *data); 248 extern void *get_FMaddr (FMFieldPtr iofield, void *data, void *string_base, int encode); 249 extern void *put_FMaddr (FMFieldPtr iofield, void *data); 250 extern float get_FMfloat(FMFieldPtr iofield, void *data); 251 extern double get_FMdouble(FMFieldPtr iofield, void *data); 252 extern short get_FMshort(FMFieldPtr iofield, void *data); 253 extern int get_FMint(FMFieldPtr iofield, void *data); 254 extern long get_FMlong(FMFieldPtr iofield, void *data); 255 extern void get_FMlong8(FMFieldPtr iofield, void *data, unsigned long *low_long, long *high_long); 256 #if defined(SIZEOF_LONG_LONG) 257 #if SIZEOF_LONG_LONG != 0 258 extern long long get_FMlong_long(FMFieldPtr iofield, void *data); 259 extern unsigned long long get_FMulong_long(FMFieldPtr iofield, void *data); 260 #endif 261 #endif 262 #if defined(SIZEOF_LONG_DOUBLE) 263 #if SIZEOF_LONG_DOUBLE != 0 264 extern long double get_FMlong_double(FMFieldPtr iofield, void *data); 265 #endif 266 #endif 267 extern unsigned short get_FMushort(FMFieldPtr iofield, void *data); 268 extern unsigned int get_FMuint(FMFieldPtr iofield, void *data); 269 extern unsigned long get_FMulong(FMFieldPtr iofield, void *data); 270 extern int get_FMulong8(FMFieldPtr iofield, void *data, unsigned long *low_long, unsigned long *high_long); 271 extern char *get_FMstring(FMFieldPtr iofield, void *data); 272 extern char get_FMchar(FMFieldPtr iofield, void *data); 273 extern int get_FMenum(FMFieldPtr iofield, void *data); 274 275 #if defined(__cplusplus) || defined(c_plusplus) 276 } 277 #endif 278 #endif 279