1 /* BEGIN INCLUDE FILE parse.incl.pl1 */
  2 
  3 
  4 /****^  HISTORY COMMENTS:
  5   1) change(91-01-09,Blackmore), approve(91-01-09,MCR8234),
  6      audit(91-12-05,Huen), install(92-04-24,MR12.5-1011):
  7      Change entry points for 'lex', 'lex$write_last_line', and
  8      'statement_type', for constant reference resolution fix.
  9                                                    END HISTORY COMMENTS */
 10 
 11 declare   attribute_parse     entry(ptr,ptr,fixed bin(15),bit(1) aligned);
 12                               /* parameter 1:     (input)   block node ptr                */
 13                               /* parameter 2:     (input)   symbol node ptr               */
 14                               /* parameter 3:     (in/out)  token index                   */
 15                               /* parameter 4:     (input)   called while doing generic    */
 16 
 17 declare   context             entry(ptr,ptr,fixed bin(15));
 18                               /* parameter 1:     (input)   usually token node ptr        */
 19                               /* parameter 2:     (input)   block node ptr                */
 20                               /* parameter 3:     (input)   context type                  */
 21 
 22 declare   data_list_parse     entry(fixed bin(15),ptr,ptr)
 23                               returns(bit(1) aligned);
 24                               /* parameter 1:     (in/out)  token index                   */
 25                               /* parameter 2:     (input)   block node ptr                */
 26                               /* parameter 3:     (output)  data list parse tree ptr      */
 27                               /* return:          (output)  valid parse bit               */
 28 
 29 declare   declare_label       entry(ptr,ptr,ptr,bit(3) aligned);
 30                               /* parameter 1:     (input)   block node ptr                */
 31                               /* parameter 2:     (input)   statement node ptr  */
 32                               /* parameter 3:     (input)   label list ptr or null        */
 33                               /* parameter 4:     (input)   declare type                  */
 34 
 35 declare   declare_parse       entry(fixed bin(15),ptr,ptr);
 36                               /* parameter 1:     (input)   token index                   */
 37                               /* parameter 2:     (input)   block node ptr                */
 38                               /* parameter 3:     (input)   label list ptr or null        */
 39 
 40 declare   declare_parse$abort entry(fixed bin(15),ptr);
 41                               /* parameter 1:     (input)   error number                  */
 42                               /* parameter 2:     (input)   any node ptr                  */
 43 
 44 declare   default_parse       entry(fixed bin(15),ptr,ptr);
 45                               /* parameter 1:     (input)   token index                   */
 46                               /* parameter 2:     (input)   block node ptr                */
 47                               /* parameter 3:     (input)   label list ptr or null        */
 48 
 49 declare   descriptor_parse    entry(ptr,ptr,fixed bin(15))
 50                               returns(ptr);
 51                               /* parameter 1:     (input)   block node ptr                */
 52                               /* parameter 2:     (input)   token node ptr or null        */
 53                               /* parameter 3:     (in/out)  token index                   */
 54                               /* return:          (output)  symbol node ptr               */
 55 
 56 declare   do_parse            entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
 57                               bit(1) aligned,bit(1) aligned,bit(1) aligned);
 58                               /* parameter 1:     (in/out)  token index                   */
 59                               /* parameter 2:     (input)   label list ptr or null        */
 60                               /* parameter 3:     (input)   conditions                    */
 61                               /* parameter 4:     (input)   father block node ptr         */
 62                               /* parameter 5:     (output)  end ptr                       */
 63                               /* parameter 6:     (input)   entry bit                     */
 64                               /* parameter 7:     (input)   return bit                    */
 65                               /* parameter 8:     (input)   iterative do bit              */
 66 
 67 declare   evaluate            entry(bit(9) aligned,ptr,ptr) returns(ptr);
 68                               /* parameter 1:     (input)   opcode              */
 69                               /* parameter 2:     (input)   left operand (token ptr)      */
 70                               /* parameter 3:     (input)   right operand (token ptr)     */
 71                               /* return:          (output)  ptr to result node  */
 72 
 73 declare   expression_parse    entry(fixed bin(15),ptr)
 74                               returns(ptr);
 75                               /* parameter 1:     (in/out)  token index                   */
 76                               /* parameter 2:     (input)   block node ptr                */
 77                               /* return:          (output)  expression parse tree ptr     */
 78 
 79 declare   format_list_parse   entry(fixed bin(15),ptr,ptr,ptr)
 80                               returns(bit(1) aligned);
 81                               /* parameter 1:     (in/out)  token index                   */
 82                               /* parameter 2:     (input)   block node ptr                */
 83                               /* parameter 3:     (input)   statement node ptr            */
 84                               /* parameter 4:     (output)  format list parse tree ptr    */
 85                               /* return:          (output)  valid parse bit               */
 86 
 87 declare   if_parse            entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
 88                               bit(1) aligned);
 89                               /* parameter 1:     (in/out)  token index                   */
 90                               /* parameter 2:     (input)   label list ptr or null        */
 91                               /* parameter 3:     (input)   conditions                    */
 92                               /* parameter 4:     (input)   father block node ptr         */
 93                               /* parameter 5:     (input)   end ptr                       */
 94                               /* parameter 6:     (output)  valid parse bit               */
 95 
 96 declare   io_statement_parse  entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
 97                               bit(1) aligned,bit(9) aligned);
 98                               /* parameter 1:     (in/out)  token index                   */
 99                               /* parameter 2:     (input)   label list ptr or null        */
