1 
  2 declare   builtin_function    entry(pointer,(128) pointer,fixed bin(15))
  3                               returns(pointer);
  4                               /* parameter 1:     (input)   symbol node pointer           */
  5                               /* parameter 2:     (input)   argument tree pointers        */
  6                               /* parameter 3:     (input)   number of arguments           */
  7                               /* return:          (output)  operator node pointer         */
  8 
  9 declare   builtin_function$declare_entry entry(pointer)
 10                               returns(pointer);
 11                               /* parameter 1:     (input)   symbol node pointer           */
 12                               /* return:          (output)  symbol node pointer           */
 13 
 14 declare   builtin_function$lookup entry(pointer)
 15                               returns(bit(1) aligned);
 16                               /* parameter 1:     (input)   symbol node pointer           */
 17                               /* return:          (output)  matching indicator bit        */
 18 
 19 declare   builtin_function$lookup_external entry(pointer)
 20                               returns (bit(1) aligned);
 21                               /* parameter 1:     (input)   symbol node pointer           */
 22                               /* return:          (output)  matching indicator bit        */
 23 
 24 declare   cardlex             entry(pointer,fixed bin(15));
 25                               /* parameter 1:     (output)  token node pointer            */
 26                               /* parameter 2:     (output)  character index               */
 27 
 28 declare   cardlex$initialize_lex entry(pointer,fixed bin(15));
 29                               /* parameter 1:     (input)   source segment pointer        */
 30                               /* parameter 2:     (input)   source string length          */
 31 
 32 declare   cardlex$write_last_line entry;
 33 
 34 declare   dcl$declaration_processor entry;
 35 
 36 declare   dcl$implicit_parse  entry;
 37 
 38 declare   dcl$make_declaration entry(pointer)
 39                               returns(pointer);
 40                               /* parameter 1:     (input)   token node pointer            */
 41                               /* return:          (output)  reference node pointer        */
 42 
 43 declare   declaration_parse$abnormal_parse entry;
 44 
 45 declare   declaration_parse$automatic_parse entry;
 46 
 47 declare   declaration_parse$character_parse entry;
 48 
 49 declare   declaration_parse$common_parse entry;
 50 
 51 declare   declaration_parse$complex_parse entry;
 52 
 53 declare   declaration_parse$data_parse entry;
 54 
 55 declare   declaration_parse$dimension_parse entry;
 56 
 57 declare   declaration_parse$double_precision_parse entry;
 58 
 59 declare   declaration_parse$equivalence_parse entry;
 60 
 61 declare   declaration_parse$external_parse entry;
 62 
 63 declare   declaration_parse$integer_parse entry;
 64 
 65 declare   declaration_parse$logical_parse entry;
 66 
 67 declare   declaration_parse$namelist_parse entry;
 68 
 69 declare   declaration_parse$real_parse entry;
 70 
 71 declare   flex                entry(pointer,fixed bin(15));
 72                               /* parameter 1:     (output)  token node pointer            */
 73                               /* parameter 2:     (output)  character index               */
 74 
 75 declare   flex$initialize_lex entry(pointer,fixed bin(15));
 76                               /* parameter 1:     (input)   source segment pointer        */
 77                               /* parameter 2:     (input)   source string length          */
 78 
 79 declare   flex$write_last_line entry;
 80 
 81 declare   fortran_assign_parse entry(pointer,pointer,fixed bin(15));
 82                               /* parameter 1:     (input)   statement node pointer        */
 83                               /* parameter 2:     (input)   block node pointer            */
 84                               /* parameter 3:     (input)   fortran statement type code   */
 85 
 86 declare   fortran_crse_parse  entry(pointer,pointer,fixed bin(15));
 87                               /* parameter 1:     (input)   statement node pointer        */
 88                               /* parameter 2:     (input)   block node pointer            */
 89                               /* parameter 3:     (input)   fortran statement type code   */
 90 
 91 declare   fortran_do_parse    entry(pointer);
 92                               /* parameter 1:     (input)   statement node pointer        */
 93 
 94 declare   fortran_do_parse$end_test entry;
 95 
 96 declare   fortran_expression_parse entry(pointer,pointer)
 97                               returns(bit(1) aligned);
 98                               /* parameter 1:     (input)   token node pointer            */
 99                               /* parameter 2:     (output)  expression pointer            */
