1 /* BEGIN INCLUDE FILE ... semant.incl.pl1 */
  2 
  3 /* Modified: 30 Aug 1979 by PCK to fix 1804 and 1823 */
  4 /* Modified: 26 Aug 1979 by PCK to implement by name assignment */
  5 
  6 
  7 declare   alloc_semantics     entry(pointer,pointer,pointer);
  8                               /* parameter 1:     (input)   block node pointer            */
  9                               /* parameter 2:     (input)   statement node pointer        */
 10                               /* parameter 3:     (in/out)  tree pointer                  */
 11 
 12 declare   alloc_semantics$init_only entry(pointer,pointer,pointer);
 13                               /* parameter 1:     (input)   qualifier pointer             */
 14                               /* parameter 2:     (input)   statement node pointer        */
 15                               /* parameter 3:     (input)   symbol node pointer           */
 16 
 17 declare   builtin             entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned)
 18                               returns(pointer);
 19                               /* parameter 1:     (input)   block node pointer            */
 20                               /* parameter 2:     (input)   statement node pointer        */
 21                               /* parameter 3:     (input)   tree pointer                  */
 22                               /* parameter 4:     (input)   subscript pointer             */
 23                               /* parameter 5:     (input)   builtin symbol node pointer   */
 24                               /* parameter 6:     (in/out)  context                       */
 25                               /* return:          (output)  tree pointer                  */
 26 
 27 declare   check_star_extents  entry(pointer,pointer);
 28                               /* parameter 1:     (input) symbol node of procedure        */
 29                               /* parameter 2:     (input) argument list pointer           */
 30 
 31 declare   compare_declaration entry(pointer,pointer,bit(1) aligned) reducible
 32                               returns(bit(1) aligned);
 33                               /* parameter 1:     (input)   reference or symbol node ptr  */
 34                               /* parameter 2:     (input)   symbol node ptr     */
 35                               /* parameter 3:     (input)   "1"b if aligned attribute ignored for string      */
 36                               /* return:          (output)  compare bit                   */
 37 
 38 declare   context_processor   entry(pointer,label);
 39                               /* parameter 1:     (input)   root block node pointer       */
 40 
 41 declare   declare             entry(pointer);
 42                               /* parameter 1:     (input)   symbol node pointer           */
 43 
 44 declare   declare_structure   entry(pointer);
 45                               /* parameter 1:     (input)   symbol node pointer           */
 46 
 47 declare   defined_reference   entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned)
 48                               returns(pointer);
 49                               /* parameter 1:     (input)   block node pointer            */
 50                               /* parameter 2:     (input)   statement node pointer        */
 51                               /* parameter 3:     (input)   tree pointer                  */
 52                               /* parameter 4:     (input)   subscript list pointer or null*/
 53                               /* parameter 5:     (input)   symbol node pointer           */
 54                               /* parameter 6:     (in/out)  context                       */
 55                               /* return:          (output)  tree pointer                  */
 56 
 57 declare   do_semantics        entry(pointer,pointer,pointer);
 58                               /* parameter 1:     (input)   block node pointer            */
 59                               /* parameter 2:     (input)   statement node pointer        */
 60                               /* parameter 3:     (input)   tree pointer                  */
 61 
 62 declare   expand_assign       entry(pointer,pointer,pointer,bit(36) aligned,pointer)
 63                               returns(pointer);
 64                               /* parameter 1:     (input)   block node pointer            */
 65                               /* parameter 2:     (input)   statement node pointer        */
 66                               /* parameter 3:     (input)   tree pointer                  */
 67                               /* parameter 4:     (in/out)  context                       */
 68                               /* parameter 5:     (input)   aggregate reference node ptr  */
 69                               /* return:          (output)  tree pointer                  */
 70 
 71 declare   expand_by_name      entry(pointer,pointer,pointer);
 72                               /* parameter 1:     (input)   block node pointer            */
 73                               /* parameter 2:     (input)   statement node pointer        */
 74                               /* parameter 3:     (input/output)      tree pointer                  */
 75 
 76 declare   expand_infix        entry(pointer,pointer,pointer,bit(36) aligned)
 77                               returns(pointer);
 78                               /* parameter 1:     (input)   block node pointer            */
 79                               /* parameter 2:     (input)   statement node pointer        */
 80                               /* parameter 3:     (input)   tree pointer                  */
 81                               /* parameter 4:     (in/out)  context                       */
 82                               /* return:          (output)  tree pointer                  */
 83 
 84 declare   expand_initial      entry(pointer,pointer,pointer);
 85                               /* parameter 1:     (input)   symbol node pointer           */
 86                               /* parameter 2:     (input)   statement node pointer        */
 87                               /* parameter 3:     (input)   locator                       */
 88 
 89 declare   expand_prefix       entry(pointer,pointer,pointer,bit(36) aligned)
 90                               returns(pointer);
 91                               /* parameter 1:     (input)   block node pointer            */
 92                               /* parameter 2:     (input)   statement node pointer        */
 93                               /* parameter 3:     (input)   tree pointer                  */
 94                               /* parameter 4:     (in/out)  context                       */
 95                               /* return:          (output)  tree pointer                  */
 96 
 97 declare   expand_primitive    entry(pointer,pointer,pointer,bit(36) aligned)
 98                               returns(pointer);
 99                               /* parameter 1:     (input)   block node pointer            */
