Action unknown: copypageplugin__copy
cdc:nos2.source:opl.opl871:deck:tdutab
Deck TDUTAB
Library Member Format: MODIFY
Source
Seq # *Modification Id* Act
----------------------------+
00001 M00S00001.tdutab +++|*NOSEQ
00002 M00S00002.tdutab +++|*WIDTH 95
00003 M00S00003.tdutab +++|MODULE tdutab;
00004 M00S00004.tdutab +++|
00005 M00S00005.tdutab +++|?? SET ( CHKALL := ON ), RIGHT := 110 ??
00006 M00S00006.tdutab +++|
00007 M00S00007.tdutab +++|{ Module : TDUTAB }
| Line S00001 Modification History | |
|---|---|
M01 (Added by) | 281l803 |
Seq # *Modification Id* Act
----------------------------+
00008 M01S00001.281l803 +++|{ Copyright Control Data Systems Inc. 1992. }
00009 M00S00008.tdutab +++|{ Written: 1/84 by R. Lindsey }
00010 M00S00009.tdutab +++|{ Version: Cyber 170/180, version 1 }
00011 M00S00010.tdutab +++|{ Purpose: This module encapsulates the internal tables of the TDU program. }
00012 M00S00011.tdutab +++|{ It provides functions to add elements to the tables, to optimize }
00013 M00S00012.tdutab +++|{ them, and to return the elements for output. }
00014 M00S00013.tdutab +++|{ This module has no I/O. }
00015 M00S00014.tdutab +++|
00016 M00S00015.tdutab +++| ?? PUSH ( LIST := OFF ) ?? {use this line to suppress commdeck list}
00017 M00S00016.tdutab +++|{ ?? PUSH ( LIST := ON ) ?? {use this line to list common decks }
00018 M00S00017.tdutab +++|?? SKIP := 4 ??
00019 M00S00018.tdutab +++|
00020 M00S00019.tdutab +++|?? NEWTITLE := 'ZTDTTAB' ??
00021 M00S00020.tdutab +++|{ **************************** }
00022 M00S00021.tdutab +++|{ common deck ZTDTTAB follows: }
00023 M00S00022.tdutab +++|*CALL ZTDTTAB
00024 M00S00023.tdutab +++|
00025 M00S00024.tdutab +++|?? OLDTITLE ??
00026 M00S00025.tdutab +++|
00027 M00S00026.tdutab +++|{ ************************** }
00028 M00S00027.tdutab +++|{ tdu error handler follows: }
00029 M00S00028.tdutab +++|*CALL ZTDPERR
00030 M00S00029.tdutab +++|*CALL ZTDCCON
00031 M00S00030.tdutab +++|
00032 M00S00031.tdutab +++|{ ************************* }
00033 M00S00032.tdutab +++|{ tdu verb-table constants: }
00034 M00S00033.tdutab +++|*CALL ZTDCVRB
00035 M00S00034.tdutab +++|
00036 M00S00035.tdutab +++|?? EJECT ??
00037 M00S00036.tdutab +++|?? POP ??
00038 M00S00037.tdutab +++|
00039 M00S00038.tdutab +++| VAR
00040 M00S00039.tdutab +++| parm_record: parameter_record, { all parameters stored here }
00041 M00S00040.tdutab +++| input_list: ^input_node := NIL, { head of input list }
00042 M00S00041.tdutab +++| input_offset: INTEGER,
00043 M00S00042.tdutab +++| output_table: ARRAY [ 0 .. output_last_ordinal ] OF string_node,
00044 M00S00043.tdutab +++| key_name_table: ARRAY [ 0 .. key_name_last_ordinal ] OF string_node,
00045 M00S00044.tdutab +++| init_table: ARRAY [ 0 .. init_last_ordinal ] OF string_node,
00046 M00S00045.tdutab +++| appstr_table,
00047 M00S00046.tdutab +++| appstr_next_node_dumped,
00048 M00S00047.tdutab +++| appstr_latest_new_node: ^appstr_node,
00049 M00S00048.tdutab +++| output_total_characters,
00050 M00S00049.tdutab +++| key_name_total_characters,
00051 M00S00050.tdutab +++| init_total_characters,
00052 M00S00051.tdutab +++| appstr_total_sequences,
00053 M00S00052.tdutab +++| appstr_total_characters: INTEGER,
00054 M00S00053.tdutab +++| status: ost$status;
00055 M00S00054.tdutab +++|
00056 M00S00055.tdutab +++| ?? NEWTITLE := 'store_ord_char_node' ??
00057 M00S00056.tdutab +++| ?? EJECT ??
00058 M00S00057.tdutab +++|
00059 M00S00058.tdutab +++| PROCEDURE store_ord_char_node (ordinal: ordinal_type;
00060 M00S00059.tdutab +++| sequence_length: INTEGER;
00061 M00S00060.tdutab +++| char_sequence: STRING(*);
00062 M00S00061.tdutab +++| VAR table: ARRAY [ * ] OF string_node;
00063 M00S00062.tdutab +++| VAR total_characters: INTEGER;
00064 M00S00063.tdutab +++| VAR error_return: error_type);
00065 M00S00064.tdutab +++|
00066 M00S00065.tdutab +++| error_return := no_error;
00067 M00S00066.tdutab +++| IF table[ordinal].length > 0 THEN
00068 M00S00067.tdutab +++| error_return := duplicate_error
00069 M00S00068.tdutab +++| ELSEIF sequence_length > 0 THEN
00070 M00S00069.tdutab +++| ALLOCATE table[ordinal].chars : [ sequence_length ];
00071 M00S00070.tdutab +++| IF table[ordinal].chars = NIL THEN
00072 M00S00071.tdutab +++| error_return := no_room_error;
00073 M00S00072.tdutab +++| ELSE
00074 M00S00073.tdutab +++| table[ordinal].length := sequence_length;
00075 M00S00074.tdutab +++| table[ordinal].chars^ := char_sequence(1,sequence_length);
00076 M00S00075.tdutab +++| total_characters := total_characters + sequence_length
00077 M00S00076.tdutab +++| IFEND
00078 M00S00077.tdutab +++| IFEND
00079 M00S00078.tdutab +++| PROCEND store_ord_char_node;
00080 M00S00079.tdutab +++| ?? OLDTITLE ??
| Line S00001 Modification History | |
|---|---|
M01 (Added by) | tdutab1 |
Seq # *Modification Id* Act
----------------------------+
00081 M01S00001.tdutab1 +++|
00082 M01S00002.tdutab1 +++| ?? NEWTITLE := 'concatenate_sequences' ??
00083 M01S00003.tdutab1 +++| ?? EJECT ??
00084 M01S00004.tdutab1 +++|
00085 M01S00005.tdutab1 +++| PROCEDURE concatenate_sequences (new_seq: STRING(*);
00086 M01S00006.tdutab1 +++| new_seq_length: INTEGER;
00087 M01S00007.tdutab1 +++| VAR table_node: string_node;
00088 M01S00008.tdutab1 +++| VAR total_characters: INTEGER;
00089 M01S00009.tdutab1 +++| VAR error_return: error_type);
00090 M01S00010.tdutab1 +++| VAR
00091 M01S00011.tdutab1 +++| allocation_len,
00092 M01S00012.tdutab1 +++| stringrep_len: INTEGER,
00093 M01S00013.tdutab1 +++| old_node: string_node;
00094 M01S00014.tdutab1 +++|
00095 M01S00015.tdutab1 +++| error_return := no_error;
00096 M01S00016.tdutab1 +++| old_node := table_node;
00097 M01S00017.tdutab1 +++| IF old_node.length = 0 THEN
00098 M01S00018.tdutab1 +++| allocation_len := new_seq_length
00099 M01S00019.tdutab1 +++| ELSE
00100 M01S00020.tdutab1 +++| allocation_len := old_node.length + new_seq_length
00101 M01S00021.tdutab1 +++| IFEND;
00102 M01S00022.tdutab1 +++| table_node.length := allocation_len;
00103 M01S00023.tdutab1 +++| IF allocation_len > 0 THEN { can't allocate 0 }
00104 M01S00024.tdutab1 +++| ALLOCATE table_node.chars : [ allocation_len ];
00105 M01S00025.tdutab1 +++| IF table_node.chars = NIL THEN
00106 M01S00026.tdutab1 +++| error_return := no_room_error;
00107 M01S00027.tdutab1 +++| ELSE
00108 M01S00028.tdutab1 +++| IF old_node.length = 0 THEN
00109 M01S00029.tdutab1 +++| table_node.chars^ := new_seq(1,new_seq_length)
00110 M01S00030.tdutab1 +++| ELSE
00111 M01S00031.tdutab1 +++| STRINGREP(table_node.chars^, stringrep_len,
00112 M01S00032.tdutab1 +++| old_node.chars^(1,old_node.length),
00113 M01S00033.tdutab1 +++| new_seq(1,new_seq_length));
00114 M01S00034.tdutab1 +++| FREE old_node.chars
00115 M01S00035.tdutab1 +++| IFEND;
00116 M01S00036.tdutab1 +++| total_characters := total_characters + new_seq_length
00117 M01S00037.tdutab1 +++| IFEND
00118 M01S00038.tdutab1 +++| IFEND
00119 M01S00039.tdutab1 +++| PROCEND concatenate_sequences;
00120 M01S00040.tdutab1 +++| ?? OLDTITLE ??
00121 M00S00080.tdutab +++|
00122 M00S00081.tdutab +++| ?? NEWTITLE := 'initialize_tables' ??
00123 M00S00082.tdutab +++| ?? EJECT ??
00124 M00S00083.tdutab +++|
00125 M00S00084.tdutab +++| PROCEDURE [XDCL] initialize_tables;
00126 M00S00085.tdutab +++| VAR
00127 M00S00086.tdutab +++| table_ndx: INTEGER;
00128 M00S00087.tdutab +++|
00129 M00S00088.tdutab +++| ALLOCATE input_list : [ fail ]; { ignore no-room error, caught later }
00130 M00S00089.tdutab +++| IF input_list <> NIL THEN
00131 M00S00090.tdutab +++| input_list^.next_node := NIL;
00132 M00S00091.tdutab +++| input_list^.offset := 0;
00133 M00S00092.tdutab +++| input_list^.node_visited := FALSE
00134 M00S00093.tdutab +++| IFEND;
00135 M00S00094.tdutab +++| FOR table_ndx := 1 TO output_last_ordinal DO
00136 M00S00095.tdutab +++| output_table[table_ndx].length := 0;
00137 M00S00096.tdutab +++| output_table[table_ndx].chars := NIL
00138 M00S00097.tdutab +++| FOREND;
00139 M00S00098.tdutab +++| output_total_characters := 0;
00140 M00S00099.tdutab +++| FOR table_ndx := 1 TO key_name_last_ordinal DO
00141 M00S00100.tdutab +++| key_name_table[table_ndx].length := 0;
00142 M00S00101.tdutab +++| key_name_table[table_ndx].chars := NIL
00143 M00S00102.tdutab +++| FOREND;
00144 M00S00103.tdutab +++| key_name_total_characters := 0;
00145 M00S00104.tdutab +++| FOR table_ndx := 1 TO init_last_ordinal DO
00146 M00S00105.tdutab +++| init_table[table_ndx].length := 0;
00147 M00S00106.tdutab +++| init_table[table_ndx].chars := NIL
00148 M00S00107.tdutab +++| FOREND;
00149 M00S00108.tdutab +++| init_total_characters := 0;
00150 M00S00109.tdutab +++| appstr_table := NIL;
00151 M00S00110.tdutab +++| appstr_latest_new_node := NIL;
00152 M00S00111.tdutab +++| appstr_next_node_dumped := NIL;
00153 M00S00112.tdutab +++| appstr_total_sequences := 0;
00154 M00S00113.tdutab +++| appstr_total_characters := 0
00155 M00S00114.tdutab +++| PROCEND initialize_tables;
00156 M00S00115.tdutab +++| ?? OLDTITLE ??
00157 M00S00116.tdutab +++|
00158 M00S00117.tdutab +++| ?? NEWTITLE := 'store_parameters' ??
00159 M00S00118.tdutab +++| ?? EJECT ??
00160 M00S00119.tdutab +++|
00161 M00S00120.tdutab +++| PROCEDURE [XDCL] store_parameters (parm: parameter_record);
00162 M00S00121.tdutab +++| parm_record := parm; { save it in my local space }
00163 M00S00122.tdutab +++| PROCEND store_parameters;
00164 M00S00123.tdutab +++| ?? OLDTITLE ??
00165 M00S00124.tdutab +++|
00166 M00S00125.tdutab +++| ?? NEWTITLE := 'dump_parameters' ??
00167 M00S00126.tdutab +++| ?? SKIP := 4 ??
00168 M00S00127.tdutab +++|
00169 M00S00128.tdutab +++| PROCEDURE [XDCL] dump_parameters (VAR parm: parameter_record);
00170 M00S00129.tdutab +++| parm := parm_record; { give caller my copy }
00171 M00S00130.tdutab +++| PROCEND dump_parameters;
00172 M00S00131.tdutab +++| ?? OLDTITLE ??
00173 M00S00132.tdutab +++|
00174 M00S00133.tdutab +++| ?? NEWTITLE := 'store_output_node' ??
00175 M00S00134.tdutab +++| ?? EJECT ??
00176 M00S00135.tdutab +++|
00177 M00S00136.tdutab +++| PROCEDURE [XDCL] store_output_node (ordinal: ordinal_type;
00178 M00S00137.tdutab +++| sequence_length: INTEGER;
00179 M00S00138.tdutab +++| char_sequence: STRING(*);
00180 M00S00139.tdutab +++| VAR error_return: error_type);
00181 M00S00140.tdutab +++|
00182 M00S00141.tdutab +++| IF ( ordinal < 0 ) OR
00183 M00S00142.tdutab +++| ( ordinal > output_last_ordinal ) THEN
00184 M00S00143.tdutab +++| error_return := no_room_error
00185 M00S00144.tdutab +++| ELSE
| Line S00145 Modification History | |
|---|---|
M01 (Removed by) | tdutab1 |
Seq # *Modification Id* Act ----------------------------+ 00186 M01S00145.tdutab1 ---| store_ord_char_node(ordinal, sequence_length, char_sequence, 00187 M01S00146.tdutab1 ---| output_table, output_total_characters, error_return)
| Line S00041 Modification History | |
|---|---|
M01 (Added by) | tdutab1 |
Seq # *Modification Id* Act ----------------------------+ 00188 M01S00041.tdutab1 +++| concatenate_sequences(char_sequence, sequence_length, 00189 M01S00042.tdutab1 +++| output_table[ordinal], output_total_characters, 00190 M01S00043.tdutab1 +++| error_return) 00191 M00S00147.tdutab +++| IFEND 00192 M00S00148.tdutab +++| PROCEND store_output_node; 00193 M00S00149.tdutab +++| ?? OLDTITLE ?? 00194 M00S00150.tdutab +++| 00195 M00S00151.tdutab +++| ?? NEWTITLE := 'dump_output_node' ?? 00196 M00S00152.tdutab +++| ?? SKIP := 4 ?? 00197 M00S00153.tdutab +++| 00198 M00S00154.tdutab +++| PROCEDURE [XDCL] dump_output_node (ordinal: ordinal_type; 00199 M00S00155.tdutab +++| VAR length: INTEGER; 00200 M00S00156.tdutab +++| VAR chars: ^STRING(*); 00201 M00S00157.tdutab +++| VAR total_ordinals: INTEGER; 00202 M00S00158.tdutab +++| VAR total_characters: INTEGER; 00203 M00S00159.tdutab +++| VAR node_returned: BOOLEAN); 00204 M00S00160.tdutab +++| 00205 M00S00161.tdutab +++| node_returned := FALSE; 00206 M00S00162.tdutab +++| IF ( ordinal >= 0 ) AND 00207 M00S00163.tdutab +++| ( ordinal <= output_last_ordinal ) THEN 00208 M00S00164.tdutab +++| node_returned := TRUE; 00209 M00S00165.tdutab +++| total_ordinals := output_last_ordinal; 00210 M00S00166.tdutab +++| total_characters := output_total_characters; 00211 M00S00167.tdutab +++| length := output_table[ordinal].length; 00212 M00S00168.tdutab +++| chars := output_table[ordinal].chars 00213 M00S00169.tdutab +++| IFEND 00214 M00S00170.tdutab +++| PROCEND dump_output_node; 00215 M00S00171.tdutab +++| ?? OLDTITLE ?? 00216 M00S00172.tdutab +++| 00217 M00S00173.tdutab +++| ?? NEWTITLE := 'store_key_name_node' ?? 00218 M00S00174.tdutab +++| ?? EJECT ?? 00219 M00S00175.tdutab +++| 00220 M00S00176.tdutab +++| PROCEDURE [XDCL] store_key_name_node (ordinal: ordinal_type; 00221 M00S00177.tdutab +++| sequence_length: INTEGER; 00222 M00S00178.tdutab +++| char_sequence: STRING(*); 00223 M00S00179.tdutab +++| VAR error_return: error_type); 00224 M00S00180.tdutab +++| 00225 M00S00181.tdutab +++| IF ( ordinal < 0 ) OR 00226 M00S00182.tdutab +++| ( ordinal > key_name_last_ordinal ) THEN 00227 M00S00183.tdutab +++| error_return := no_room_error 00228 M00S00184.tdutab +++| ELSE 00229 M00S00185.tdutab +++| store_ord_char_node(ordinal, sequence_length, char_sequence, 00230 M00S00186.tdutab +++| key_name_table, key_name_total_characters, error_return) 00231 M00S00187.tdutab +++| IFEND 00232 M00S00188.tdutab +++| PROCEND store_key_name_node; 00233 M00S00189.tdutab +++| ?? OLDTITLE ?? 00234 M00S00190.tdutab +++| 00235 M00S00191.tdutab +++| ?? NEWTITLE := 'dump_key_name_node' ?? 00236 M00S00192.tdutab +++| ?? SKIP := 4 ?? 00237 M00S00193.tdutab +++| 00238 M00S00194.tdutab +++| PROCEDURE [XDCL] dump_key_name_node(ordinal: ordinal_type; 00239 M00S00195.tdutab +++| VAR length: INTEGER; 00240 M00S00196.tdutab +++| VAR chars: ^STRING(*); 00241 M00S00197.tdutab +++| VAR total_ordinals: INTEGER; 00242 M00S00198.tdutab +++| VAR total_characters: INTEGER; 00243 M00S00199.tdutab +++| VAR node_returned: BOOLEAN); 00244 M00S00200.tdutab +++| 00245 M00S00201.tdutab +++| node_returned := FALSE; 00246 M00S00202.tdutab +++| IF ( ordinal >= 0 ) AND 00247 M00S00203.tdutab +++| ( ordinal <= key_name_last_ordinal ) THEN 00248 M00S00204.tdutab +++| node_returned := TRUE; 00249 M00S00205.tdutab +++| total_ordinals := key_name_last_ordinal; 00250 M00S00206.tdutab +++| total_characters := key_name_total_characters; 00251 M00S00207.tdutab +++| length := key_name_table[ordinal].length; 00252 M00S00208.tdutab +++| chars := key_name_table[ordinal].chars 00253 M00S00209.tdutab +++| IFEND 00254 M00S00210.tdutab +++| PROCEND dump_key_name_node; 00255 M00S00211.tdutab +++| ?? OLDTITLE ?? 00256 M00S00212.tdutab +++| 00257 M00S00213.tdutab +++| ?? NEWTITLE := 'store_reset_sequence' ?? 00258 M00S00214.tdutab +++| ?? EJECT ?? 00259 M00S00215.tdutab +++| 00260 M00S00216.tdutab +++| PROCEDURE [XDCL] store_reset_sequence (ordinal: ordinal_type; 00261 M00S00217.tdutab +++| char_seq_length: INTEGER; 00262 M00S00218.tdutab +++| char_seq: STRING(*); 00263 M00S00219.tdutab +++| VAR error_return: error_type); 00264 M00S00220.tdutab +++|
| Line S00221 Modification History | |
|---|---|
M01 (Removed by) | tdutab1 |
Seq # *Modification Id* Act
----------------------------+
00265 M01S00221.tdutab1 ---| ?? NEWTITLE := 'concatenate_init_sequence' ??
00266 M01S00222.tdutab1 ---| ?? EJECT ??
00267 M01S00223.tdutab1 ---|
00268 M01S00224.tdutab1 ---| PROCEDURE concatenate_init_sequence (new_seq: STRING(*);
00269 M01S00225.tdutab1 ---| new_seq_length: INTEGER;
00270 M01S00226.tdutab1 ---| VAR init_node: string_node;
00271 M01S00227.tdutab1 ---| VAR error_return: error_type);
00272 M01S00228.tdutab1 ---| VAR
00273 M01S00229.tdutab1 ---| allocation_len,
00274 M01S00230.tdutab1 ---| stringrep_len: INTEGER,
00275 M01S00231.tdutab1 ---| old_node: string_node;
00276 M01S00232.tdutab1 ---|
00277 M01S00233.tdutab1 ---| error_return := no_error;
00278 M01S00234.tdutab1 ---| old_node := init_node;
00279 M01S00235.tdutab1 ---| IF old_node.length = 0 THEN
00280 M01S00236.tdutab1 ---| allocation_len := new_seq_length
00281 M01S00237.tdutab1 ---| ELSE
00282 M01S00238.tdutab1 ---| allocation_len := old_node.length + new_seq_length
00283 M01S00239.tdutab1 ---| IFEND;
00284 M01S00240.tdutab1 ---| init_node.length := allocation_len;
00285 M01S00241.tdutab1 ---| IF allocation_len > 0 THEN { can't allocate 0 }
00286 M01S00242.tdutab1 ---| ALLOCATE init_node.chars : [ allocation_len ];
00287 M01S00243.tdutab1 ---| IF init_node.chars = NIL THEN
00288 M01S00244.tdutab1 ---| error_return := no_room_error;
00289 M01S00245.tdutab1 ---| ELSE
00290 M01S00246.tdutab1 ---| IF old_node.length = 0 THEN
00291 M01S00247.tdutab1 ---| init_node.chars^ := new_seq(1,new_seq_length)
00292 M01S00248.tdutab1 ---| ELSE
00293 M01S00249.tdutab1 ---| STRINGREP(init_node.chars^, stringrep_len,
00294 M01S00250.tdutab1 ---| old_node.chars^(1,old_node.length),
00295 M01S00251.tdutab1 ---| new_seq(1,new_seq_length));
00296 M01S00252.tdutab1 ---| FREE old_node.chars
00297 M01S00253.tdutab1 ---| IFEND;
00298 M01S00254.tdutab1 ---| init_total_characters := init_total_characters + new_seq_length
00299 M01S00255.tdutab1 ---| IFEND
00300 M01S00256.tdutab1 ---| IFEND
00301 M01S00257.tdutab1 ---| PROCEND concatenate_init_sequence;
00302 M01S00258.tdutab1 ---| ?? OLDTITLE ??
00303 M01S00259.tdutab1 ---| ?? SKIP := 4 ??
00304 M01S00260.tdutab1 ---|
00305 M00S00261.tdutab +++| IF ( ordinal < 0 ) OR
00306 M00S00262.tdutab +++| ( ordinal > init_last_ordinal ) THEN
00307 M00S00263.tdutab +++| error_return := no_room_error
00308 M00S00264.tdutab +++| ELSE
| Line S00265 Modification History | |
|---|---|
M01 (Removed by) | tdutab1 |
Seq # *Modification Id* Act ----------------------------+ 00309 M01S00265.tdutab1 ---| concatenate_init_sequence(char_seq, char_seq_length, 00310 M01S00266.tdutab1 ---| init_table[ordinal], error_return);
| Line S00044 Modification History | |
|---|---|
M01 (Added by) | tdutab1 |
Seq # *Modification Id* Act
----------------------------+
00311 M01S00044.tdutab1 +++| concatenate_sequences(char_seq, char_seq_length,
00312 M01S00045.tdutab1 +++| init_table[ordinal], init_total_characters,
00313 M01S00046.tdutab1 +++| error_return);
00314 M00S00267.tdutab +++| IFEND
00315 M00S00268.tdutab +++| PROCEND store_reset_sequence;
00316 M00S00269.tdutab +++| ?? OLDTITLE ??
00317 M00S00270.tdutab +++|
00318 M00S00271.tdutab +++| ?? NEWTITLE := 'dump_reset_sequence' ??
00319 M00S00272.tdutab +++| ?? SKIP := 4 ??
00320 M00S00273.tdutab +++|
00321 M00S00274.tdutab +++| PROCEDURE [XDCL] dump_reset_sequence(ordinal: ordinal_type;
00322 M00S00275.tdutab +++| VAR length: INTEGER;
00323 M00S00276.tdutab +++| VAR chars: ^STRING(*);
00324 M00S00277.tdutab +++| VAR total_ordinals: INTEGER;
00325 M00S00278.tdutab +++| VAR total_characters: INTEGER;
00326 M00S00279.tdutab +++| VAR node_returned: BOOLEAN);
00327 M00S00280.tdutab +++|
00328 M00S00281.tdutab +++| node_returned := FALSE;
00329 M00S00282.tdutab +++| IF ( ordinal >= 0 ) AND
00330 M00S00283.tdutab +++| ( ordinal <= init_last_ordinal ) THEN
00331 M00S00284.tdutab +++| node_returned := TRUE;
00332 M00S00285.tdutab +++| total_ordinals := init_last_ordinal;
00333 M00S00286.tdutab +++| total_characters := init_total_characters;
00334 M00S00287.tdutab +++| length := init_table[ordinal].length;
00335 M00S00288.tdutab +++| chars := init_table[ordinal].chars
00336 M00S00289.tdutab +++| IFEND
00337 M00S00290.tdutab +++| PROCEND dump_reset_sequence;
00338 M00S00291.tdutab +++| ?? OLDTITLE ??
00339 M00S00292.tdutab +++|
00340 M00S00293.tdutab +++| ?? NEWTITLE := 'store_appstr_node' ??
00341 M00S00294.tdutab +++| ?? EJECT ??
00342 M00S00295.tdutab +++|
00343 M00S00296.tdutab +++| PROCEDURE [XDCL] store_appstr_node (name: STRING(*);
00344 M00S00297.tdutab +++| sequence_length: INTEGER;
00345 M00S00298.tdutab +++| char_sequence: STRING(*);
00346 M00S00299.tdutab +++| VAR error_return: error_type);
00347 M00S00300.tdutab +++| VAR
00348 M00S00301.tdutab +++| new_node: ^appstr_node;
00349 M00S00302.tdutab +++|
00350 M00S00303.tdutab +++| error_return := no_error;
00351 M00S00304.tdutab +++| ALLOCATE new_node;
00352 M00S00305.tdutab +++| IF new_node = NIL THEN
00353 M00S00306.tdutab +++| error_return := no_room_error
00354 M00S00307.tdutab +++| ELSE
00355 M00S00308.tdutab +++| IF appstr_table = NIL THEN
00356 M00S00309.tdutab +++| appstr_table := new_node
00357 M00S00310.tdutab +++| ELSE
00358 M00S00311.tdutab +++| appstr_latest_new_node^.next_node := new_node
00359 M00S00312.tdutab +++| IFEND;
00360 M00S00313.tdutab +++| appstr_latest_new_node := new_node;
00361 M00S00314.tdutab +++| new_node^.next_node := NIL;
00362 M00S00315.tdutab +++| new_node^.name := name;
00363 M00S00316.tdutab +++| new_node^.value.length := sequence_length;
00364 M00S00317.tdutab +++| appstr_total_sequences := appstr_total_sequences + 1;
00365 M00S00318.tdutab +++| IF sequence_length > 0 THEN
00366 M00S00319.tdutab +++| ALLOCATE new_node^.value.chars : [ sequence_length ];
00367 M00S00320.tdutab +++| IF new_node^.value.chars = NIL THEN
00368 M00S00321.tdutab +++| error_return := no_room_error
00369 M00S00322.tdutab +++| ELSE
00370 M00S00323.tdutab +++| new_node^.value.chars^ := char_sequence(1,sequence_length);
00371 M00S00324.tdutab +++| appstr_total_characters :=
00372 M00S00325.tdutab +++| appstr_total_characters + sequence_length
00373 M00S00326.tdutab +++| IFEND
00374 M00S00327.tdutab +++| IFEND
00375 M00S00328.tdutab +++| IFEND
00376 M00S00329.tdutab +++| PROCEND store_appstr_node;
00377 M00S00330.tdutab +++| ?? OLDTITLE ??
00378 M00S00331.tdutab +++|
00379 M00S00332.tdutab +++| ?? NEWTITLE := 'reset_appstr_table' ??
00380 M00S00333.tdutab +++| ?? SKIP := 4 ??
00381 M00S00334.tdutab +++|
00382 M00S00335.tdutab +++| PROCEDURE [XDCL] reset_appstr_table;
00383 M00S00336.tdutab +++| appstr_next_node_dumped := appstr_table
00384 M00S00337.tdutab +++| PROCEND reset_appstr_table;
00385 M00S00338.tdutab +++| ?? OLDTITLE ??
00386 M00S00339.tdutab +++|
00387 M00S00340.tdutab +++| ?? NEWTITLE := 'dump_appstr_node' ??
00388 M00S00341.tdutab +++| ?? EJECT ??
00389 M00S00342.tdutab +++|
00390 M00S00343.tdutab +++| PROCEDURE [XDCL] dump_appstr_node (VAR name: STRING(*);
00391 M00S00344.tdutab +++| VAR length: INTEGER;
00392 M00S00345.tdutab +++| VAR chars: ^STRING(*);
00393 M00S00346.tdutab +++| VAR total_sequences: INTEGER;
00394 M00S00347.tdutab +++| VAR total_characters: INTEGER;
00395 M00S00348.tdutab +++| VAR node_returned: BOOLEAN);
00396 M00S00349.tdutab +++|
00397 M00S00350.tdutab +++| IF ( appstr_table = NIL ) OR
00398 M00S00351.tdutab +++| ( appstr_next_node_dumped = NIL ) THEN
00399 M00S00352.tdutab +++| node_returned := FALSE
00400 M00S00353.tdutab +++| ELSE
00401 M00S00354.tdutab +++| node_returned := TRUE;
00402 M00S00355.tdutab +++| name := appstr_next_node_dumped^.name;
00403 M00S00356.tdutab +++| length := appstr_next_node_dumped^.value.length;
00404 M00S00357.tdutab +++| chars := appstr_next_node_dumped^.value.chars;
00405 M00S00358.tdutab +++| appstr_next_node_dumped := appstr_next_node_dumped^.next_node;
00406 M00S00359.tdutab +++| total_sequences := appstr_total_sequences;
00407 M00S00360.tdutab +++| total_characters := appstr_total_characters
00408 M00S00361.tdutab +++| IFEND
00409 M00S00362.tdutab +++| PROCEND dump_appstr_node;
00410 M00S00363.tdutab +++| ?? OLDTITLE ??
00411 M00S00364.tdutab +++|
00412 M00S00365.tdutab +++| ?? NEWTITLE := 'store_input_node' ??
00413 M00S00366.tdutab +++| ?? EJECT ??
00414 M00S00367.tdutab +++|
00415 M00S00368.tdutab +++| PROCEDURE [XDCL] store_input_node (ordinal: ordinal_type;
00416 M00S00369.tdutab +++| sequence_length: INTEGER;
00417 M00S00370.tdutab +++| char_sequence: STRING(*);
00418 M00S00371.tdutab +++| VAR error_return: error_type);
00419 M00S00372.tdutab +++|
00420 M00S00373.tdutab +++| { Input character recognition sequences are stored in a tree of linked }
00421 M00S00374.tdutab +++| { lists. Each character of a particular sequence occupies a node in }
00422 M00S00375.tdutab +++| { a different level of the tree. Thus, when matching a sequence in }
00423 M00S00376.tdutab +++| { the tree, one would start at the first level (pointed to by }
00424 M00S00377.tdutab +++| { input_list), and search the linked list which constitutes that level }
00425 M00S00378.tdutab +++| { (using search_level). If the character is found, the process repeats}
00426 M00S00379.tdutab +++| { with the next character in the sequence, and the search is of the }
00427 M00S00380.tdutab +++| { level pointed to by the node which was found. }
00428 M00S00381.tdutab +++| { Each level consists of a linked list of 'list' nodes, where each node }
00429 M00S00382.tdutab +++| { corresponds to a single-element list in the final output format. }
00430 M00S00383.tdutab +++| { These list nodes are later combined where possible into ranges and }
00431 M00S00384.tdutab +++| { single-action ranges by the optimize_tables procedure. }
00432 M00S00385.tdutab +++| { The last node in each level's linked list is always a 'fail' node. }
00433 M00S00386.tdutab +++|
00434 M00S00387.tdutab +++| VAR
00435 M00S00388.tdutab +++| new_node,
00436 M00S00389.tdutab +++| pred_node, { predecessor to current node }
00437 M00S00390.tdutab +++| succ_node, { successor to current node }
00438 M00S00391.tdutab +++| prev_level, { previous level which points to current}
00439 M00S00392.tdutab +++| curr_level: ^input_node, { start of the level to search }
00440 M00S00393.tdutab +++| node_found: BOOLEAN,
00441 M00S00394.tdutab +++| char_ndx: INTEGER;
00442 M00S00395.tdutab +++|
00443 M00S00396.tdutab +++| ?? NEWTITLE := 'search_level' ??
00444 M00S00397.tdutab +++| ?? SKIP := 4 ??
00445 M00S00398.tdutab +++|
00446 M00S00399.tdutab +++| PROCEDURE search_level (ch: CHAR; curr_level: ^input_node;
00447 M00S00400.tdutab +++| VAR pred_node: ^input_node; VAR succ_node: ^input_node;
00448 M00S00401.tdutab +++| VAR node_found: BOOLEAN);
00449 M00S00402.tdutab +++| { This procedure searches a particular level of the input char tree, }
00450 M00S00403.tdutab +++| { looking for a node which contains the given character. If it }
00451 M00S00404.tdutab +++| { doesn't find one, it returns pointers set up to insert a new node }
00452 M00S00405.tdutab +++| { for that character in its proper order. }
00453 M00S00406.tdutab +++|
00454 M00S00407.tdutab +++| node_found := FALSE;
00455 M00S00408.tdutab +++| pred_node := NIL;
00456 M00S00409.tdutab +++| succ_node := curr_level;
00457 M00S00410.tdutab +++| WHILE ( succ_node^.opcode <> fail ) AND
00458 M00S00411.tdutab +++| ( node_found = FALSE ) AND
00459 M00S00412.tdutab +++| ( succ_node^.list_pointer^[1].character <= ch ) DO
00460 M00S00413.tdutab +++| IF succ_node^.list_pointer^[1].character = ch THEN
00461 M00S00414.tdutab +++| node_found := TRUE
00462 M00S00415.tdutab +++| ELSE
00463 M00S00416.tdutab +++| pred_node := succ_node;
00464 M00S00417.tdutab +++| succ_node := pred_node^.next_node
00465 M00S00418.tdutab +++| IFEND
00466 M00S00419.tdutab +++| WHILEND
00467 M00S00420.tdutab +++| PROCEND search_level;
00468 M00S00421.tdutab +++| ?? OLDTITLE ??
00469 M00S00422.tdutab +++| ?? EJECT ??
00470 M00S00423.tdutab +++|
00471 M00S00424.tdutab +++| error_return := no_error;
00472 M00S00425.tdutab +++| curr_level := input_list;
00473 M00S00426.tdutab +++| FOR char_ndx := 1 TO sequence_length DO
00474 M00S00427.tdutab +++| search_level(char_sequence(char_ndx), curr_level,
00475 M00S00428.tdutab +++| pred_node, succ_node, node_found);
00476 M00S00429.tdutab +++| IF node_found THEN
00477 M00S00430.tdutab +++| IF succ_node^.list_pointer^[1].action.ordinal > no_ordinal THEN
00478 M00S00431.tdutab +++| IF char_ndx <> sequence_length THEN
00479 M00S00432.tdutab +++| error_return := superset_error;
00480 M00S00433.tdutab +++| RETURN
00481 M00S00434.tdutab +++| IFEND;
00482 M00S00435.tdutab +++| error_return := duplicate_input_error;
00483 M00S00436.tdutab +++| RETURN
00484 M00S00437.tdutab +++| IFEND;
00485 M00S00438.tdutab +++| IF char_ndx = sequence_length THEN
00486 M00S00439.tdutab +++| error_return := subset_error;
00487 M00S00440.tdutab +++| RETURN
00488 M00S00441.tdutab +++| IFEND;
00489 M00S00442.tdutab +++| prev_level := succ_node;
00490 M00S00443.tdutab +++| curr_level := { point to next level in sequence }
00491 M00S00444.tdutab +++| succ_node^.list_pointer^[1].action.next_level
00492 M00S00445.tdutab +++| ELSE { no match found, build a new node }
00493 M00S00446.tdutab +++| ALLOCATE new_node : [ list ]; { create a list node }
00494 M00S00447.tdutab +++| IF pred_node = NIL THEN { never got past first node }
00495 M00S00448.tdutab +++| IF char_ndx = 1 THEN { first level only }
00496 M00S00449.tdutab +++| new_node^.next_node := input_list;
00497 M00S00450.tdutab +++| input_list := new_node
00498 M00S00451.tdutab +++| ELSE { beyond first level }
00499 M00S00452.tdutab +++| new_node^.next_node :=
00500 M00S00453.tdutab +++| prev_level^.list_pointer^[1].action.next_level;
00501 M00S00454.tdutab +++| prev_level^.list_pointer^[1].action.next_level := new_node
00502 M00S00455.tdutab +++| IFEND
00503 M00S00456.tdutab +++| ELSE { new node is in midst of existing level}
00504 M00S00457.tdutab +++| new_node^.next_node := pred_node^.next_node;
00505 M00S00458.tdutab +++| pred_node^.next_node := new_node;
00506 M00S00459.tdutab +++| IFEND;
00507 M00S00460.tdutab +++| new_node^.offset := 0;
00508 M00S00461.tdutab +++| new_node^.node_visited := FALSE;
00509 M00S00462.tdutab +++| new_node^.list_character_count := 1; { one element in list }
00510 M00S00463.tdutab +++| ALLOCATE new_node^.list_pointer : [ 1..1 ]; { the list itself }
00511 M00S00464.tdutab +++| new_node^.list_pointer^[1].character := char_sequence(char_ndx);
00512 M00S00465.tdutab +++| new_node^.list_pointer^[1].action.next_offset := 0;
00513 M00S00466.tdutab +++| IF char_ndx = sequence_length THEN
00514 M00S00467.tdutab +++| new_node^.list_pointer^[1].action.ordinal := ordinal;
00515 M00S00468.tdutab +++| new_node^.list_pointer^[1].action.next_level := NIL
00516 M00S00469.tdutab +++| ELSE
00517 M00S00470.tdutab +++| new_node^.list_pointer^[1].action.ordinal := no_ordinal;
00518 M00S00471.tdutab +++| ALLOCATE
00519 M00S00472.tdutab +++| new_node^.list_pointer^[1].action.next_level : [ fail ];
00520 M00S00473.tdutab +++| new_node^.list_pointer^[1].action.next_level^.next_node := NIL;
00521 M00S00474.tdutab +++| new_node^.list_pointer^[1].action.next_level^.offset := 0;
00522 M00S00475.tdutab +++| new_node^.list_pointer^[1].action.next_level^.
00523 M00S00476.tdutab +++| node_visited := FALSE;
00524 M00S00477.tdutab +++| prev_level := new_node;
00525 M00S00478.tdutab +++| curr_level :=
00526 M00S00479.tdutab +++| new_node^.list_pointer^[1].action.next_level
00527 M00S00480.tdutab +++| IFEND
00528 M00S00481.tdutab +++| IFEND
00529 M00S00482.tdutab +++| FOREND
00530 M00S00483.tdutab +++| PROCEND store_input_node;
00531 M00S00484.tdutab +++| ?? OLDTITLE ??
00532 M00S00485.tdutab +++|
00533 M00S00486.tdutab +++| ?? NEWTITLE := 'dump_input_node' ??
00534 M00S00487.tdutab +++| ?? SKIP := 4 ??
00535 M00S00488.tdutab +++|
00536 M00S00489.tdutab +++| PROCEDURE [XDCL] dump_input_node (
00537 M00S00490.tdutab +++| before_procedure: ^PROCEDURE(in_nd: ^input_node) );
00538 M00S00491.tdutab +++|
00539 M00S00492.tdutab +++| traverse_input_tree(input_list, before_procedure, NIL)
00540 M00S00493.tdutab +++| PROCEND dump_input_node;
00541 M00S00494.tdutab +++| ?? OLDTITLE ??
00542 M00S00495.tdutab +++|
00543 M00S00496.tdutab +++| ?? NEWTITLE := 'reset_input_table' ??
00544 M00S00497.tdutab +++| ?? SKIP := 4 ??
00545 M00S00498.tdutab +++|
00546 M00S00499.tdutab +++| PROCEDURE [XDCL] reset_input_table (VAR character_count: INTEGER);
00547 M00S00500.tdutab +++|
00548 M00S00501.tdutab +++| PROCEDURE reset_node_flags(in_node: ^input_node);
00549 M00S00502.tdutab +++| in_node^.node_visited := FALSE;
00550 M00S00503.tdutab +++| calculate_input_offsets(in_node)
00551 M00S00504.tdutab +++| PROCEND reset_node_flags;
00552 M00S00505.tdutab +++|
00553 M00S00506.tdutab +++| input_offset := 0;
00554 M00S00507.tdutab +++| dump_input_node(^reset_node_flags);
00555 M00S00508.tdutab +++| character_count := input_offset
00556 M00S00509.tdutab +++| PROCEND reset_input_table;
00557 M00S00510.tdutab +++| ?? OLDTITLE ??
00558 M00S00511.tdutab +++|
00559 M00S00512.tdutab +++| ?? NEWTITLE := 'traverse_input_tree' ??
00560 M00S00513.tdutab +++| ?? EJECT ??
00561 M00S00514.tdutab +++|
00562 M00S00515.tdutab +++| PROCEDURE traverse_input_tree ( { recursively process tree, calling proc}
00563 M00S00516.tdutab +++| in_node: ^input_node;
00564 M00S00517.tdutab +++| before_procedure: ^PROCEDURE(in_nd: ^input_node);
00565 M00S00518.tdutab +++| after_procedure: ^PROCEDURE(in_nd: ^input_node) );
00566 M00S00519.tdutab +++|
00567 M00S00520.tdutab +++| VAR
00568 M00S00521.tdutab +++| action_ndx: INTEGER;
00569 M00S00522.tdutab +++|
00570 M00S00523.tdutab +++| IF in_node <> NIL THEN
00571 M00S00524.tdutab +++| IF before_procedure <> NIL THEN
00572 M00S00525.tdutab +++| before_procedure^(in_node) { do whatever my caller requests }
00573 M00S00526.tdutab +++| IFEND;
00574 M00S00527.tdutab +++| CASE in_node^.opcode OF
00575 M00S00528.tdutab +++| = fail =
00576 M00S00529.tdutab +++| ;
00577 M00S00530.tdutab +++| = list =
00578 M00S00531.tdutab +++| traverse_input_tree(in_node^.next_node, { same level first }
00579 M00S00532.tdutab +++| before_procedure, after_procedure);
00580 M00S00533.tdutab +++| FOR action_ndx := 1 TO in_node^.list_character_count DO
00581 M00S00534.tdutab +++| traverse_input_tree( { now the next level }
00582 M00S00535.tdutab +++| in_node^.list_pointer^[action_ndx].
00583 M00S00536.tdutab +++| action.next_level,
00584 M00S00537.tdutab +++| before_procedure, after_procedure)
00585 M00S00538.tdutab +++| FOREND;
00586 M00S00539.tdutab +++| = range =
00587 M00S00540.tdutab +++| traverse_input_tree(in_node^.next_node,
00588 M00S00541.tdutab +++| before_procedure, after_procedure);
00589 M00S00542.tdutab +++| FOR action_ndx := ORD(in_node^.range_lower_bound) TO
00590 M00S00543.tdutab +++| ORD(in_node^.range_upper_bound) DO
00591 M00S00544.tdutab +++| traverse_input_tree(
00592 M00S00545.tdutab +++| in_node^.range_pointer^[action_ndx].next_level,
00593 M00S00546.tdutab +++| before_procedure, after_procedure)
00594 M00S00547.tdutab +++| FOREND;
00595 M00S00548.tdutab +++| = single_action_range =
00596 M00S00549.tdutab +++| traverse_input_tree(in_node^.next_node,
00597 M00S00550.tdutab +++| before_procedure, after_procedure);
00598 M00S00551.tdutab +++| traverse_input_tree(
00599 M00S00552.tdutab +++| in_node^.sar_action.next_level,
00600 M00S00553.tdutab +++| before_procedure, after_procedure);
00601 M00S00554.tdutab +++| CASEND;
00602 M00S00555.tdutab +++| IF after_procedure <> NIL THEN
00603 M00S00556.tdutab +++| after_procedure^(in_node) { do whatever desired after traversal }
00604 M00S00557.tdutab +++| IFEND
00605 M00S00558.tdutab +++| IFEND
00606 M00S00559.tdutab +++| PROCEND traverse_input_tree;
00607 M00S00560.tdutab +++| ?? OLDTITLE ??
00608 M00S00561.tdutab +++|
00609 M00S00562.tdutab +++| ?? NEWTITLE := 'calculate_input_offsets' ??
00610 M00S00563.tdutab +++| ?? EJECT ??
00611 M00S00564.tdutab +++|
00612 M00S00565.tdutab +++| PROCEDURE calculate_input_offsets (in_node: ^input_node);
00613 M00S00566.tdutab +++|
00614 M00S00567.tdutab +++| in_node^.offset := input_offset;
00615 M00S00568.tdutab +++| CASE in_node^.opcode OF
00616 M00S00569.tdutab +++| = fail =
00617 M00S00570.tdutab +++| input_offset := input_offset + 1;
00618 M00S00571.tdutab +++| = list =
00619 M00S00572.tdutab +++| input_offset := input_offset + 2 +
00620 M00S00573.tdutab +++| ( in_node^.list_character_count * 3 );
00621 M00S00574.tdutab +++| = range =
00622 M00S00575.tdutab +++| input_offset := input_offset + 3 + (
00623 M00S00576.tdutab +++| ( ( ORD(in_node^.range_upper_bound) -
00624 M00S00577.tdutab +++| ORD(in_node^.range_lower_bound) ) + 1 ) * 2 );
00625 M00S00578.tdutab +++| = single_action_range =
00626 M00S00579.tdutab +++| input_offset := input_offset + 5;
00627 M00S00580.tdutab +++| CASEND
00628 M00S00581.tdutab +++| PROCEND calculate_input_offsets;
00629 M00S00582.tdutab +++| ?? OLDTITLE ??
00630 M00S00583.tdutab +++|
00631 M00S00584.tdutab +++| ?? NEWTITLE := 'optimize_tables' ??
00632 M00S00585.tdutab +++| ?? EJECT ??
00633 M00S00586.tdutab +++|
00634 M00S00587.tdutab +++| PROCEDURE [XDCL] optimize_tables;
00635 M00S00588.tdutab +++| VAR
00636 M00S00589.tdutab +++| next_ordinal: ordinal_type,
00637 M00S00590.tdutab +++| node_returned: BOOLEAN,
00638 M00S00591.tdutab +++| error_return: error_type;
00639 M00S00592.tdutab +++|
00640 M00S00593.tdutab +++| ?? NEWTITLE := 'create_ranges' ??
00641 M00S00594.tdutab +++| ?? SKIP := 4 ??
00642 M00S00595.tdutab +++|
00643 M00S00596.tdutab +++| PROCEDURE create_ranges (in_node: ^input_node);
00644 M00S00597.tdutab +++| VAR
00645 M00S00598.tdutab +++| action_ndx: INTEGER;
00646 M00S00599.tdutab +++|
00647 M00S00600.tdutab +++| IF in_node <> NIL THEN
00648 M00S00601.tdutab +++| CASE in_node^.opcode OF
00649 M00S00602.tdutab +++| = fail =
00650 M00S00603.tdutab +++| ;
00651 M00S00604.tdutab +++| = list =
00652 M00S00605.tdutab +++| FOR action_ndx := 1 TO in_node^.list_character_count DO
00653 M00S00606.tdutab +++| IF in_node^.list_pointer^[action_ndx].action.next_level <>
00654 M00S00607.tdutab +++| NIL THEN
00655 M00S00608.tdutab +++| create_range_level(
00656 M00S00609.tdutab +++| in_node^.list_pointer^[action_ndx].action.next_level)
00657 M00S00610.tdutab +++| IFEND
00658 M00S00611.tdutab +++| FOREND;
00659 M00S00612.tdutab +++| = range =
00660 M00S00613.tdutab +++| FOR action_ndx := ORD(in_node^.range_lower_bound) TO
00661 M00S00614.tdutab +++| ORD(in_node^.range_upper_bound) DO
00662 M00S00615.tdutab +++| IF in_node^.range_pointer^[action_ndx].next_level <> NIL
00663 M00S00616.tdutab +++| THEN
00664 M00S00617.tdutab +++| create_range_level(
00665 M00S00618.tdutab +++| in_node^.range_pointer^[action_ndx].next_level)
00666 M00S00619.tdutab +++| IFEND
00667 M00S00620.tdutab +++| FOREND;
00668 M00S00621.tdutab +++| = single_action_range =
00669 M00S00622.tdutab +++| IF in_node^.sar_action.next_level <> NIL THEN
00670 M00S00623.tdutab +++| create_range_level(in_node^.sar_action.next_level)
00671 M00S00624.tdutab +++| IFEND
00672 M00S00625.tdutab +++| CASEND
00673 M00S00626.tdutab +++| IFEND
00674 M00S00627.tdutab +++| PROCEND create_ranges;
00675 M00S00628.tdutab +++| ?? OLDTITLE ??
00676 M00S00629.tdutab +++|
00677 M00S00630.tdutab +++| ?? NEWTITLE := 'create_range_level' ??
00678 M00S00631.tdutab +++| ?? EJECT ??
00679 M00S00632.tdutab +++|
00680 M00S00633.tdutab +++| PROCEDURE create_range_level (VAR curr_level: ^input_node);
00681 M00S00634.tdutab +++| { This procedure scans across a given level of the input tree, }
00682 M00S00635.tdutab +++| { attempting to reduce consecutive lists of characters to ranges. }
00683 M00S00636.tdutab +++| { It ASSUMES it is being called as the FIRST phase of input table }
00684 M00S00637.tdutab +++| { optimization, so that each level consists of single-item lists }
00685 M00S00638.tdutab +++| { ONLY, and that the lists are in ASCENDING ORDER. }
00686 M00S00639.tdutab +++|
00687 M00S00640.tdutab +++| VAR
00688 M00S00641.tdutab +++| new_node,
00689 M00S00642.tdutab +++| pred_node,
00690 M00S00643.tdutab +++| succ_node,
00691 M00S00644.tdutab +++| low_node,
00692 M00S00645.tdutab +++| low_node_pred,
00693 M00S00646.tdutab +++| new_low_node: ^input_node,
00694 M00S00647.tdutab +++| low,
00695 M00S00648.tdutab +++| high: CHAR,
00696 M00S00649.tdutab +++| range_ndx: INTEGER;
00697 M00S00650.tdutab +++|
00698 M00S00651.tdutab +++| IF curr_level^.opcode = list THEN { just in case of empty table }
00699 M00S00652.tdutab +++| low := curr_level^.list_pointer^[1].character
00700 M00S00653.tdutab +++| IFEND;
00701 M00S00654.tdutab +++| high := low;
00702 M00S00655.tdutab +++| low_node := curr_level;
00703 M00S00656.tdutab +++| succ_node := curr_level;
00704 M00S00657.tdutab +++| pred_node := NIL;
00705 M00S00658.tdutab +++| WHILE ( succ_node <> NIL ) AND
00706 M00S00659.tdutab +++| ( error_return = no_error ) DO
00707 M00S00660.tdutab +++| IF ( succ_node^.opcode <> fail ) AND
00708 M00S00661.tdutab +++| ( succ_node^.list_pointer^[1].character = SUCC(high) ) THEN
00709 M00S00662.tdutab +++| high := succ_node^.list_pointer^[1].character { extend range }
00710 M00S00663.tdutab +++| ELSEIF low = high THEN { 'orphan' list--reset search ptrs }
00711 M00S00664.tdutab +++| IF succ_node^.opcode = list THEN
00712 M00S00665.tdutab +++| low := succ_node^.list_pointer^[1].character;
00713 M00S00666.tdutab +++| high := low;
00714 M00S00667.tdutab +++| low_node := succ_node;
00715 M00S00668.tdutab +++| low_node_pred := pred_node
00716 M00S00669.tdutab +++| IFEND
00717 M00S00670.tdutab +++| ELSE { at least 2 consecutive nodes found }
00718 M00S00671.tdutab +++| ALLOCATE new_node : [ range ];
00719 M00S00672.tdutab +++| IF new_node = NIL THEN
00720 M00S00673.tdutab +++| osp$set_status_abnormal(tdc_prod_code,
00721 M00S00674.tdutab +++| tde_optimize_table_full, '', status);
00722 M00S00675.tdutab +++| error_status(status);
00723 M00S00676.tdutab +++| error_return := no_room_error;
00724 M00S00677.tdutab +++| RETURN
00725 M00S00678.tdutab +++| IFEND;
00726 M00S00679.tdutab +++| new_node^.next_node := succ_node; { new range in same spot}
00727 M00S00680.tdutab +++| new_node^.offset := 0;
00728 M00S00681.tdutab +++| new_node^.node_visited := FALSE;
00729 M00S00682.tdutab +++| IF low_node = curr_level THEN { new node is first on level}
00730 M00S00683.tdutab +++| curr_level := new_node { return pointer to my caller }
00731 M00S00684.tdutab +++| ELSE
00732 M00S00685.tdutab +++| low_node_pred^.next_node := new_node
00733 M00S00686.tdutab +++| IFEND;
00734 M00S00687.tdutab +++| new_node^.range_lower_bound := low;
00735 M00S00688.tdutab +++| new_node^.range_upper_bound := high;
00736 M00S00689.tdutab +++| ALLOCATE new_node^.range_pointer : [ ORD(low)..ORD(high) ];
00737 M00S00690.tdutab +++| IF new_node^.range_pointer = NIL THEN
00738 M00S00691.tdutab +++| osp$set_status_abnormal(tdc_prod_code,
00739 M00S00692.tdutab +++| tde_optimize_table_full, '', status);
00740 M00S00693.tdutab +++| error_status(status);
00741 M00S00694.tdutab +++| error_return := no_room_error;
00742 M00S00695.tdutab +++| RETURN
00743 M00S00696.tdutab +++| IFEND;
00744 M00S00697.tdutab +++| FOR range_ndx := ORD(low) TO ORD(high) DO
00745 M00S00698.tdutab +++| new_node^.range_pointer^[range_ndx] :=
00746 M00S00699.tdutab +++| low_node^.list_pointer^[1].action;
00747 M00S00700.tdutab +++| new_low_node := low_node^.next_node;
00748 M00S00701.tdutab +++| FREE low_node^.list_pointer;
00749 M00S00702.tdutab +++| FREE low_node;
00750 M00S00703.tdutab +++| low_node := new_low_node
00751 M00S00704.tdutab +++| FOREND;
00752 M00S00705.tdutab +++| IF succ_node^.opcode = list THEN
00753 M00S00706.tdutab +++| low := succ_node^.list_pointer^[1].character;
00754 M00S00707.tdutab +++| high := low;
00755 M00S00708.tdutab +++| low_node := succ_node;
00756 M00S00709.tdutab +++| low_node_pred := new_node
00757 M00S00710.tdutab +++| IFEND
00758 M00S00711.tdutab +++| IFEND;
00759 M00S00712.tdutab +++| pred_node := succ_node;
00760 M00S00713.tdutab +++| IF succ_node^.opcode = fail THEN
00761 M00S00714.tdutab +++| succ_node := NIL
00762 M00S00715.tdutab +++| ELSE
00763 M00S00716.tdutab +++| succ_node := pred_node^.next_node
00764 M00S00717.tdutab +++| IFEND
00765 M00S00718.tdutab +++| WHILEND
00766 M00S00719.tdutab +++| PROCEND create_range_level;
00767 M00S00720.tdutab +++| ?? OLDTITLE ??
00768 M00S00721.tdutab +++|
00769 M00S00722.tdutab +++| ?? NEWTITLE := 'insert_remaining_chars' ??
00770 M00S00723.tdutab +++| ?? EJECT ??
00771 M00S00724.tdutab +++|
00772 M00S00725.tdutab +++| PROCEDURE insert_remaining_chars;
00773 M00S00726.tdutab +++| { This procedure processes the first level of the input tree only, }
00774 M00S00727.tdutab +++| { adding all characters that are not yet represented there. This }
00775 M00S00728.tdutab +++| { is necessary because we can make no assumptions about which }
00776 M00S00729.tdutab +++| { characters the application program wants to see. We will pass }
00777 M00S00730.tdutab +++| { everything to the app, and let it decide what to do. }
00778 M00S00731.tdutab +++| { At the time this procedure is called, it ASSUMES that the first }
00779 M00S00732.tdutab +++| { level consists ONLY of ranges and lists, and that everything }
00780 M00S00733.tdutab +++| { is still in ASCENDING ORDER. }
00781 M00S00734.tdutab +++|
00782 M00S00735.tdutab +++| VAR
00783 M00S00736.tdutab +++| pred_node,
00784 M00S00737.tdutab +++| succ_node: ^input_node,
00785 M00S00738.tdutab +++| first_needed: 0 .. 129;
00786 M00S00739.tdutab +++|
00787 M00S00740.tdutab +++| ?? NEWTITLE := 'maybe_insert_chars' ??
00788 M00S00741.tdutab +++| ?? EJECT ??
00789 M00S00742.tdutab +++|
00790 M00S00743.tdutab +++| PROCEDURE maybe_insert_chars (next_used: 0 .. 128;
00791 M00S00744.tdutab +++| succ_node: ^input_node;
00792 M00S00745.tdutab +++| VAR pred_node: ^input_node;
00793 M00S00746.tdutab +++| VAR first_needed: 0 .. 129);
00794 M00S00747.tdutab +++|
00795 M00S00748.tdutab +++| VAR
00796 M00S00749.tdutab +++| new_node: ^input_node;
00797 M00S00750.tdutab +++|
00798 M00S00751.tdutab +++| IF next_used > first_needed THEN
00799 M00S00752.tdutab +++| ALLOCATE new_node : [ single_action_range ];
00800 M00S00753.tdutab +++| IF new_node = NIL THEN
00801 M00S00754.tdutab +++| osp$set_status_abnormal(tdc_prod_code,
00802 M00S00755.tdutab +++| tde_optimize_table_full, '', status);
00803 M00S00756.tdutab +++| error_status(status);
00804 M00S00757.tdutab +++| error_return := no_room_error;
00805 M00S00758.tdutab +++| ELSE
00806 M00S00759.tdutab +++| new_node^.next_node := succ_node;
00807 M00S00760.tdutab +++| new_node^.offset := 0;
00808 M00S00761.tdutab +++| new_node^.node_visited := FALSE;
00809 M00S00762.tdutab +++| IF pred_node = NIL THEN
00810 M00S00763.tdutab +++| input_list := new_node
00811 M00S00764.tdutab +++| ELSE
00812 M00S00765.tdutab +++| pred_node^.next_node := new_node
00813 M00S00766.tdutab +++| IFEND;
00814 M00S00767.tdutab +++| pred_node := new_node;
00815 M00S00768.tdutab +++| new_node^.sar_lower_bound := CHR(first_needed);
00816 M00S00769.tdutab +++| new_node^.sar_upper_bound := CHR(next_used - 1);
00817 M00S00770.tdutab +++| new_node^.sar_action.ordinal := overstrike_ordinal;
00818 M00S00771.tdutab +++| new_node^.sar_action.next_offset := 0;
00819 M00S00772.tdutab +++| new_node^.sar_action.next_level := NIL
00820 M00S00773.tdutab +++| IFEND
00821 M00S00774.tdutab +++| IFEND;
00822 M00S00775.tdutab +++| first_needed := next_used + 1
00823 M00S00776.tdutab +++| PROCEND maybe_insert_chars;
00824 M00S00777.tdutab +++| ?? OLDTITLE ??
00825 M00S00778.tdutab +++|
00826 M00S00779.tdutab +++| succ_node := input_list;
00827 M00S00780.tdutab +++| pred_node := NIL;
00828 M00S00781.tdutab +++| first_needed := 0;
00829 M00S00782.tdutab +++| WHILE first_needed < 128 DO
00830 M00S00783.tdutab +++| CASE succ_node^.opcode OF
00831 M00S00784.tdutab +++| = fail =
00832 M00S00785.tdutab +++| maybe_insert_chars(128, succ_node, pred_node, first_needed);
00833 M00S00786.tdutab +++| = list =
00834 M00S00787.tdutab +++| maybe_insert_chars(
00835 M00S00788.tdutab +++| ORD(succ_node^.list_pointer^[1].character),
00836 M00S00789.tdutab +++| succ_node, pred_node, first_needed);
00837 M00S00790.tdutab +++| first_needed := 1 + ORD(succ_node^.list_pointer^
00838 M00S00791.tdutab +++| [succ_node^.list_character_count].character);
00839 M00S00792.tdutab +++| = range =
00840 M00S00793.tdutab +++| maybe_insert_chars(ORD(succ_node^.range_lower_bound),
00841 M00S00794.tdutab +++| succ_node, pred_node, first_needed);
00842 M00S00795.tdutab +++| first_needed := 1 + ORD(succ_node^.range_upper_bound);
00843 M00S00796.tdutab +++| CASEND;
00844 M00S00797.tdutab +++| pred_node := succ_node;
00845 M00S00798.tdutab +++| succ_node := pred_node^.next_node
00846 M00S00799.tdutab +++| WHILEND
00847 M00S00800.tdutab +++| PROCEND insert_remaining_chars;
00848 M00S00801.tdutab +++| ?? OLDTITLE ??
00849 M00S00802.tdutab +++|
00850 M00S00803.tdutab +++| ?? NEWTITLE := 'combine_lists' ??
00851 M00S00804.tdutab +++| ?? EJECT ??
00852 M00S00805.tdutab +++|
00853 M00S00806.tdutab +++| PROCEDURE combine_lists (in_node: ^input_node);
00854 M00S00807.tdutab +++| { This procedure processes all levels of the input tree, combining }
00855 M00S00808.tdutab +++| { multiple list nodes at each level into a single list node. }
00856 M00S00809.tdutab +++| { It is called recursively by traverse_input_tree. }
00857 M00S00810.tdutab +++|
00858 M00S00811.tdutab +++| VAR
00859 M00S00812.tdutab +++| action_ndx: INTEGER;
00860 M00S00813.tdutab +++|
00861 M00S00814.tdutab +++| IF in_node <> NIL THEN
00862 M00S00815.tdutab +++| CASE in_node^.opcode OF
00863 M00S00816.tdutab +++| = fail =
00864 M00S00817.tdutab +++| ;
00865 M00S00818.tdutab +++| = list =
00866 M00S00819.tdutab +++| FOR action_ndx := 1 TO in_node^.list_character_count DO
00867 M00S00820.tdutab +++| IF in_node^.list_pointer^[action_ndx].action.next_level <>
00868 M00S00821.tdutab +++| NIL THEN
00869 M00S00822.tdutab +++| combine_list_level(
00870 M00S00823.tdutab +++| in_node^.list_pointer^[action_ndx].action.next_level)
00871 M00S00824.tdutab +++| IFEND
00872 M00S00825.tdutab +++| FOREND;
00873 M00S00826.tdutab +++| = range =
00874 M00S00827.tdutab +++| FOR action_ndx := ORD(in_node^.range_lower_bound) TO
00875 M00S00828.tdutab +++| ORD(in_node^.range_upper_bound) DO
00876 M00S00829.tdutab +++| IF in_node^.range_pointer^[action_ndx].next_level <> NIL
00877 M00S00830.tdutab +++| THEN
00878 M00S00831.tdutab +++| combine_list_level(
00879 M00S00832.tdutab +++| in_node^.range_pointer^[action_ndx].next_level)
00880 M00S00833.tdutab +++| IFEND
00881 M00S00834.tdutab +++| FOREND;
00882 M00S00835.tdutab +++| = single_action_range =
00883 M00S00836.tdutab +++| IF in_node^.sar_action.next_level <> NIL THEN
00884 M00S00837.tdutab +++| combine_list_level(in_node^.sar_action.next_level)
00885 M00S00838.tdutab +++| IFEND
00886 M00S00839.tdutab +++| CASEND
00887 M00S00840.tdutab +++| IFEND
00888 M00S00841.tdutab +++| PROCEND combine_lists;
00889 M00S00842.tdutab +++| ?? OLDTITLE ??
00890 M00S00843.tdutab +++|
00891 M00S00844.tdutab +++| ?? NEWTITLE := 'combine_list_level' ??
00892 M00S00845.tdutab +++| ?? EJECT ??
00893 M00S00846.tdutab +++|
00894 M00S00847.tdutab +++| PROCEDURE combine_list_level (VAR curr_level: ^input_node);
00895 M00S00848.tdutab +++| { This procedure scans across a given level of the input tree, }
00896 M00S00849.tdutab +++| { combining all separate lists found at that level into a single }
00897 M00S00850.tdutab +++| { list. It doesn't really care at what phase of the optimization }
00898 M00S00851.tdutab +++| { it is being called. }
00899 M00S00852.tdutab +++|
00900 M00S00853.tdutab +++| VAR
00901 M00S00854.tdutab +++| new_node,
00902 M00S00855.tdutab +++| pred_node,
00903 M00S00856.tdutab +++| succ_node: ^input_node,
00904 M00S00857.tdutab +++| list_count,
00905 M00S00858.tdutab +++| new_ndx,
00906 M00S00859.tdutab +++| old_ndx: INTEGER;
00907 M00S00860.tdutab +++|
00908 M00S00861.tdutab +++| succ_node := curr_level;
00909 M00S00862.tdutab +++| pred_node := NIL;
00910 M00S00863.tdutab +++| list_count := 0;
00911 M00S00864.tdutab +++| WHILE succ_node^.opcode <> fail DO
00912 M00S00865.tdutab +++| IF succ_node^.opcode = list THEN
00913 M00S00866.tdutab +++| list_count := list_count + succ_node^.list_character_count
00914 M00S00867.tdutab +++| IFEND;
00915 M00S00868.tdutab +++| pred_node := succ_node;
00916 M00S00869.tdutab +++| succ_node := succ_node^.next_node
00917 M00S00870.tdutab +++| WHILEND;
00918 M00S00871.tdutab +++| IF list_count > 0 THEN { at least one list on this level }
00919 M00S00872.tdutab +++| ALLOCATE new_node : [ list ];
00920 M00S00873.tdutab +++| IF new_node = NIL THEN
00921 M00S00874.tdutab +++| error_return := no_room_error;
00922 M00S00875.tdutab +++| osp$set_status_abnormal(tdc_prod_code, tde_optimize_table_full,
00923 M00S00876.tdutab +++| '', status);
00924 M00S00877.tdutab +++| error_status(status);
00925 M00S00878.tdutab +++| RETURN
00926 M00S00879.tdutab +++| IFEND;
00927 M00S00880.tdutab +++| new_node^.offset := 0;
00928 M00S00881.tdutab +++| new_node^.node_visited := FALSE;
00929 M00S00882.tdutab +++| new_node^.list_character_count := list_count;
00930 M00S00883.tdutab +++| ALLOCATE new_node^.list_pointer : [ 1 .. list_count ];
00931 M00S00884.tdutab +++| IF new_node^.list_pointer = NIL THEN
00932 M00S00885.tdutab +++| error_return := no_room_error;
00933 M00S00886.tdutab +++| osp$set_status_abnormal(tdc_prod_code,
00934 M00S00887.tdutab +++| tde_optimize_table_full, '', status);
00935 M00S00888.tdutab +++| error_status(status);
00936 M00S00889.tdutab +++| RETURN
00937 M00S00890.tdutab +++| IFEND;
00938 M00S00891.tdutab +++| succ_node := curr_level;
00939 M00S00892.tdutab +++| pred_node := NIL;
00940 M00S00893.tdutab +++| new_ndx := 0;
00941 M00S00894.tdutab +++| WHILE ( succ_node <> NIL ) AND
00942 M00S00895.tdutab +++| ( error_return = no_error ) DO
00943 M00S00896.tdutab +++| CASE succ_node^.opcode OF
00944 M00S00897.tdutab +++| = list = { old node, move pieces to new node }
00945 M00S00898.tdutab +++| FOR old_ndx := 1 TO succ_node^.list_character_count DO
00946 M00S00899.tdutab +++| new_ndx := new_ndx + 1;
00947 M00S00900.tdutab +++| new_node^.list_pointer^[new_ndx].character :=
00948 M00S00901.tdutab +++| succ_node^.list_pointer^[old_ndx].character;
00949 M00S00902.tdutab +++| new_node^.list_pointer^[new_ndx].action :=
00950 M00S00903.tdutab +++| succ_node^.list_pointer^[old_ndx].action
00951 M00S00904.tdutab +++| FOREND;
00952 M00S00905.tdutab +++| FREE succ_node^.list_pointer;
00953 M00S00906.tdutab +++| IF succ_node = curr_level THEN { old list is first on lvl }
00954 M00S00907.tdutab +++| curr_level := succ_node^.next_node; { link around it }
00955 M00S00908.tdutab +++| FREE succ_node;
00956 M00S00909.tdutab +++| succ_node := curr_level
00957 M00S00910.tdutab +++| ELSE
00958 M00S00911.tdutab +++| pred_node^.next_node := succ_node^.next_node;
00959 M00S00912.tdutab +++| FREE succ_node;
00960 M00S00913.tdutab +++| succ_node := pred_node^.next_node
00961 M00S00914.tdutab +++| IFEND;
00962 M00S00915.tdutab +++| = range, single_action_range =
00963 M00S00916.tdutab +++| pred_node := succ_node;
00964 M00S00917.tdutab +++| succ_node := pred_node^.next_node;
00965 M00S00918.tdutab +++| = fail = { at end, insert new node here }
00966 M00S00919.tdutab +++| new_node^.next_node := succ_node; { new list at end }
00967 M00S00920.tdutab +++| IF succ_node = curr_level THEN { new node is first on lvl }
00968 M00S00921.tdutab +++| curr_level := new_node { return pointer to my caller }
00969 M00S00922.tdutab +++| ELSE
00970 M00S00923.tdutab +++| pred_node^.next_node := new_node
00971 M00S00924.tdutab +++| IFEND;
00972 M00S00925.tdutab +++| succ_node := NIL;
00973 M00S00926.tdutab +++| CASEND;
00974 M00S00927.tdutab +++| WHILEND
00975 M00S00928.tdutab +++| IFEND
00976 M00S00929.tdutab +++| PROCEND combine_list_level;
00977 M00S00930.tdutab +++| ?? OLDTITLE ??
00978 M00S00931.tdutab +++|
00979 M00S00932.tdutab +++| ?? NEWTITLE := 'assign_input_offsets' ??
00980 M00S00933.tdutab +++| ?? SKIP := 2 ??
00981 M00S00934.tdutab +++|
00982 M00S00935.tdutab +++| PROCEDURE assign_input_offsets (in_node: ^input_node);
00983 M00S00936.tdutab +++| VAR
00984 M00S00937.tdutab +++| action_ndx: INTEGER;
00985 M00S00938.tdutab +++|
00986 M00S00939.tdutab +++| CASE in_node^.opcode OF
00987 M00S00940.tdutab +++| = fail =
00988 M00S00941.tdutab +++| ;
00989 M00S00942.tdutab +++| = list =
00990 M00S00943.tdutab +++| FOR action_ndx := 1 TO in_node^.list_character_count DO
00991 M00S00944.tdutab +++| IF in_node^.list_pointer^[action_ndx].action.ordinal =
00992 M00S00945.tdutab +++| no_ordinal THEN
00993 M00S00946.tdutab +++| in_node^.list_pointer^[action_ndx].action.next_offset :=
00994 M00S00947.tdutab +++| in_node^.list_pointer^[action_ndx].action.next_level^
00995 M00S00948.tdutab +++| .offset
00996 M00S00949.tdutab +++| IFEND
00997 M00S00950.tdutab +++| FOREND;
00998 M00S00951.tdutab +++| = range =
00999 M00S00952.tdutab +++| FOR action_ndx := ORD(in_node^.range_lower_bound) TO
01000 M00S00953.tdutab +++| ORD(in_node^.range_upper_bound) DO
01001 M00S00954.tdutab +++| IF in_node^.range_pointer^[action_ndx].ordinal=no_ordinal THEN
01002 M00S00955.tdutab +++| in_node^.range_pointer^[action_ndx].next_offset :=
01003 M00S00956.tdutab +++| in_node^.range_pointer^[action_ndx].next_level^.offset
01004 M00S00957.tdutab +++| IFEND
01005 M00S00958.tdutab +++| FOREND;
01006 M00S00959.tdutab +++| = single_action_range =
01007 M00S00960.tdutab +++| IF in_node^.sar_action.ordinal = no_ordinal THEN
01008 M00S00961.tdutab +++| in_node^.sar_action.next_offset :=
01009 M00S00962.tdutab +++| in_node^.sar_action.next_level^.offset
01010 M00S00963.tdutab +++| IFEND
01011 M00S00964.tdutab +++| CASEND
01012 M00S00965.tdutab +++| PROCEND assign_input_offsets;
01013 M00S00966.tdutab +++| ?? OLDTITLE ??
01014 M00S00967.tdutab +++|
01015 M00S00968.tdutab +++| ?? EJECT ??
01016 M00S00969.tdutab +++|
01017 M00S00970.tdutab +++| error_return := no_error;
01018 M00S00971.tdutab +++| appstr_latest_new_node := appstr_table;
01019 M00S00972.tdutab +++|
01020 M00S00973.tdutab +++| traverse_input_tree(input_list, NIL, ^create_ranges);
01021 M00S00974.tdutab +++| create_range_level(input_list); { root level wasn't handled recursively }
01022 M00S00975.tdutab +++| IF error_return = no_error THEN
01023 M00S00976.tdutab +++| insert_remaining_chars; { adds all chars not already in first lv}
01024 M00S00977.tdutab +++| IF error_return = no_error THEN
01025 M00S00978.tdutab +++| traverse_input_tree(input_list, NIL, ^combine_lists);
01026 M00S00979.tdutab +++| combine_list_level(input_list); { root level wasn't handled }
01027 M00S00980.tdutab +++| IF error_return = no_error THEN
01028 M00S00981.tdutab +++| input_offset := 0; { assign object table offset addresses }
01029 M00S00982.tdutab +++| dump_input_node(^calculate_input_offsets);
01030 M00S00983.tdutab +++| dump_input_node(^assign_input_offsets)
01031 M00S00984.tdutab +++| IFEND
01032 M00S00985.tdutab +++| IFEND
01033 M00S00986.tdutab +++| IFEND
01034 M00S00987.tdutab +++| PROCEND optimize_tables;
01035 M00S00988.tdutab +++| ?? OLDTITLE ??
01036 M00S00989.tdutab +++|
01037 M00S00990.tdutab +++|MODEND tdutab;
cdc/nos2.source/opl.opl871/deck/tdutab.txt · Last modified: (external edit)