100                               /* return:          (output)  error bit                     */
101 
102 declare   fortran_operator_semantics    entry(pointer)
103                               returns(pointer);
104                               /* parameter 1:     (input)   expression pointer            */
105                               /* return:          (output)  expression pointer            */
106 
107 declare   fortran_format_parse entry(pointer);
108                               /* parameter 1:     (input)   statement node pointer        */
109 
110 declare   fortran_if_parse    entry(pointer,pointer,fixed bin(15));
111                               /* parameter 1:     (input)   statement node pointer        */
112                               /* parameter 2:     (input)   block node pointer            */
113                               /* parameter 3:     (input)   fortran statement type code   */
114 
115 declare   fortran_io_parse    entry(pointer,pointer,fixed bin(15));
116                               /* parameter 1:     (input)   statement node pointer        */
117                               /* parameter 2:     (input)   block node pointer            */
118                               /* parameter 3:     (input)   fortran statement type code   */
119 
120 declare   fortran_parse       entry(pointer,pointer,fixed bin(18));
121                               /* parameter 1:     (output)  block node pointer            */
122                               /* parameter 2:     (input)   source segment pointer        */
123                               /* parameter 3:     (input)   source string length          */
124 
125 declare   fortran_parse$abort entry(fixed bin(15),pointer);
126                               /* parameter 1:     (input)   error message number          */
127                               /* parameter 2:     (input)   token node pointer            */
128 
129 declare   fortran_parse$call_es entry;
130 
131 declare   fortran_parse$error entry(fixed bin(15),pointer);
132                               /* parameter 1:     (input)   error message number          */
133                               /* parameter 2:     (input)   token node pointer            */
134 
135 declare   fortran_reference_parse       entry(pointer,pointer)
136                               returns(bit(1) aligned);
137                               /* parameter 1:     (i/o)     token node pointer            */
138                               /* parameter 2:     (output)  reference node pointer        */
139                               /* return:          (output)  error bit                     */
140 
141 declare   fortran_reference_parse$call entry(pointer,pointer)
142                               returns(bit(1) aligned);
143                               /* parameter 1:     (i/o)     token node pointer            */
144                               /* parameter 2:     (output)  reference node pointer        */
145                               /* return:          (output)  error bit                     */
146 
147 declare   fortran_reference_parse$left_side entry(pointer,pointer)
148                               returns(bit(1) aligned);
149                               /* parameter 1:     (i/o)     token node pointer            */
150                               /* parameter 2:     (output)  reference node pointer        */
151                               /* return:          (output)  error bit                     */
152 
153 declare   fortran_reference_parse$sf    entry(pointer,pointer)
154                               returns(bit(1) aligned);
155                               /* parameter 1:     (i/o)     token node pointer            */
156                               /* parameter 2:     (output)  reference node pointer        */
157                               /* return:          (output)  error bit                     */
158 
159 declare   fortran_reference_parse$make_call       entry(pointer, pointer, (128) pointer, fixed bin, bit(1) aligned)
160                               returns(pointer);
161                               /* parameter 1:     (input)   reference of function return value */
162                               /* parameeter 2:    (input)   entry name reference */
163                               /* parameter 3:     (input)   argument list excluding return value */
164                               /* parameter 4:     (input)   argument list count excluding return value */
165                               /* parameter 5:     (input)   On if descriptors are required */
166                               /* return:          (output)  pointer to std_call operator */
167 
168 declare   fortran_reserve$declare_lib entry(fixed bin(15))
169                               returns(pointer);
170                               /* parameter 1:     (input)   library entry index           */
171                               /* return:          (output)  reference node pointer        */
172 
173 declare   fortran_reserve$read_lib      entry(fixed bin(15))
174                               returns(pointer);
175                               /* parameter 1:     (input)   library entry index           */
176                               /* return:          (output)  token node pointer            */
177 
178 declare   fortran_subroutine_parse entry(pointer,pointer,fixed bin(15));
179                               /* parameter 1:     (input)   statement node pointer        */
180                               /* parameter 2:     (input)   block node pointer            */
181                               /* parameter 3:     (input)   fortran statement type code   */
182 
183 declare   fortran_subscripter entry(pointer,fixed bin(15),(128) pointer)
184                               returns(pointer);
185                               /* parameter 1:     (input)   symbol node pointer           */
186                               /* parameter 2:     (input)   number of subscripts          */
187                               /* parameter 3:     (input)   subscript expression pointers */
188                               /* return:          (output)  reference node pointer        */
189 
190 declare   general_format_parse_ entry(character(1024) aligned, character(2048) aligned, fixed bin(15));
191                               /* parameter 1:     (input)   string to be parsed           */
192                               /* parameter 2:     (output)  result of parse               */
193                               /* parameter 3:     (output)  error code                    */
194 
195 declare   go_to_parse         entry(pointer);
196                               /* parameter 1:     (input)   statement node pointer        */
197 
198 declare   initial_attribute   entry(pointer,pointer);
199                               /* parameter 1:     (input)   declaration list pointer      */
200                               /* parameter 2:     (i/o)     token node pointer            */
201 
202 declare   make_format         entry(pointer)
203                               returns(pointer);
204                               /* parameter 1:     (input)   token node pointer            */
205                               /* return:          (output)  symbol node pointer           */
206 
207 declare   make_label entry(pointer)
208                               returns(pointer);
209                               /* parameter 1:     (input)   token node pointer            */
210                               /* return:          (output)  pointer to label node         */
211 
212 declare   prologue_entry$auto_initial entry(pointer);
213                               /* parameter 1:     (input)   symbol node pointer           */
214 
215 declare   replace_parameters  entry(pointer,(128) pointer,fixed bin(15))
216                               returns(pointer);
217                               /* parameter 1:     (input)   statement function pointer    */
218                               /* parameter 2:     (input)   statement func arg pointers   */
219                               /* parameter 3:     (input)   number of arguments           */
220                               /* return:          (output)  expression pointer            */
221 
222 declare   set_parameters      entry(pointer,pointer)
223                               returns(pointer);
224                               /* parameter 1:     (input)   statement func expr pointer   */
225                               /* parameter 2:     (input)   list node pointer             */
226                               /* return:          (output)  statement func expr pointer   */
227 
228 declare   statement_recognizer entry(pointer)
229                               returns(fixed bin(8));
230                               /* parameter 1:     (output)  statement node pointer        */
231                               /* return:          (output)  fortran statement type code   */
232 
233 declare   statement_recognizer$back_up entry(fixed bin(15))
234                               returns(pointer);
235                               /* parameter 1:     (input)   token count                   */
236                               /* return:          (output)  token node pointer            */
237 
238 declare   statement_recognizer$back_up_statement entry
239                               returns(pointer);
240                               /* return:          (output)  token node pointer            */
241 
242 declare   statement_recognizer$from_if_parse entry(pointer)
243                               returns(fixed bin(8));
244                               /* parameter 1:     (output)  statement node pointer        */
245                               /* return:          (output)  fortran statement type code   */
246 
247 declare   statement_recognizer$init entry(pointer,pointer)
248                               returns(fixed bin(8));
249                               /* parameter 1:     (output)  statement node pointer        */
250                               /* parameter 2:     (input)   block node pointer            */
251                               /* return:          (output)  fortran statement type code   */
252 
253 declare   statement_recognizer$next_token entry
254                               returns(pointer);
255                               /* return:          (output)  token node pointer            */
256 
257 declare   statement_recognizer$top_of_stack entry
258                               returns(pointer);
259                               /* return:          (output)  token node pointer            */
260 
261 declare   stmnt_func_parse    entry(bit(1) aligned,pointer);
262                               /* parameter 1:     (output)  assignm stmnt type            */
263                               /* parameter 2:     (input)   statement node pointer        */
264 
265 declare   type$fix_array_sizes entry(pointer,fixed bin(24),fixed bin(24));
266                               /* parameter 1:     (input)   symbol node pointer           */
267                               /* parameter 2:     (input)   word size                     */
268                               /* parameter 3:     (input)   bit size                      */