COMPILATION LISTING OF SEGMENT mu_data_class Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 04/18/85 1041.6 mst Thu 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* 22**/ 23 24 mu_data_class: procedure (); return; /* not a valid entry */ 25 26 /* DESCRIPTION: 27* 28* this routine, given a standard multics pl1 argument descriptor, 29* will determine whether the descriptor refers to the class 30* of data, that the particular entry refers to, and return 31* either a true or false value. there are 12 entries: 32* real - determines if the data type is real 33* complex - determines if the data type is complex 34* char - determines determines if the data type is character 35* bit - determines if the data type is bit 36* varying - determines if the data type is bit or character varying 37* aligned - determines if the data type is unpacked 38* fixed - determines if the data type is numeric and fixed point 39* scalar - determines if the data is not an array 40* string - determines if the data is a string type(bit or char) 41* number - determines if the data is a number(real or complex) 42* convertible - determines if the data can be converted to float decimal(59) 43* binary - determines if the data is a binary number 44* 45**/ 46 47 /* PARAMETERS: 48* 49* desc_ptr - - (input) pointer, points to the bit(36) standard 50* multics pl1 descriptor for data, which is to be queried for it's data class 51* 52* valid - - (output) bit(1) aligned, either true or false, true if the 53* descriptor refered to a data type in the class determined by the entry called, 54* which is one of real, complex, char, bit, varying, aligned, fixed, scalar 55* string, number, convertible, or binary 56* 57**/ 58 59 /* check for data being numeric, and real */ 60 61 real: real_data_class: entry (desc_ptr) returns (bit (1) aligned); 62 63 class = type_to_class (descriptor.type); 64 if abs (class) = REAL then 65 valid = ON; 66 else valid = OFF; 67 68 return (valid); 69 70 /* check for data being numeric, and complex */ 71 72 complex: complex_data_class: entry (desc_ptr) returns (bit (1) aligned); 73 74 class = type_to_class (descriptor.type); 75 if abs (class) = COMPLEX then 76 valid = ON; 77 else valid = OFF; 78 79 return (valid); 80 81 /* check for data being character */ 82 83 character: character_data_class: entry (desc_ptr) returns (bit (1) aligned); 84 85 class = type_to_class (descriptor.type); 86 if abs (class) = CHAR then 87 valid = ON; 88 else valid = OFF; 89 90 return (valid); 91 92 /* check for data being bit */ 93 94 bit: bit_data_class: entry (desc_ptr) returns (bit (1) aligned); 95 96 class = type_to_class (descriptor.type); 97 if abs (class) = BIT then 98 valid = ON; 99 else valid = OFF; 100 101 return (valid); 102 103 /* check for data being varying character or bit */ 104 105 varying: varying_data_class: entry (desc_ptr) returns (bit (1) aligned); 106 107 class = type_to_class (descriptor.type); 108 if class < VARYING then 109 valid = ON; 110 else valid = OFF; 111 112 return (valid); 113 114 /* check for data being aligned or unaligned */ 115 116 aligned: aligned_data_class: entry (desc_ptr) returns (bit (1) aligned); 117 118 valid = ^(descriptor.packed); 119 120 return (valid); 121 122 /* check for data being scalar */ 123 124 scalar: scalar_data_class: entry (desc_ptr) returns (bit (1) aligned); 125 126 if fixed (descriptor.number_dims) = 0 then 127 valid = ON; 128 else valid = OFF; 129 130 return (valid); 131 132 /* check for number data being fixed point */ 133 134 fixed: fixed_data_class: entry (desc_ptr) returns (bit (1) aligned); 135 136 class = type_to_class (descriptor.type); 137 if class > 0 & class <= FIXED then 138 valid = ON; 139 else valid = OFF; 140 141 return (valid); 142 143 /* check for data being a string type */ 144 145 string: string_data_class: entry (desc_ptr) returns (bit (1) aligned); 146 147 class = type_to_class (descriptor.type); 148 if abs (class) > STRING then 149 valid = ON; 150 else valid = OFF; 151 152 return (valid); 153 154 /* check for the data being any type of number */ 155 156 number: number_data_class: entry (desc_ptr) returns (bit (1) aligned); 157 158 class = type_to_class (descriptor.type); 159 if class ^= 0 & abs (class) <= NUMBER then 160 valid = ON; 161 else valid = OFF; 162 163 return (valid); 164 165 /* check for data type being convertable to float decimal (59) */ 166 167 convertible: convertible_data_class: entry (desc_ptr) returns (bit (1) aligned); 168 169 class = type_to_class (descriptor.type); 170 if abs (class) = REAL | abs (class) = CHAR then 171 valid = ON; 172 else valid = OFF; 173 174 return (valid); 175 176 /* check for data type being a binary number */ 177 178 binary: binary_data_class: entry (desc_ptr) returns (bit (1) aligned); 179 180 if (descriptor.type >= 1 & descriptor.type <= 8) | 181 descriptor.type = 33 | descriptor.type = 34 then 182 valid = ON; 183 else valid = OFF; 184 185 return (valid); 186 187 declare class fixed bin; /* class encoding taken from data type */ 188 declare STRING fixed bin int static options (constant) init (2); /* encoding for string check */ 189 declare NUMBER fixed bin int static options (constant) init (2); /* encoding for number check */ 190 declare REAL fixed bin internal static options (constant) init (1); /* encoding for real numerics */ 191 declare COMPLEX fixed bin internal static options (constant) init (2); /* encoding for complex numerics */ 192 declare BIT fixed bin internal static options (constant) init (3); /* encoding for bit strings */ 193 declare CHAR fixed bin internal static options (constant) init (4); /* encoding for character strings */ 194 declare VARYING fixed bin internal static options (constant) init (-2); /* encoding for varying string comparison */ 195 declare FIXED fixed bin internal static options (constant) init (2); /* encoding for varying string comparison */ 196 declare valid bit (1) aligned; /* on => class matches entry called */ 197 declare ON bit (1) init ("1"b) internal static options (constant); /* true value */ 198 declare OFF bit (1) init ("0"b) internal static options (constant); /* false value */ 199 declare (abs, fixed) builtin; 200 201 /* the following encoding array, takes a data type as it's index, 202* and returns as an element value, the following classifying values: 203* real fixed = 1, real float = -1, 204* complex fixed = 2, complex float = -2, 205* bit = 3, bit varying = -3, 206* character = 4, character varying = -4, no class = 0 */ 207 208 declare type_to_class (0:63) aligned internal static options (constant) fixed bin 209 init (0, (2) (1), (2) (-1), /* 0 - 4 */ 210 (2) (2), (2) (-2), /* 5 - 8 */ 211 1, -1, 2, -2, (6) (0), /* 9 - 12, 13 - 18 */ 212 3, -3, 4, -4, /* 19 - 22 */ 213 (6) (0), /* 23 - 28 */ 214 (2) (1), (2) (0), /* 29 - 32 */ 215 (4) (1), 0, /* 33 - 37 */ 216 (4) (1), /* 38 - 41 */ 217 -1, 1, -1, 2, -2, /* 42 - 46 */ 218 (17) (0)); /* 47 - 63 */ 219 220 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 221 222 223 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/85 0908.1 mu_data_class.pl1 >special_ldd>online>mrds.pbf-04/18/85>mu_data_class.pl1 221 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 192 ref 97 CHAR constant fixed bin(17,0) initial dcl 193 ref 86 170 COMPLEX constant fixed bin(17,0) initial dcl 191 ref 75 FIXED constant fixed bin(17,0) initial dcl 195 ref 137 NUMBER constant fixed bin(17,0) initial dcl 189 ref 159 OFF constant bit(1) initial unaligned dcl 198 ref 66 77 88 99 110 128 139 150 161 172 183 ON constant bit(1) initial unaligned dcl 197 ref 64 75 86 97 108 126 137 148 159 170 180 REAL constant fixed bin(17,0) initial dcl 190 ref 64 170 STRING constant fixed bin(17,0) initial dcl 188 ref 148 VARYING 001137 constant fixed bin(17,0) initial dcl 194 ref 108 abs builtin function dcl 199 ref 64 75 86 97 148 159 170 170 class 000100 automatic fixed bin(17,0) dcl 187 set ref 63* 64 74* 75 85* 86 96* 97 107* 108 136* 137 137 147* 148 158* 159 159 169* 170 170 desc_ptr parameter pointer dcl 1-19 ref 61 61 63 72 72 74 83 83 85 94 94 96 105 105 107 116 116 118 124 124 126 134 134 136 145 145 147 156 156 158 167 167 169 178 178 180 180 180 180 descriptor based structure level 1 unaligned dcl 1-6 fixed builtin function dcl 199 ref 126 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 126 packed 0(07) based bit(1) level 2 packed unaligned dcl 1-6 ref 118 type 0(01) based fixed bin(6,0) level 2 packed unsigned unaligned dcl 1-6 ref 63 74 85 96 107 136 147 158 169 180 180 180 180 type_to_class 000000 constant fixed bin(17,0) initial array dcl 208 ref 63 74 85 96 107 136 147 158 169 valid 000101 automatic bit(1) dcl 196 set ref 64* 66* 68 75* 77* 79 86* 88* 90 97* 99* 101 108* 110* 112 118* 120 126* 128* 130 137* 139* 141 148* 150* 152 159* 161* 163 170* 172* 174 180* 183* 185 NAMES DECLARED BY EXPLICIT CONTEXT. aligned 000503 constant entry external dcl 116 aligned_data_class 000471 constant entry external dcl 116 binary 001075 constant entry external dcl 178 binary_data_class 001063 constant entry external dcl 178 bit 000356 constant entry external dcl 94 bit_data_class 000344 constant entry external dcl 94 character 000302 constant entry external dcl 83 character_data_class 000270 constant entry external dcl 83 complex 000226 constant entry external dcl 72 complex_data_class 000214 constant entry external dcl 72 convertible 001016 constant entry external dcl 167 convertible_data_class 001004 constant entry external dcl 167 fixed 000613 constant entry external dcl 134 fixed_data_class 000601 constant entry external dcl 134 mu_data_class 000115 constant entry external dcl 24 number 000741 constant entry external dcl 156 number_data_class 000727 constant entry external dcl 156 real 000152 constant entry external dcl 61 real_data_class 000140 constant entry external dcl 61 scalar 000545 constant entry external dcl 124 scalar_data_class 000533 constant entry external dcl 124 string 000665 constant entry external dcl 145 string_data_class 000653 constant entry external dcl 145 varying 000432 constant entry external dcl 105 varying_data_class 000420 constant entry external dcl 105 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 1672 1140 10 223 262 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mu_data_class 70 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME mu_data_class 000100 class mu_data_class 000101 valid mu_data_class 000102 num_dims mu_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 24 000114 24 000125 61 000134 63 000161 64 000170 66 000200 68 000201 72 000212 74 000235 75 000244 77 000254 79 000255 83 000266 85 000311 86 000320 88 000330 90 000331 94 000342 96 000365 97 000374 99 000404 101 000405 105 000416 107 000441 108 000450 110 000455 112 000456 116 000467 118 000512 120 000521 124 000531 126 000554 128 000565 130 000566 134 000577 136 000622 137 000631 139 000637 141 000640 145 000651 147 000674 148 000703 150 000713 152 000714 156 000725 158 000750 159 000757 161 000770 163 000771 167 001002 169 001025 170 001034 172 001047 174 001050 178 001061 180 001104 183 001125 185 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