100                               /* parameter 2:     (input)   statement node pointer        */
101                               /* parameter 3:     (input)   tree pointer                  */
102                               /* parameter 4:     (input)   context                       */
103                               /* return:          (output)  tree pointer                  */
104 
105 declare   expression_semantics entry(pointer,pointer,pointer,bit(36) aligned)
106                               returns(pointer);
107                               /* parameter 1:     (input)   block node pointer            */
108                               /* parameter 2:     (input)   statement node pointer        */
109                               /* parameter 3:     (input)   tree pointer                  */
110                               /* parameter 4:     (in/out)  context                       */
111                               /* return:          (output)  tree pointer                  */
112 
113 declare   fill_refer          entry(pointer,pointer,bit(1) aligned)
114                               returns(pointer);
115                               /* parameter 1:     (input)   null,ref node,op node ptr */
116                               /* parameter 2:     (input)   null,ref node,op node ptr */
117                               /* parameter 3:     (input)   copy switch for param 2 */
118                               /* return:          (output)  ptr to processed tree */
119 
120 declare   io_data_list_semantics$format_list_semantics entry(pointer,pointer,pointer);
121                               /* parameter 1:     (input)   block node pointer            */
122                               /* parameter 2:     (input)   statement node pointer        */
123                               /* parameter 3:     (in/out)  tree pointer                  */
124 
125 declare   function            entry(pointer,pointer,pointer,pointer,bit(36) aligned)
126                               returns(pointer);
127                               /* parameter 1:     (input)   block node pointer            */
128                               /* parameter 2:     (input)   statement node pointer        */
129                               /* parameter 3:     (input)   tree pointer                  */
130                               /* parameter 4:     (input)   symbol node pointer           */
131                               /* parameter 5:     (in/out)  context                       */
132                               /* return:          (output)  tree pointer                  */
133 
134 declare   generic_selector    entry(pointer,pointer,pointer,pointer,bit(36) aligned)
135                               returns(pointer);
136                               /* parameter 1:     (input)   block node pointer  */
137                               /* parameter 2:     (input)   statement node pointer        */
138                               /* parameter 3:     (input)   tree pointer        */
139                               /* parameter 4:     (input)   pointer to argument list      */
140                               /* parameter 5:     (in/out)  context             */
141                               /* return:          (output)  tree pointer        */
142 
143 declare   io_data_list_semantics entry(pointer,pointer,pointer);
144                               /* parameter 1:     (input)   block node pointer            */
145                               /* parameter 2:     (input)   statement node pointer        */
146                               /* parameter 3:     (input)   operator node pointer         */
147 
148 declare   io_semantics        entry(pointer,pointer,pointer);
149                               /* parameter 1:     (input)   block node pointer            */
150                               /* parameter 2:     (input)   statement node pointer        */
151                               /* parameter 3:     (input)   tree pointer                  */
152 
153 declare   lookup              entry(pointer,pointer,pointer,pointer,bit(36) aligned)
154                               returns(bit(1) aligned);
155                               /* parameter 1:     (input)   block node pointer            */
156                               /* parameter 2:     (input)   stmnt|symbol node pointer     */
157                               /* parameter 3:     (input)   token or reference node ptr   */
158                               /* parameter 4:     (output)  symbol node pointer           */
159                               /* parameter 5:     (in/out)  context                       */
160                               /* return:          (output)  symbol found bit              */
161 
162 declare   make_non_quick      entry(pointer, bit (36) aligned);
163                               /* parameter 1:     (input)   tree pointer        */
164                               /* parameter 2:     (input)   reason why being made nonquick */
165 
166 declare   match_arguments     entry(pointer,pointer) reducible
167                               returns(bit(1) aligned);
168                               /* parameter 1:     (input)   reference or symbol node ptr  */
169                               /* parameter 2:     (input)   reference or symbol node ptr  */
170                               /* return:          (output)  compare bit                   */
171 
172 declare   offset_adder        entry(pointer,fixed binary(31),fixed binary(3),bit(1) aligned,
173                                     pointer,fixed binary(31),fixed binary(3),bit(1) aligned,bit(1));
174                               /* parameter 1:     (in/out)  tree pointer                  */
175                               /* parameter 2:     (in/out)  constant size                 */
176                               /* parameter 3:     (in/out)  units                         */
177                               /* parameter 4:     (in/out)  ON if units ^= word_, but tree in words */
178                               /* parameter 5:     (input)   tree pointer                  */
179                               /* parameter 6:     (input)   constant size                 */
180                               /* parameter 7:     (input)   units                         */
181                               /* parameter 8:     (input)   ON if units ^= word_, but tree in words */
182                               /* parameter 9:     (input)   ON if should not improve units          */
183 
184 declare   operator_semantics  entry(pointer,pointer,pointer,bit(36) aligned)
185                               returns(pointer);
186                               /* parameter 1:     (input)   block node pointer            */
187                               /* parameter 2:     (input)   statement node pointer        */
188                               /* parameter 3:     (input)   tree pointer                  */
189                               /* parameter 4:     (in/out)  context                       */
190                               /* return:          (output)  tree pointer                  */
191 
192 declare   propagate_bit       entry(pointer,fixed binary(15));
193                               /* parameter 1:     (input)   symbol node pointer           */
194                               /* parameter 2:     (input)   attribute number              */
195 
196 declare   semantic_translator$call_es entry(pointer,pointer,pointer,label,bit(1) aligned)
197                               returns(pointer);
198                               /* parameter 1:     (input)   block ptr */
199                               /* parameter 2:     (input)   statement ptr       */
200                               /* parameter 3:     (input)   tree ptr  */
201                               /* parameter 4:     (input)   failure label       */
202                               /* parameter 5:     (input)   "1"b -- convert to integer    */
203                               /* return:          (output)  tree ptr            */
204 
205 declare   simplify_expression entry(pointer,fixed bin,bit(1)aligned);
206                               /* parameter 1:     (in/out)  tree pointer                  */
207                               /* parameter 2:     (output)  value of constant, if the entire tree
208                                                             is simplified                 */
209                               /* parameter 3:     (output)  bit indicating if the tree has
210                                                             been simplified               */
211 
212 declare   simplify_offset     entry(pointer,bit(36) aligned);
213                               /* parameter 1:     (input)   reference node pointer        */
214                               /* parameter 2:     (input)   context                       */
215 
216 declare   subscripter         entry(pointer,pointer,pointer,pointer,pointer)
217                               returns(pointer);
218                               /* parameter 1:     (input)   block node pointer            */
219                               /* parameter 2:     (input)   statement node pointer        */
220                               /* parameter 3:     (input)   tree pointer                  */
221                               /* parameter 4:     (in/out)  subscript list pointer        */
222                               /* parameter 5:     (input)   symbol node pointer           */
223                               /* return:          (output)  reference node pointer        */
224 
225 declare   validate            entry(pointer);
226                               /* parameter 1:     (input)   symbol node pointer           */
227 
228 %include language_utility;
229 /* END INCLUDE FILE ... semant.incl.pl1 */