100                               /* parameter 3:     (input)   conditions                    */
101                               /* parameter 4:     (input)   father block node ptr         */
102                               /* parameter 5:     (output)  end ptr                       */
103                               /* parameter 6:     (output)  valid parse bit               */
104                               /* parameter 7:     (output)  statement type                */
105 
106 declare   lex                 entry(ptr);
107                               /* parameter 1:     (input)   block node ptr                */
108 
109 declare   lex$write_last_line entry(ptr);
110                               /* parameter 1:     (input)   block node ptr                */
111 
112 declare   lex$initialize_lex  entry(ptr,fixed bin(15));
113                               /* parameter 1:     (input)   ptr to source                 */
114                               /* parameter 2:     (input)   length of source (chars)      */
115 
116 declare   on_parse            entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr);
117                               /* parameter 1:     (in/out)  token index                   */
118                               /* parameter 2:     (input)   label list ptr or null        */
119                               /* parameter 3:     (input)   conditions                    */
120                               /* parameter 4:     (input)   father block node ptr         */
121                               /* parameter 5:     (output)  end ptr (set to null)         */
122 
123 declare   on_parse$revert     entry(fixed bin(15),ptr,ptr);
124                               /* parameter 1:     (input)   token index         */
125                               /* parameter 2:     (input)   statement node ptr  */
126                               /* parameter 3:     (input)   block node ptr      */
127 
128 declare   parse               entry(ptr,ptr,fixed bin(15));
129                               /* parameter 1:     (output)  root ptr            */
130                               /* parameter 2      (input)   source ptr                    */
131                               /* parameter 3:     (input)   source length                 */
132 
133 declare   procedure_parse     entry(fixed bin(15),ptr,bit(12) aligned,ptr,ptr,
134                               bit(9) aligned,bit(1) aligned);
135                               /* parameter 1:     (in/out)  token index                   */
136                               /* parameter 2:     (input)   label list ptr or null        */
137                               /* parameter 3:     (input)   conditions                    */
138                               /* parameter 4:     (input)   father block node ptr         */
139                               /* parameter 5:     (output)  end ptr             */
140                               /* parameter 6:     (input)   block type                    */
141                               /* parameter 7:     (input)   no return statement bit       */
142 
143 declare   process_entry       entry(fixed bin(15),bit(9) aligned,ptr,ptr,bit(12) aligned);
144                               /* parameter 1:     (in/out)  token index                   */
145                               /* parameter 2:     (input)   statement type                */
146                               /* parameter 3:     (input)   block node ptr                */
147                               /* parameter 4:     (input)   label list ptr or null        */
148                               /* parameter 5:     (input)   conditions                    */
149 
150 declare   reference_parse     entry(fixed bin(15),ptr)
151                               returns(ptr);
152                               /* parameter 1:     (in/out)  token index                   */
153                               /* parameter 2:     (input)   block node ptr                */
154                               /* return:          (output)  reference parse tree ptr      */
155 
156 declare   reserve$rename_parse entry(fixed bin(15)) returns(bit(1) aligned);
157                               /* parameter 1:     (in/out)  token index          */
158                               /* return:          (output)  success bit          */
159 
160 declare   statement_parse     entry(fixed bin(15),ptr,bit(12) aligned,ptr,fixed bin(15));
161                               /* parameter 1:     (in/out)  token index                   */
162                               /* parameter 2:     (input)   label list ptr or null        */
163                               /* parameter 3:     (input)   conditions                    */
164                               /* parameter 4:     (input)   block node ptr                */
165                               /* parameter 5:     (input)   statement type                */
166 
167 declare   statement_type      entry(ptr,fixed bin(15),ptr,bit(12) aligned)
168                               returns(fixed bin(15));
169                               /* parameter 1:     (input)   block node ptr                */
170                               /* parameter 2:     (in/out)  token index                   */
171                               /* parameter 3:     (output)  label list ptr or null        */
172                               /* parameter 4:     (output)  conditions                    */
173                               /* return:          (output)  statement type                */
174 
175 %include language_utility;
176 /* END INCLUDE FILE parse.incl.pl1 */