home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 299_01 / mel.h < prev    next >
C/C++ Source or Header  |  1989-12-30  |  18KB  |  503 lines
  1. /*
  2. ------------------------------------------------------------------------
  3. filename: mel.h
  4. author: g. m. crews
  5. creation date: 25-Jul-1988
  6. date of last revision: 19-Jul-1989
  7.  
  8. the following defines the input and output interface (called "dictionaries") 
  9. between MEL (a generic metalanguage processor) and the engineering analysis 
  10. program it is being used for. (see files mel.doc and mel.c for more
  11. information.)
  12.  
  13. the idea is to use "descriptors" (english-like strings) to make i/o more
  14. readable to an analysis program user or checker. the dictionaries define the
  15. "meanings" of the tokens in the string.
  16.  
  17. the following data objects form the interface:
  18.  
  19.     input:
  20.  
  21.     char meli_descriptor_string[]    input descriptor string
  22.     meli_file(...)            interpret data from text file
  23.     meli(...)            interpret data from above string
  24.     meli_descrip_type(...)        get descriptor type
  25.     meli_num_params(...)        get number parameters read
  26.     meli_param(...)         get value of particular parameter
  27.     meli_data(...)            get parameter data
  28.  
  29.     output:
  30.  
  31.     char melo_descriptor_string[]    output descriptor string
  32.     melo_init(...)            prepare to output descriptor
  33.     melo_data(...)            put parameter data
  34.     melo(...)            translate data to above string
  35.     melo_file(...)            translate and send to text file
  36.  
  37.     errors:
  38.  
  39.     struct {...} mel_err        i/o error description
  40.  
  41.  
  42. development and testing of any particular set of dictionaries may be 
  43. facilitated with a debugging program called test_mel.  for more information, 
  44. see the file test_mel.c. 
  45.  
  46. NOTE THAT THIS FILE MUST BE CUSTOMIZED FOR EACH TARGET APPLICATION PROGRAM.  
  47. APPLICATION DEVELOPERS SHOULD SEARCH FOR THE WORD "CUSTOMIZED" FOR THE 
  48. LOCATIONS OF NUMBERS AND OTHER DATA THAT NEED TO CHANGE TO REFLECT 
  49. REQUIREMENTS OF THEIR OWN PARTICULAR APPLICATION PROGRAM.
  50.  
  51. THE PARTICULAR DICTIONARIES CURRENTLY DEFINED ARE SIMPLY A TEST FOR
  52. ILLUSTRATIVE PURPOSES.    INPUT AND OUTPUT DICTIONARIES ARE IDENTICAL AND LOOK
  53. LIKE:
  54.  
  55.     program_data,
  56.     program = 'sss',
  57.     date = 'sss',
  58.     input_filename = 'sss',
  59.     output_filename = 'sss',
  60.     errors_filename = 'sss',
  61.     label = 'sss';
  62.     program_options,
  63.     output_format = 'sss';         "verbose or terse"
  64.     message,
  65.     code = nnn,
  66.     text = 'sss';
  67.     end_of_data;
  68.  
  69. (NOTE THAT nnn STANDS FOR A NUMBER AND 'sss' STANDS FOR A STRING.)
  70.  
  71. file content: the "public" interface is listed first, followed by the 
  72. "private" interface. application programmers should treat MEL as a "black box" 
  73. and thus only use the "public" definitions.  (note however that manifest
  74. constants, etc., in the "private" area will have to be customized.)
  75.  
  76. nomemclature: In the following, "meli" is used to label input terms, "melo"
  77. is used to label output terms, and "mel" is used for terms that may apply
  78. to either input or output.
  79.  
  80. global conditional complilation flags (see mel.doc for more information on
  81. these flags and when to use them) are used to control data hiding and maintain
  82. object oriented approach used for MEL:
  83.  
  84.     MEL_INPUT     -  define this flag when you wish to use the MEL input object
  85.             for your application programs.
  86.  
  87.     MEL_OUTPUT     -  define this flag when you wish to use MEL for output.
  88.  
  89.     MEL_PRIVATE  -  users normally should not define this flag when including
  90.             mel.h in their application program files. it is used
  91.             to define "private" data structures, etc., for internal  
  92.             MEL routines (see mel.c).                        
  93.  
  94.     MEL_INIT     -  developers should also not define this flag for the same
  95.             reasons as above.
  96. ------------------------------------------------------------------------
  97. */
  98.  
  99. /*
  100. ------------------------------------------------------------------------
  101. "public" declarations:
  102. ------------------------------------------------------------------------
  103. */
  104.  
  105. /* if using MEL for input, then must define the MEL input data object: */
  106. #ifdef MEL_INPUT
  107.  
  108. /* firstly, define input constants (all must be CUSTOMIZED): */
  109.  
  110. #define MELI_MAX_DESCRIP_STR_LEN 256
  111.     /* maximum number of characters in any input descriptor string. */
  112. #define MELI_MAX_PARAMS 6
  113.     /* maximum number of parameters for any descriptor (min = 1). */
  114. #define MELI_MAX_PARAM_STR_LEN 80
  115. #define MELI_MAX_PARAM_ARRAY_STR_LEN 1
  116.     /* largest allowable parameter string lengths (min = 1) */
  117. #define MELI_MAX_PARAM_INT_ARRAY_LEN 1
  118. #define MELI_MAX_PARAM_REAL_ARRAY_LEN 1
  119. #define MELI_MAX_PARAM_STR_ARRAY_LEN 1
  120.     /* maximum number of elements in parameter data arrays (min = 1). */
  121. #define MELI_UNITS_STR_LEN 80
  122.     /* maximum length of units associated with any param (min = 1) */
  123.  
  124. /* secondly, define input data structures: */
  125.  
  126. union meli_param_data {
  127.     int integer;
  128.     double real;
  129.     char string[MELI_MAX_PARAM_STR_LEN+1];
  130.     int integer_array[MELI_MAX_PARAM_INT_ARRAY_LEN];
  131.     double real_array[MELI_MAX_PARAM_REAL_ARRAY_LEN];
  132.     char string_array[MELI_MAX_PARAM_STR_ARRAY_LEN]
  133.              [MELI_MAX_PARAM_ARRAY_STR_LEN+1];
  134. };
  135. /* this is used for input parameter data. it may either be an integer,
  136.    real, string, array of integers, array of reals, or an array of
  137.    strings. (to save space a union was used.) */
  138.  
  139. /* thirdly, define input variables: */
  140.  
  141. char meli_descriptor_string[MELI_MAX_DESCRIP_STR_LEN+1];
  142.     /* global storage for the input descriptor string. */
  143.  
  144. /* lastly, define input functions (typically they return 0 if no error
  145.    encountered, else some nonzero error code): */
  146.  
  147. int meli_file(FILE *meli_file_handle);
  148.     /* read a descriptor string from the input stream and call meli().
  149.        also, put copy of string read into meli_descriptor_string. */
  150. int meli(void);
  151.     /* translate meli_descriptor_string and put information into a private
  152.        data structure (meli_datum). */
  153. char *meli_descrip_type(void);
  154.     /* return pointer to name of type of descriptor read by meli(). */
  155. int meli_num_params(void);
  156.     /* return number of parameters read by meli(). */
  157. int meli_param(int param_num, char *param, union meli_param_data *data,
  158.     char *units, int *array_len, int *unknown_flag);
  159.     /* fill arguement list with param_num'th parameter read by meli().
  160.        (start with param_num = 0.) */
  161. int meli_data(char *param, union meli_param_data *data,
  162.     char *units, int *array_len, int *unknown_flag);
  163.     /* see if *param was input. if it was, then fill argument list with
  164.        data from meli_datum. */
  165.  
  166. #endif /* MEL_INPUT */
  167.  
  168. /* if using MEL for output, must define the MEL output data object: */
  169. #ifdef MEL_OUTPUT
  170.  
  171. /* firstly, define output constants (all must be CUSTOMIZED): */
  172.  
  173. #define MELO_MAX_DESCRIP_STR_LEN 256
  174.     /* how many characters can be in an output descriptor string? */
  175. #define MELO_MAX_PARAMS 6
  176.     /* maximum number of parameters for any descriptor. */
  177. #define MELO_MAX_PARAM_STR_LEN 80
  178. #define MELO_MAX_PARAM_ARRAY_STR_LEN 1
  179.     /* largest allowable parameter string length. */
  180. #define MELO_MAX_PARAM_INT_ARRAY_LEN 1
  181. #define MELO_MAX_PARAM_REAL_ARRAY_LEN 1
  182. #define MELO_MAX_PARAM_STR_ARRAY_LEN 1
  183.     /* maximum number of elements in array of parameter data. */
  184. #define MELO_UNITS_STR_LEN 80
  185.     /* maximum string length of any units associated with a param. */
  186.  
  187. /* secondly, define output data structures: */
  188.  
  189. union melo_param_data {
  190.     int integer;
  191.     double real;
  192.     char string[MELO_MAX_PARAM_STR_LEN+1];
  193.     int integer_array[MELO_MAX_PARAM_INT_ARRAY_LEN];
  194.     double real_array[MELO_MAX_PARAM_REAL_ARRAY_LEN];
  195.     char string_array[MELO_MAX_PARAM_STR_ARRAY_LEN]
  196.              [MELO_MAX_PARAM_ARRAY_STR_LEN+1];
  197. };
  198. /* this is for output parameter data. it may either be an integer, real,
  199.    string, array of integers, array of reals, or an array of
  200.    strings. (to save space a union was used.) */
  201.  
  202. /* thirdly, define output variables: */
  203.  
  204. char melo_descriptor_string[MELO_MAX_DESCRIP_STR_LEN+1];
  205.     /* global storage for the output descriptor string. */
  206.  
  207. /* lastly, define output functions (typically return 0 if no error): */
  208.  
  209. int melo_init(char *descrip_type);
  210.     /* initialize private data structure (melo_datum) to accept parameter
  211.        data from following functions. output descriptor type wil