| /* |
| * Routines to print AIF objects. |
| * |
| * Copyright (c) 1996-2002 by Guardsoft Pty Ltd. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif /* HAVE_CONFIG_H */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "aif.h" |
| #include "aifint.h" |
| #include "aiferr.h" |
| |
| int |
| AIFPrint(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print(fp, depth, &fmt, &data); |
| } |
| |
| /* |
| * Prints the object in human-readable form to fp, advances fds and data to |
| * the first location after the part printed. Arithmetic values are given at |
| * least len bytes of significance, more if the fds indicates. |
| */ |
| int |
| _aif_print(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * tmp; |
| |
| _fds_resolve(fds); |
| |
| switch ( FDSType(*fds) ) |
| { |
| case AIF_BOOLEAN: |
| return _aif_print_bool(fp, depth, fds, data); |
| |
| case AIF_CHARACTER: |
| return _aif_print_char(fp, depth, fds, data); |
| |
| case AIF_INTEGER: |
| return _aif_print_int(fp, depth, fds, data); |
| |
| case AIF_FLOATING: |
| return _aif_print_float(fp, depth, fds, data); |
| |
| case AIF_ARRAY: |
| return _aif_print_array(fp, depth, fds, data); |
| |
| case AIF_POINTER: |
| return _aif_print_pointer(fp, depth, fds, data); |
| |
| case AIF_REGION: |
| return _aif_print_region(fp, depth, fds, data); |
| |
| case AIF_AGGREGATE: |
| return _aif_print_aggregate(fp, depth, fds, data); |
| |
| case AIF_NAME: |
| return _aif_print_name(fp, depth, fds, data); |
| |
| case AIF_REFERENCE: |
| tmp = _fds_lookup(fds); |
| return _aif_print(fp, depth, &tmp, data); |
| |
| case AIF_STRING: |
| return _aif_print_string(fp, depth, fds, data); |
| |
| case AIF_ENUM: |
| return _aif_print_enum(fp, depth, fds, data); |
| |
| case AIF_UNION: |
| return _aif_print_union(fp, depth, fds, data); |
| |
| case AIF_VOID: |
| return _aif_print_void(fp, depth, fds, data); |
| |
| case AIF_FUNCTION: |
| return _aif_print_function(fp, depth, fds, data); |
| |
| default: |
| SetAIFError(AIFERR_TYPE, NULL); |
| break; |
| } |
| |
| return -1; |
| } |
| |
| int |
| _aif_print_bool(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_bool_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_char(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_char_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_int(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_int_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_float(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_float_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_array(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_array_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_pointer(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_pointer_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_region(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_region_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_aggregate(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_aggregate_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_name(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_name_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_reference(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_reference_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_string(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_string_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_enum(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_enum_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_union(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_union_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_void(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_void_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| _aif_print_function(FILE *fp, int depth, char **fds, char **data) |
| { |
| char * str; |
| |
| _str_init(); |
| |
| if ( _aif_function_to_str(depth, fds, data) < 0 ) |
| return -1; |
| |
| str = _str_get(); |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |
| int |
| AIFPrintBool(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_bool(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintChar(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_char(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintInt(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_int(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintFloat(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_float(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintArray(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_array(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintPointer(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_pointer(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintRegion(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_region(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintAggregate(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_aggregate(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintName(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_name(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintReference(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_reference(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintString(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_string(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintEnum(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_enum(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintUnion(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_union(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintVoid(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_void(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintFunction(FILE *fp, int depth, AIF *a) |
| { |
| char * fmt; |
| char * data; |
| |
| if ( a == (AIF *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| fmt = AIF_FORMAT(a); |
| data = AIF_DATA(a); |
| |
| return _aif_print_function(fp, depth, &fmt, &data); |
| } |
| |
| int |
| AIFPrintArrayIndex(FILE *fp, AIFIndex *ix) |
| { |
| char * str; |
| |
| if ( ix == (AIFIndex *)NULL ) |
| { |
| SetAIFError(AIFERR_BADARG, NULL); |
| return -1; |
| } |
| |
| if ( AIFArrayIndexToStr(&str, ix) < 0 ) |
| return -1; |
| |
| fprintf(fp, "%s", str); |
| |
| _aif_free(str); |
| |
| return 0; |
| } |
| |