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 / STMT.C < prev    next >
C/C++ Source or Header  |  1994-07-23  |  8KB  |  259 lines
  1. static char rcsid[] = "$Id: stmt.c,v 1.2 1993/10/15 18:48:48 libes Exp $";
  2.  
  3. /************************************************************************
  4. ** Module:    Statement
  5. ** Description:    This module implements the Statement abstraction.  A
  6. **    statement is, in effect, a typeless Expression.  Due to the
  7. **    existence of complex language constructs, however, it often is
  8. **    not practical to implement the abstraction thus.  For this reason,
  9. **    there is a separate module for statements.  This abstraction
  10. **    supports various looping constructs, if/then/else, switch
  11. **    statements, and procedure calls.
  12. ** Constants:
  13. **    STATEMENT_NULL    - the null statement
  14. **
  15. ************************************************************************/
  16.  
  17. /*
  18.  * This code was developed with the support of the United States Government,
  19.  * and is not subject to copyright.
  20.  *
  21.  * $Log: stmt.c,v $
  22.  * Revision 1.2  1993/10/15  18:48:48  libes
  23.  * CADDETC certified
  24.  *
  25.  * Revision 1.6  1993/02/16  03:27:02  libes
  26.  * removed artifical begin/end nesting for improved reconstruction (printing)
  27.  * of original Express file
  28.  *
  29.  * Revision 1.5  1992/08/18  17:13:43  libes
  30.  * rm'd extraneous error messages
  31.  *
  32.  * Revision 1.4  1992/06/08  18:06:57  libes
  33.  * prettied up interface to print_objects_when_running
  34.  * 
  35.  * Revision 4.1  90/09/13  15:13:01  clark
  36.  * BPR 2.1 alpha
  37.  * 
  38.  */
  39.  
  40. #define STMT_C
  41. #include "stmt.h"
  42.  
  43. Statement 
  44. STMTcreate(int type)
  45. {
  46.     Statement s;
  47.     s = STMT_new();
  48.     SYMBOLset(s);
  49.     s->type = type;
  50.     return s;
  51. }
  52.  
  53. /*
  54. ** Procedure:    STMTinitialize
  55. ** Parameters:    -- none --
  56. ** Returns:    void
  57. ** Description:    Initialize the Statement module.
  58. */
  59.  
  60. void
  61. STMTinitialize(void)
  62. {
  63.     MEMinitialize(&STMT_fl,sizeof(struct Statement),500,100);
  64.  
  65.     MEMinitialize(&ALIAS_fl,sizeof(struct Alias),10,10);
  66.     MEMinitialize(&ASSIGN_fl,sizeof(struct Assignment),100,30);
  67.     MEMinitialize(&CASE_fl,sizeof(struct Case_Statement),100,30);
  68.     MEMinitialize(&COMP_STMT_fl,sizeof(struct Compound_Statement),100,30);
  69.     MEMinitialize(&COND_fl,sizeof(struct Conditional),100,30);
  70.     MEMinitialize(&LOOP_fl,sizeof(struct Loop),100,30);
  71.     MEMinitialize(&PCALL_fl,sizeof(struct Procedure_Call),100,30);
  72.     MEMinitialize(&RET_fl,sizeof(struct Return_Statement),100,30);
  73.     MEMinitialize(&INCR_fl,sizeof(struct Increment),100,30);
  74.  
  75.     OBJcreate(OBJ_ALIAS,SCOPE_get_symbol,"alias scope",OBJ_UNUSED_BITS);
  76.     OBJcreate(OBJ_INCREMENT,SCOPE_get_symbol,"increment scope",OBJ_UNUSED_BITS);
  77.  
  78.     STATEMENT_SKIP = STMTcreate(STMT_SKIP);
  79.     STATEMENT_ESCAPE = STMTcreate(STMT_ESCAPE);
  80. }
  81.  
  82. /*
  83. ** Procedure:    ASSIGNcreate
  84. ** Parameters:    Expression lhs    - the left-hand-side of the assignment
  85. **        Expression rhs    - the right-hand-side of the assignment
  86. **        Error*     errc    - buffer for error code
  87. ** Returns:    Assignment    - the assignment statement created
  88. ** Description:    Create and return an assignment statement.
  89. */
  90.  
  91. Statement 
  92. ASSIGNcreate(Expression lhs, Expression rhs)
  93. {
  94.     Statement s;
  95.     s = STMTcreate(STMT_ASSIGN);
  96.     s->u.assign = ASSIGN_new();
  97.     s->u.assign->lhs = lhs;
  98.     s->u.assign->rhs = rhs;
  99.     return s;
  100. }
  101.  
  102. /*
  103. ** Procedure:    CASEcreate
  104. ** Parameters:    Expression  selector    - expression to case on
  105. **        Linked_List cases    - list of Case_Items
  106. **        Error*      errc    - buffer for error code
  107. ** Returns:    Case_Statement        - the case statement created
  108. ** Description:    Create and return a case statement.
  109. */
  110.  
  111. Statement 
  112. CASEcreate(Expression selector, Linked_List cases)
  113. {
  114.     Statement s;
  115.  
  116.     s = STMTcreate(STMT_CASE);
  117.     s->u.Case = CASE_new();
  118.     s->u.Case->selector = selector;
  119.     s->u.Case->cases = cases;
  120.     return(s);
  121. }
  122.  
  123. /*
  124. ** Procedure:    COMP_STMTcreate
  125. ** Parameters:    Linked_List statements    - list of Statements making up
  126. **                      the compound statement
  127. **        Error*      errc    - buffer for error code
  128. ** Returns:    Compound_Statement    - the compound statement created
  129. ** Description:    Create and return a compound statement.
  130. */
  131.  
  132. Statement 
  133. COMP_STMTcreate(Linked_List statements)
  134. {
  135.     Statement s;
  136.     s = STMTcreate(STMT_COMPOUND);
  137.     s->u.compound = COMP_STMT_new();
  138.     s->u.compound->statements = statements;
  139.     return s;
  140. }
  141.  
  142. /*
  143. ** Procedure:    CONDcreate
  144. ** Parameters:    Expression test        - the condition for the if
  145. **        Statement  then        - code executed for test == true
  146. **        Statement  otherwise    - code executed for test == false
  147. **        Error*      errc    - buffer for error code
  148. ** Returns:    Conditional        - the if statement created
  149. ** Description:    Create and return an if statement.
  150. */
  151.  
  152. Statement 
  153. CONDcreate(Expression test, Linked_List then, Linked_List otherwise)
  154. {
  155.     Statement s;
  156.     s = STMTcreate(STMT_COND);
  157.     s->u.cond = COND_new();
  158.     s->u.cond->test = test;
  159.     s->u.cond->code = then;
  160.     s->u.cond->otherwise = otherwise;
  161.     return(s);
  162. }
  163.  
  164. /*
  165. ** Procedure:    PCALLcreate
  166. ** Parameters:    Procedure   procedure    - procedure called by statement
  167. **        Linked_List parameters    - list of actual parameter Expressions
  168. **        Error*      errc    - buffer for error code
  169. ** Returns:    Procedure_Call        - the procedure call generated
  170. ** Description:    Create and return a procedure call statement.
  171. */
  172.  
  173. Statement 
  174. PCALLcreate(Linked_List parameters)
  175. {
  176.     Statement s;
  177.     s = STMTcreate(STMT_PCALL);
  178.     s->u.proc = PCALL_new();
  179. /*    s->u.proc->procedure = 0;  fill in later during resolution  */
  180.     s->u.proc->parameters = parameters;
  181.     return s;
  182. }
  183.  
  184. /*
  185. ** Procedure:    LOOPcreate
  186. ** Parameters:    Linked_List controls    - list of Loop_Controls for the loop
  187. **        Statement   body    - statement to be repeated
  188. **        Error*      errc    - buffer for error code
  189. ** Returns:    Loop            - the loop generated
  190. ** Description:    Create and return a loop statement.
  191. */
  192.  
  193. Statement 
  194. LOOPcreate(Scope scope,Expression while_expr,Expression until_expr,Linked_List statements)
  195. {
  196.     Statement s = STMTcreate(STMT_LOOP);
  197.     s->u.loop = LOOP_new();
  198.     s->u.loop->scope = scope;
  199.     s->u.loop->while_expr = while_expr;
  200.     s->u.loop->until_expr = until_expr;
  201.     s->u.loop->statements = statements;
  202.     return(s);
  203. }
  204.  
  205. Statement 
  206. ALIAScreate(Scope scope,Variable variable,Linked_List statements)
  207. {
  208.     Statement s = STMTcreate(STMT_ALIAS);
  209.     s->u.alias = ALIAS_new();
  210.     s->u.alias->scope = scope;
  211.     s->u.alias->variable = variable;
  212.     s->u.alias->statements = statements;
  213.     return(s);
  214. }
  215.  
  216. /*
  217. ** Procedure:    INCR_CTLcreate
  218. ** Parameters:    Expression control    - controlling expression
  219. **        Expression start    - initial value
  220. **        Expression end        - terminal value
  221. **        Expression increment    - value by which to increment
  222. **        Error*     errc        - buffer for error code
  223. ** Returns:    Increment_Control    - increment control created
  224. ** Description:    Create and return an increment control as specified.
  225. */
  226.  
  227. Scope 
  228. INCR_CTLcreate(Symbol *control, Expression start,
  229.            Expression end, Expression increment)
  230. {
  231.     Scope s = SCOPEcreate_tiny(OBJ_INCREMENT);
  232.     Expression e = EXPcreate_from_symbol(Type_Attribute,control);
  233.     Variable v = VARcreate(e,Type_Number);
  234.     DICTdefine(s->symbol_table,control->name,
  235.         (Generic)v,control,OBJ_VARIABLE);
  236.     s->u.incr = INCR_new();
  237.     s->u.incr->init = start;
  238.     s->u.incr->end = end;
  239.     s->u.incr->increment = increment;
  240.     return s;
  241. }
  242.  
  243. /*
  244. ** Procedure:    RETcreate
  245. ** Parameters:    Expression expression    - value to return
  246. **        Error*     errc        - buffer for error code
  247. ** Returns:    Return_Statement    - the return statement created
  248. ** Description:    Create and return a return statement.
  249. */
  250.  
  251. Statement 
  252. RETcreate(Expression expression)
  253. {
  254.     Statement s = STMTcreate(STMT_RETURN);
  255.     s->u.ret = RET_new();
  256.     s->u.ret->value = expression;
  257.     return s;
  258. }
  259.