home *** CD-ROM | disk | FTP | other *** search
/ ftptest.leeds.ac.uk / 2015.02.ftptest.leeds.ac.uk.tar / ftptest.leeds.ac.uk / bionet / CAE-GROUP / SCL-WIN3x / FED_PLUS.EXE / ALG.H < prev    next >
C/C++ Source or Header  |  1994-07-25  |  6KB  |  190 lines
  1. #ifndef ALG_H
  2. #define ALG_H
  3.  
  4. /* $Id: alg.h,v 1.2 1993/10/15 18:48:24 libes Exp $ */
  5.  
  6. /************************************************************************
  7. ** Module:    Algorithm
  8. ** Description:    This module implements the Algorithm abstraction.  An
  9. **    algorithm can be a procedure, a function, or a rule.  It consists
  10. **    of a name, a return type (for functions and rules), a list of
  11. **    formal parameters, and a list of statements (body).
  12. ** Constants:
  13. **    ALGORITHM_NULL    - the null algorithm
  14. **
  15. ************************************************************************/
  16.  
  17. /*
  18.  * This software was developed by U.S. Government employees as part of
  19.  * their official duties and is not subject to copyright.
  20.  *
  21.  * $Log: alg.h,v $
  22.  * Revision 1.2  1993/10/15  18:48:24  libes
  23.  * CADDETC certified
  24.  *
  25.  * Revision 1.4  1993/02/16  03:13:56  libes
  26.  * add Where type
  27.  *
  28.  * Revision 1.3  1992/08/18  17:12:41  libes
  29.  * *** empty log message ***
  30.  *
  31.  * Revision 1.2  1992/06/08  18:06:24  libes
  32.  * prettied up interface to print_objects_when_running
  33.  *
  34.  */
  35.  
  36. /*************/
  37. /* constants */
  38. /*************/
  39.  
  40. /*****************/
  41. /* packages used */
  42. /*****************/
  43.  
  44. #include "expbasic.h"    /* get basic definitions */
  45. #include "symbol.h"
  46. #include "scope.h"
  47. #include "type.h" 
  48. #include "memory.h"
  49.  
  50. /************/
  51. /* typedefs */
  52. /************/
  53.  
  54. typedef struct Scope *Procedure;
  55. typedef struct Scope *Function;
  56. typedef struct Scope *Rule;
  57. typedef struct Where *Where;
  58.  
  59. /****************/
  60. /* modules used */
  61. /****************/
  62.  
  63. /***************************/
  64. /* hidden type definitions */
  65. /***************************/
  66.  
  67. /* each formal tag has one of these structs allocated to it */
  68. /* As each (real) call is resolved, the tag->type is temporarily borrowed */
  69. struct tag {
  70.     char *name;
  71.     Type type;
  72. };
  73.  
  74. /* 'parameters' are lists of lists of (type) expressions */
  75. struct Procedure {
  76.     int pcount;    /* # of parameters */
  77.     int tag_count;    /* # of different parameter tags */
  78.     Linked_List parameters;
  79.     Linked_List body;
  80.     int builtin;    /* builtin if true */
  81. };
  82.  
  83. struct Function {
  84.     int pcount;    /* # of parameters */
  85.     int tag_count;    /* # of different parameter/return value tags */
  86.     Linked_List parameters;
  87.     Linked_List body;
  88.     Type return_type;
  89.     int builtin;    /* builtin if true */
  90. };
  91.  
  92. struct Rule {
  93.     Linked_List parameters;
  94.     Linked_List body;
  95. /*
  96.     Linked_List where;
  97.     moved to Scope - DEL 22-Jul-1993
  98. */
  99. };
  100.  
  101. /* define a where clause */
  102. struct Where {
  103.     Symbol        *label;
  104.     Expression    expr;
  105. };
  106.  
  107. /********************/
  108. /* global variables */
  109. /********************/
  110.  
  111. #ifdef ALG_C
  112. #include "defstart.h"
  113. #else
  114. #include "decstart.h"
  115. #endif /* ALGORITHM_C */
  116.  
  117. GLOBAL struct freelist_head ALG_fl;
  118. GLOBAL struct freelist_head FUNC_fl;
  119. GLOBAL struct freelist_head RULE_fl;
  120. GLOBAL struct freelist_head PROC_fl;
  121. GLOBAL struct freelist_head WHERE_fl;
  122.  
  123. #include "de_end.h"
  124.  
  125. /******************************/
  126. /* macro function definitions */
  127. /******************************/
  128.  
  129. #define ALG_new()    (struct Algorithm *)MEM_new(&ALG_fl);
  130. #define ALG_destroy(x)    MEM_destroy(&ALG_fl,(Freelist *)(Generic)x)
  131. #define FUNC_new()    (struct Function *)MEM_new(&FUNC_fl)
  132. #define FUNC_destroy(x)    MEM_destroy(&FUNC_fl,(Freelist *)(Generic)x)
  133. #define RULE_new()    (struct Rule *)MEM_new(&RULE_fl)
  134. #define RULE_destroy(x)    MEM_destroy(&RULE_fl,(Freelist *)(Generic)x)
  135. #define PROC_new()    (struct Procedure *)MEM_new(&PROC_fl)
  136. #define PROC_destroy(x)    MEM_destroy(&PROC_fl,(Freelist *)(Generic)x)
  137. #define WHERE_new()    (struct Where *)MEM_new(&WHERE_fl)
  138. #define WHERE_destroy(x) MEM_destroy(&WHERE_fl,(Freelist *)(Generic)x)
  139.  
  140. #define ALGput_name(algorithm, name)    SCOPEput_name(algorithm,name)
  141. #define ALGget_name(algorithm)        SCOPEget_name(algorithm)
  142. #define ALGget_symbol(a)        SCOPEget_symbol(a)
  143. #define RULEget_name(r)            SCOPEget_name(r)
  144. #define FUNCget_name(f)            SCOPEget_name(f)
  145. #define PROCget_name(p)            SCOPEget_name(p)
  146. #define RULEput_name(r)            SCOPEput_name(r,n)
  147. #define FUNCput_name(f)            SCOPEput_name(f,n)
  148. #define PROCput_name(p)            SCOPEput_name(p,n)
  149. #define RULEget_symbol(r)        SCOPEget_symbol(r)
  150. #define FUNCget_symbol(f)        SCOPEget_symbol(f)
  151. #define PROCget_symbol(r)        SCOPEget_symbol(p)
  152. #define FUNCget_parameters(f)    ((f)->u.func->parameters)
  153. #define RULEget_parameters(r)    ((r)->u.rule->parameters)
  154. #define PROCget_parameters(p)    ((p)->u.proc->parameters)
  155. #define FUNCget_body(f)        ((f)->u.func->body)
  156. #define RULEget_body(r)        ((r)->u.rule->body)
  157. #define RULEput_body(r,b)    ((r)->u.rule->body = b)
  158. #define PROCget_body(p)        ((p)->u.proc->body)
  159. #define FUNCget_return_type(f)    ((f)->u.func->return_type)
  160. #define RULEget_where(r)    ((r)->where)
  161. #define RULEput_where(r,w)    ((r)->where = (w))
  162. /*
  163. #define RULEget_where_clause(r)    ((r)->u.rule->where)
  164. */
  165. #define WHEREget_label(w)    ((w)->label)
  166. #define WHEREget_expression(w)    ((w)->expr)
  167.  
  168. #if 0
  169. extern void        ALGput_parameters PROTO((Algorithm, Linked_List ));
  170. extern void        ALGput_body PROTO((Algorithm, Linked_List ));
  171. extern void        FUNCput_return_type PROTO((Algorithm, Type));
  172. extern void        RULEput_where_clause PROTO((Algorithm,Linked_List));
  173. #endif
  174.  
  175. /***********************/
  176. /* function prototypes */
  177. /***********************/
  178.  
  179. extern Scope        ALGcreate PROTO((char));
  180. extern void        ALGinitialize PROTO((void));
  181.  
  182. /********************/
  183. /* inline functions */
  184. /********************/
  185.  
  186. #if supports_inline_functions || defined(ALG_C)
  187. #endif /* supports_inline_functions || defined(ALGORITHM_C) */
  188.  
  189. #endif /* ALGORITHM_H */
  190.