COMPILATION LISTING OF SEGMENT vrmu_data_class Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/21/84 1437.1 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * * 4* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 5* * * 6* * * 7* *********************************************************** */ 8 9 /* ****************************************************** 10* * * 11* * * 12* * Copyright (c) 1972 by Massachusetts Institute of * 13* * Technology and Honeywell Information Systems, Inc. * 14* * * 15* * * 16* ****************************************************** */ 17 18 /* HISTORY: 19* 20* Originally written by Jim Gray - - December 1979 21* Renamed from mu_data_class for use in vfile_relmgr_ by Ron Harvey - 1983 22* 23**/ 24 25 vrmu_data_class: procedure (); return; /* not a valid entry */ 26 27 /* DESCRIPTION: 28* 29* this routine, given a standard multics pl1 argument descriptor, 30* will determine whether the descriptor refers to the class 31* of data, that the particular entry refers to, and return 32* either a true or false value. there are 12 entries: 33* real - determines if the data type is real 34* complex - determines if the data type is complex 35* char - determines determines if the data type is character 36* bit - determines if the data type is bit 37* varying - determines if the data type is bit or character varying 38* aligned - determines if the data type is unpacked 39* fixed - determines if the data type is numeric and fixed point 40* scalar - determines if the data is not an array 41* string - determines if the data is a string type(bit or char) 42* number - determines if the data is a number(real or complex) 43* convertible - determines if the data can be converted to float decimal(59) 44* binary - determines if the data is a binary number 45* 46**/ 47 48 /* PARAMETERS: 49* 50* desc_ptr - - (input) pointer, points to the bit(36) standard 51* multics pl1 descriptor for data, which is to be queried for it's data class 52* 53* valid - - (output) bit(1) aligned, either true or false, true if the 54* descriptor refered to a data type in the class determined by the entry called, 55* which is one of real, complex, char, bit, varying, aligned, fixed, scalar 56* string, number, convertible, or binary 57* 58**/ 59 60 /* check for data being numeric, and real */ 61 62 real: real_data_class: entry (desc_ptr) returns (bit (1) aligned); 63 64 class = type_to_class (descriptor.type); 65 if abs (class) = REAL then 66 valid = ON; 67 else valid = OFF; 68 69 return (valid); 70 71 /* check for data being numeric, and complex */ 72 73 complex: complex_data_class: entry (desc_ptr) returns (bit (1) aligned); 74 75 class = type_to_class (descriptor.type); 76 if abs (class) = COMPLEX then 77 valid = ON; 78 else valid = OFF; 79 80 return (valid); 81 82 /* check for data being character */ 83 84 character: character_data_class: entry (desc_ptr) returns (bit (1) aligned); 85 86 class = type_to_class (descriptor.type); 87 if abs (class) = CHAR then 88 valid = ON; 89 else valid = OFF; 90 91 return (valid); 92 93 /* check for data being bit */ 94 95 bit: bit_data_class: entry (desc_ptr) returns (bit (1) aligned); 96 97 class = type_to_class (descriptor.type); 98 if abs (class) = BIT then 99 valid = ON; 100 else valid = OFF; 101 102 return (valid); 103 104 /* check for data being varying character or bit */ 105 106 varying: varying_data_class: entry (desc_ptr) returns (bit (1) aligned); 107 108 class = type_to_class (descriptor.type); 109 if class < VARYING then 110 valid = ON; 111 else valid = OFF; 112 113 return (valid); 114 115 /* check for data being aligned or unaligned */ 116 117 aligned: aligned_data_class: entry (desc_ptr) returns (bit (1) aligned); 118 119 valid = ^(descriptor.packed); 120 121 return (valid); 122 123 /* check for data being scalar */ 124 125 scalar: scalar_data_class: entry (desc_ptr) returns (bit (1) aligned); 126 127 if fixed (descriptor.number_dims) = 0 then 128 valid = ON; 129 else valid = OFF; 130 131 return (valid); 132 133 /* check for number data being fixed point */ 134 135 fixed: fixed_data_class: entry (desc_ptr) returns (bit (1) aligned); 136 137 class = type_to_class (descriptor.type); 138 if class > 0 & class <= FIXED then 139 valid = ON; 140 else valid = OFF; 141 142 return (valid); 143 144 /* check for data being a string type */ 145 146 string: string_data_class: entry (desc_ptr) returns (bit (1) aligned); 147 148 class = type_to_class (descriptor.type); 149 if abs (class) > STRING then 150 valid = ON; 151 else valid = OFF; 152 153 return (valid); 154 155 /* check for the data being any type of number */ 156 157 number: number_data_class: entry (desc_ptr) returns (bit (1) aligned); 158 159 class = type_to_class (descriptor.type); 160 if class ^= 0 & abs (class) <= NUMBER then 161 valid = ON; 162 else valid = OFF; 163 164 return (valid); 165 166 /* check for data type being convertable to float decimal (59) */ 167 168 convertible: convertible_data_class: entry (desc_ptr) returns (bit (1) aligned); 169 170 class = type_to_class (descriptor.type); 171 if abs (class) = REAL | abs (class) = CHAR then 172 valid = ON; 173 else valid = OFF; 174 175 return (valid); 176 177 /* check for data type being a binary number */ 178 179 binary: binary_data_class: entry (desc_ptr) returns (bit (1) aligned); 180 181 if (descriptor.type >= 1 & descriptor.type <= 8) | 182 descriptor.type = 33 | descriptor.type = 34 then 183 valid = ON; 184 else valid = OFF; 185 186 return (valid); 187 188 dcl class fixed bin; /* class encoding taken from data type */ 189 dcl STRING fixed bin int static options (constant) init (2); /* encoding for string check */ 190 dcl NUMBER fixed bin int static options (constant) init (2); /* encoding for number check */ 191 dcl REAL fixed bin internal static options (constant) init (1); /* encoding for real numerics */ 192 dcl COMPLEX fixed bin internal static options (constant) init (2); /* encoding for complex numerics */ 193 dcl BIT fixed bin internal static options (constant) init (3); /* encoding for bit strings */ 194 dcl CHAR fixed bin internal static options (constant) init (4); /* encoding for character strings */ 195 dcl VARYING fixed bin internal static options (constant) init (-2); /* encoding for varying string comparison */ 196 dcl FIXED fixed bin internal static options (constant) init (2); /* encoding for varying string comparison */ 197 dcl valid bit (1) aligned; /* on => class matches entry called */ 198 dcl ON bit (1) init ("1"b) internal static options (constant); /* true value */ 199 dcl OFF bit (1) init ("0"b) internal static options (constant); /* false value */ 200 dcl (abs, fixed) builtin; 201 202 /* the following encoding array, takes a data type as it's index, 203* and returns as an element value, the following classifying values: 204* real fixed = 1, real float = -1, 205* complex fixed = 2, complex float = -2, 206* bit = 3, bit varying = -3, 207* character = 4, character varying = -4, no class = 0 */ 208 209 dcl type_to_class (0:63) aligned internal static options (constant) fixed bin 210 init (0, (2) (1), (2) (-1), /* 0 - 4 */ 211 (2) (2), (2) (-2), /* 5 - 8 */ 212 1, -1, 2, -2, (6) (0), /* 9 - 12, 13 - 18 */ 213 3, -3, 4, -4, /* 19 - 22 */ 214 (6) (0), /* 23 - 28 */ 215 (2) (1), (2) (0), /* 29 - 32 */ 216 (4) (1), 0, /* 33 - 37 */ 217 (4) (1), /* 38 - 41 */ 218 -1, 1, -1, 2, -2, /* 42 - 46 */ 219 (17) (0)); /* 47 - 63 */ 220 221 1 1 /* BEGIN mdbm_descriptor.incl.pl1 -- jaw 5/31/78 */ 1 2 /* modified by Jim Gray - - Nov. 1979, to change type from fixed bin(5) to 1 3* unsigned fixed bin(6), so new packed decimal data types could be handled. 1 4* also the duplicate mrds_descriptor.incl.pl1 was eliminated. */ 1 5 1 6 dcl 1 descriptor based (desc_ptr), /* map of Multics descriptor */ 1 7 2 version bit (1) unal, /* DBM handles vers. 1 only */ 1 8 2 type unsigned fixed bin (6) unal, /* data type */ 1 9 2 packed bit (1) unal, /* on if data item is packed */ 1 10 2 number_dims bit (4) unal, /* dimensions */ 1 11 2 size, /* size for string data */ 1 12 3 scale bit (12) unal, /* scale for num. data */ 1 13 3 precision bit (12) unal, /* prec. for num. data */ 1 14 2 array_info (num_dims), 1 15 3 lower_bound fixed bin (35), /* lower bound of dimension */ 1 16 3 upper_bound fixed bin (35), /* upper bound of dimension */ 1 17 3 multiplier fixed bin (35); /* element separation */ 1 18 1 19 dcl desc_ptr ptr; 1 20 dcl num_dims fixed bin init (0) ; /* more useful form of number_dims */ 1 21 1 22 /* END mdbm_descriptor.incl.pl1 */ 1 23 1 24 222 223 224 end vrmu_data_class; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/21/84 0934.0 vrmu_data_class.pl1 >special_ldd>online>mrds_install>vrmu_data_class.pl1 222 1 10/14/83 1608.6 mdbm_descriptor.incl.pl1 >ldd>include>mdbm_descriptor.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. BIT constant fixed bin(17,0) initial dcl 193 ref 98 CHAR constant fixed bin(17,0) initial dcl 194 ref 87 171 COMPLEX constant fixed bin(17,0) initial dcl 192 ref 76 FIXED constant fixed bin(17,0) initial dcl 196 ref 138 NUMBER constant fixed bin(17,0) initial dcl 190 ref 160 OFF constant bit(1) initial unaligned dcl 199 ref 67 78 89 100 111 129 140 151 162 173 184 ON constant bit(1) initial unaligned dcl 198 ref 65 76 87 98 109 127 138 149 160 171 181 REAL constant fixed bin(17,0) initial dcl 191 ref 65 171 STRING constant fixed bin(17,0) initial dcl 189 ref 149 VARYING 001137 constant fixed bin(17,0) initial dcl 195 ref 109 abs builtin function dcl 200 ref 65 76 87 98 149 160 171 171 class 000100 automatic fixed bin(17,0) dcl 188 set ref 64* 65 75* 76 86* 87 97* 98 108* 109 137* 138 138 148* 149 159* 160 160 170* 171 171 desc_ptr parameter pointer dcl 1-19 ref 62 62 64 73 73 75 84 84 86 95 95 97 106 106 108 117 117 119 125 125 127 135 135 137 146 146 148 157 157 159 168 168 170 179 179 181 181 181 181 descriptor based structure level 1 unaligned dcl 1-6 fixed builtin function dcl 200 ref 127 num_dims 000102 automatic fixed bin(17,0) initial dcl 1-20 set ref 1-20* number_dims 0(08) based bit(4) level 2 packed unaligned dcl 1-6 ref 127 packed 0(07) based bit(1) level 2 packed unaligned dcl 1-6 ref 119 type 0(01) based fixed bin(6,0) level 2 packed unsigned unaligned dcl 1-6 ref 64 75 86 97 108 137 148 159 170 181 181 181 181 type_to_class 000000 constant fixed bin(17,0) initial array dcl 209 ref 64 75 86 97 108 137 148 159 170 valid 000101 automatic bit(1) dcl 197 set ref 65* 67* 69 76* 78* 80 87* 89* 91 98* 100* 102 109* 111* 113 119* 121 127* 129* 131 138* 140* 142 149* 151* 153 160* 162* 164 171* 173* 175 181* 184* 186 NAMES DECLARED BY EXPLICIT CONTEXT. aligned 000503 constant entry external dcl 117 aligned_data_class 000471 constant entry external dcl 117 binary 001075 constant entry external dcl 179 binary_data_class 001063 constant entry external dcl 179 bit 000356 constant entry external dcl 95 bit_data_class 000344 constant entry external dcl 95 character 000302 constant entry external dcl 84 character_data_class 000270 constant entry external dcl 84 complex 000226 constant entry external dcl 73 complex_data_class 000214 constant entry external dcl 73 convertible 001016 constant entry external dcl 168 convertible_data_class 001004 constant entry external dcl 168 fixed 000613 constant entry external dcl 135 fixed_data_class 000601 constant entry external dcl 135 number 000741 constant entry external dcl 157 number_data_class 000727 constant entry external dcl 157 real 000152 constant entry external dcl 62 real_data_class 000140 constant entry external dcl 62 scalar 000545 constant entry external dcl 125 scalar_data_class 000533 constant entry external dcl 125 string 000665 constant entry external dcl 146 string_data_class 000653 constant entry external dcl 146 varying 000432 constant entry external dcl 106 varying_data_class 000420 constant entry external dcl 106 vrmu_data_class 000115 constant entry external dcl 25 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1422 1432 1140 1432 Length 1670 1140 10 222 262 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME vrmu_data_class 70 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME vrmu_data_class 000100 class vrmu_data_class 000101 valid vrmu_data_class 000102 num_dims vrmu_data_class THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. return signal ext_entry NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 1 20 000111 25 000114 25 000125 62 000134 64 000161 65 000170 67 000200 69 000201 73 000212 75 000235 76 000244 78 000254 80 000255 84 000266 86 000311 87 000320 89 000330 91 000331 95 000342 97 000365 98 000374 100 000404 102 000405 106 000416 108 000441 109 000450 111 000455 113 000456 117 000467 119 000512 121 000521 125 000531 127 000554 129 000565 131 000566 135 000577 137 000622 138 000631 140 000637 142 000640 146 000651 148 000674 149 000703 151 000713 153 000714 157 000725 159 000750 160 000757 162 000770 164 000771 168 001002 170 001025 171 001034 173 001047 175 001050 179 001061 181 001104 184 001125 186 001126 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved