/* BEGIN: fs_star_.incl.pl1 * * * * * * * * * * * * */ /****^ HISTORY COMMENTS: 1) change(88-07-15,GDixon), approve(88-09-20,MCR7987), audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): Initial version corresponding to MTB781-00. 2) change(88-08-25,GDixon), approve(88-09-20,MCR7987), audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): Modifications corresponding to MTB781-01 correcting minor problems found during the review of the earlier MTB. 3) change(88-09-19,GDixon), approve(88-09-20,MCR8007), audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): Final changes reflecting MTB781-02. This is the MR12.2 version. END HISTORY COMMENTS */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* This include file declares structures and named constants used when calling the fs_star_ */ /* subroutine. */ /* */ /* star_options: */ /* defines star matching, selection and sorting criteria. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 star_options aligned based (star_optionsP), 2 version char(8), /* = STAR_OPTIONS_VERSION_1 */ 2 caller, 3 ssu_sciP ptr, /* subsystem sci_ptr, used to get */ /* areas & temp segs, report errors. */ /* null => use other elements as below */ 3 fs_star_dataP ptr, /* ptr to fs_star_ internal data. */ 2 selection, 3 star_pathsP ptr, /* ptr to input pathname array. */ /* Starred paths select starting ents. */ 3 path_allow bit(36) aligned, /* type of paths allowed in star_paths */ /* See PATH_ALLOW_xxx constants below. */ 3 entry_type, /* selection/expansion of standard */ 4 ( /* entry types. See ENTRY_xxx */ links, /* constants below. */ segs, dirs, msfs, msf_comps, dm_files, archives, arch_comps, extended_entries) bit(36) aligned, 3 extended_entry_typesP ptr, /* ptr to entry type selection array. */ /* ^=null => only paths matching one */ /* extended entry type are */ /* selected. */ 3 match_namesP ptr, /* ptr to added starname match array. */ /* ^=null => only paths matching one */ /* or more matchnames are */ /* selected. */ 3 exclude_namesP ptr, /* ptr to starname exclusion array. */ /* ^=null => selected paths matching */ /* one or more excludenames */ /* are de-selected. */ 2 per_entry, /* For each selected entry: */ 3 sorting (6), /* major/minor sort keys, by locator */ 4 ( /* within selected subtree. */ dirs, /* Sorting of dirs in selected subtree */ dir_ents, /* Sorting of ents in selected dirs. */ comps) fixed bin, /* Sorting of archive and msf */ /* components in selected ents. */ /* Lower-numbered array elements are */ /* major keys. See SORT_xxx */ /* constants below. */ 3 handler /* call this proc to handle entry. */ entry (ptr, char(*), (*)char(32), char(*), fixed bin), /* call handler (star_dataP, dir, ent_names, comp_name, action); */ 3 error /* call this proc if error occurs. */ entry (ptr, char(*), (*)char(32), char(*), fixed bin(35), char(*), fixed bin), /* call error (star_dataP, dir, ent_names, comp_name, */ /* code, message, action); */ /* =ssu_$null_entry => */ /* use ssu_$print_error */ 3 handler_dataP ptr, /* ptr to caller-provided data passed */ /* on to .handler and .error. */ 3 data_desired fixed bin, /* type of info to pass to .handler */ /* for each selected entry. See */ /* DATA_xxx constants below. */ 3 data_version char(8) unal, /* Version of star_data structure */ /* that .handler expects to receive. */ /* Only STAR_DATA_VERSION_1 allowed. */ 2 mbz bit(36) aligned, /* Reserved for future use. */ star_optionsP ptr; /* ptr to star_options structure. */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constant for star_options.version: */ /* version of star_options the caller is prepared to deal with. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl STAR_OPTIONS_VERSION_1 init("STAROPT1") char(8) int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* star_paths: */ /* array of directory entry pathnames (or archive component pathnames) which does initial */ /* pathname selection, based upon starnames in dir part (dir>**>ent), final entryname (dir>**), */ /* and/or archive component part (dir>ent.archive::**) of pathname. These starnames select the */ /* initial set of entries to which further selection criteria are applied. */ /* star_options.path_allow setting controls which type of pathname (dir entry or archive */ /* component) is allowed, and which parts may contain stars. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 star_paths aligned based (star_options.star_pathsP), 2 version char(8), /* = STAR_PATHS_VERSION_1 */ 2 max_count fixed bin, /* maximum size of value array for the */ /* current allocation of star_paths. */ 2 count fixed bin, /* current size of value array. */ 2 value (star_paths_size refer (star_paths.max_count)) char(202) unal, /* dir>**>ent>**::** */ star_paths_size fixed bin auto, STAR_PATHS_VERSION_1 init("STARPTH1") char(8) int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.path_allow: */ /* select the types of pathnames are allowed, and which pathname components may contain stars. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (PATH_ALLOW_DIR_STAR_NAMES init("1"b), /* dir>**>ent */ PATH_ALLOW_ENTRY_STAR_NAMES init("01"b), /* dir>** */ PATH_ALLOW_ARCHIVE_COMPONENTS init("001"b), /* dir>ent::comp */ PATH_ALLOW_ARCHIVE_STAR_NAMES init("0001"b), /* dir>ent::** */ PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES init("0011"b), /* dir>ent::** or dir>ent::comp */ PATH_ALLOW_NONDIR_STAR_NAMES init("0111"b), /* dir>**::** */ PATH_ALLOW_BRANCH_STAR_NAMES init("1100"b), /* dir>**>** */ PATH_ALLOW_ALL_STAR_NAMES init("1111"b)) /* dir>**>**::** */ bit(36) aligned int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.selection.entry_type: */ /* for entries matching the starname, selection by entry type, control expansion, etc. */ /* One named constant from each group may be ORed together to form a value to be assigned to */ /* each star_options.entry_type.XXX value (eg, star_options.entry_type.segs). */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (ENTRY_DONT_RETURN init("1"b), /* Don't return entries of this type. */ ENTRY_RETURN init("0"b), /* Return entries of this type. */ ENTRY_LIST_SUBENTRIES init("01"b), /* List components of matching ents. */ ENTRY_DONT_LIST_SUBENTRIES init("00"b), /* Don't list components of match ents. */ /* Applies to: dirs, archives, msfs */ ENTRY_INAEE init("001"b), /* Interpret as extended ent (-inaee). */ ENTRY_INASE init("000"b), /* Interpret as standard ent (-inase). */ /* Applies to: segs, dirs, msfs, & */ /* dm_files. */ ENTRY_DONT_SELECT_NULL init("0001"b), /* Select only nonnull entries. */ ENTRY_DONT_SELECT_NONNULL init("00001"b), /* Select only null entries. */ ENTRY_SELECT_NULL_NONNULL init("00000"b), /* Select both null and nonnull entries.*/ /* Applies to: links, segs, msfs, */ /* msf_comps, archives, arch_comps */ ENTRY_CHASE_NONSTAR_LINKS init("000001"b), /* Chase links only if link was not */ /* selected by a starname. */ ENTRY_CHASE_ALL_LINKS init("0000001"b), /* Chase all links. (-chase) */ ENTRY_DONT_CHASE_LINKS init("0000000"b), /* Don't chase links. (-no_chase) */ /* Applies to: links */ ENTRY_DONT_SELECT_OBJECTS init("00000001"b), /* Select only nonobject files. */ ENTRY_DONT_SELECT_NONOBJECTS init("000000001"b), /* Select only object files. */ ENTRY_SELECT_ALL_FILES init("000000000"b), /* Select both objects and nonobjects. */ /* Applies to: segs, msfs, arch_comps */ ENTRY_DONT_SELECT_MDIRS init("0000000001"b), /* Select only nonmaster dirs. */ ENTRY_DONT_SELECT_NON_MDIRS init("00000000001"b),/* Select only master dirs. */ ENTRY_SELECT_ALL_DIRS init("00000000000"b))/* Select both masters and nonmasters. */ /* Applies to: dirs */ bit(36) aligned int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* extended_entry_types: */ /* array of extended entry types applied to entries selected from the star_paths array. If an */ /* entry matches any of the given extended types, that entry is included for further selection. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 extended_entry_types aligned based (star_options.extended_entry_typesP), 2 version char(8), /* = STAR_EXTENDED_ENTRY_VERSION_1 */ 2 max_count fixed bin, /* maximum size of value array for the */ /* current allocation of */ /* extended_entry_types. */ 2 count fixed bin, /* current size of value array. */ 2 value (extended_entry_types_size refer (extended_entry_types.max_count)) char(32) unal, /* -slet EXTENDED_TYPE */ extended_entry_types_size fixed bin auto, STAR_EXTENDED_ENTRY_VERSION_1 init("STARETP1") char(8) int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* match_names: */ /* array of additional starnames which are applied to entries selected from the star_paths */ /* and extended_entry_types arrays. If any name on an entry matches any match_name, that entry */ /* is included for further selection. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 match_names aligned based (star_options.match_namesP), 2 version char(8), /* = STAR_MATCH_NAMES_VERSION_1 */ 2 max_count fixed bin, /* maximum size of value array for the */ /* current allocation of match_names. */ 2 count fixed bin, /* current size of value array. */ 2 value (match_names_size refer (match_names.max_count)) char(32) unal, /* -match ** */ match_names_size fixed bin auto, STAR_MATCH_NAMES_VERSION_1 init("STARMNM1") char(8) int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* exclude_names: */ /* array of starnames which are applied to entries selected from star_paths, */ /* extended_entry_types and match_names arrays. If any name on an entry matches an exclude */ /* name, that entry is excluded from further selection. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 exclude_names aligned based (star_options.exclude_namesP), 2 version char(8), /* = STAR_EXCLUDE_NAMES_VERSION_1 */ 2 max_count fixed bin, /* maximum size of value array for the */ /* current allocation of exclude_names */ 2 count fixed bin, /* current size of value array. */ 2 value (exclude_names_size refer (exclude_names.max_count)) char(32) unal, /* -exclude ** */ exclude_names_size fixed bin auto, STAR_EXCLUDE_NAMES_VERSION_1 init("STARENM1") char(8) int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.handler: */ /* handler procedure's action parameter to control the further progress of searching. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (HANDLER_OK init (0), /* no error when handling entry. */ HANDLER_REJECT init (1), /* no error, but handler does not */ /* accept entry; it should not be */ /* counted, expanded, etc. */ HANDLER_DONT_EXPAND init (2), /* no error, but handler does not want */ /* dir/archive entry expanded. */ HANDLER_EXPAND init (3), /* no error, but expand dir/archive */ /* even if contrary to .entry_type. */ HANDLER_EXPAND_DONT_COUNT init (4), /* no error, but handler does not accept */ /* entry; it should not be counted, but */ /* should be expanded. */ HANDLER_DONT_COUNT init (5), /* no error, but handler does not accept */ /* entry; it should not be counted. Its */ /* expansion depends upon .entry_type */ /* setting for this type of entry. */ HANDLER_STOP init (6), /* no error, but the selection process */ /* process terminates immediately. */ /* Entry should be counted, then */ /* fs_star_$select returns to caller. */ HANDLER_ABORT init (7) /* error, entry not counted, selection */ /* process terminates immediately, */ /* handler reports any error, then */ /* fs_star_$select returns to caller. */ ) fixed bin internal static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.error: */ /* error procedure's action parameter. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (ERROR_OK init (0), /* error was processed successfully. */ /* Entry causing error should be */ /* counted as a match, but should not */ /* be passed to handler for processing */ /* nor expanded. */ ERROR_REJECT init (1), /* error was processed successfully. */ /* Entry causing error was rejected, */ /* should not be counted as a match, */ /* expanded, nor passed to handler. */ ERROR_STOP init (6), /* error was processed successfully, */ /* but error routine wants to stop the */ /* selection process immediately. */ /* Entry should be counted as a match, */ /* but not expanded nor passed to the */ /* handler routine for processing. */ ERROR_ABORT init (7) /* error processing was unsuccessful. */ /* Error routine wants to stop the */ /* selection process immediately. */ /* Entry should not be counted as a */ /* match, expanded, nor passed to the */ /* handler routine. */ ) fixed bin internal static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.sorting: */ /* */ /* fs_star_ can sort the selected entries before they are passed to the caller-provided handler */ /* routine. Sorting of selected entries can be based upon three categories of sorting: */ /* - the attributes of selected archive or MSF components (the component's name or its position */ /* within the archive/msf); or */ /* - the attributes of the selected directory entry (matching entryname, entry type or position */ /* within the directory); or */ /* - the selected entry's location within the selected subtree, or the matching entrynames in the */ /* directory part of the pathname of a selected entry. */ /* */ /* To provide flexibility, any of the sorting categories above can be used singly, or in */ /* combination. If used in combination, component sorting occurs before entry sorting, which occurs */ /* before directory pathname sorting. Within a given category, several sorting operations are */ /* possible. These include: */ /* - sorting by name; */ /* - sorting by (standard or extended) entry type; */ /* - sorting of children entries with respect to their parent; */ /* - sorting in ascending or descending sequence (forward or reverse); or */ /* - sorting can be disabled for the category. */ /* */ /* Within a sort category, each sorting operation can be used singly, or in combinations of one to*/ /* four sort operations in a caller-defined order. Order sort operations are specified by filling in*/ /* the elements of the star_options.sorting arrays. For example: */ /* star_options.selection.entry_type = ENTRY_RETURN; */ /* star_options.sorting(*) = SORT_OFF; */ /* star_options.sorting(1) = SORT_FORWARD; */ /* star_options.sorting(1).comps = SORT_BY_NAME; */ /* passes all directories and directory entries in the selected subtree to the handler routine in the*/ /* order they were returned by hcs_$star_. Selected components of archives and MSFs are passed to */ /* the handler routine, sorted by component name. */ /* star_options.selection.entry_type = ENTRY_RETURN; */ /* star_options.sorting(*) = SORT_OFF; */ /* star_options.sorting(1) = SORT_FORWARD; */ /* star_options.sorting(1).comps = SORT_REVERSE; */ /* star_options.sorting(2).comps = SORT_BY_NAME; */ /* passes the components to the handler sorted by component name, in reverse ASCII collating */ /* sequence. */ /* star_options.selection.entry_type = ENTRY_DONT_RETURN; */ /* star_options.selection.entry_type.dirs = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ /* star_options.selection.entry_type.archives = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ /* star_options.selection.entry_type.arch_comps = ENTRY_RETURN; */ /* star_options.sorting(*) = SORT_OFF; */ /* star_options.sorting(1).comps = SORT_BY_NAME; */ /* passes the archive components to the handler sorted by component name, irrespective of the archive*/ /* the component resides in. That is, components in all archives selected from the subtree are found*/ /* and sorted by name, and then passed to the handler in that order. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* star_options.selection.entry_type = ENTRY_RETURN; */ /* star_options.selection.entry_type.dirs = ENTRY_LIST_SUBENTRIES; */ /* star_options.selection.entry_type.arch_comps = ENTRY_DONT_RETURN; */ /* star_options.selection.entry_type.msf_comps = ENTRY_DONT_RETURN; */ /* star_options.sorting(*) = SORT_OFF; */ /* star_options.sorting(1).dirs = SORT_BY_NAME; */ /* star_options.sorting(1).dir_ents = SORT_BY_STANDARD_TYPE */ /* star_options.sorting(2).dir_ents = SORT_BY_NAME; */ /* star_options.sorting(3).dir_ents = SORT_ENTRIES_BEFORE_SUBENTRIES; */ /* passes selected entries to the handler routine sorted by directory, and within a directory sorted */ /* by matching entryname within entry type groupings. For entries in a single directory, this is the*/ /* type of grouping and sorting performed by the command: */ /* list -sort name -all */ /* */ /* Sorting is based upon the location of the item within the selected subtree. If sorting by */ /* dirs(*) is SORT_OFF, then the entire subtree must be selected and sorted before any data can be */ /* passed to the handler. If sorting by dirs(*) is not SORT_OFF, then the contents of each dir is */ /* sorted and passed to handler before processing subdirs. This provides more immediate response. */ /* */ /* Elements of the star_data.matched minor structure below are counts of the total entries found, */ /* divided by entry type. If sorting.dirs(*) is SORT_OFF, then these counts represent the total of */ /* all entries selected within the entire subtree. Otherwise, they represent only the entries */ /* selected and sorted within the current node of the subtree and all previously handled nodes. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (SORT_OFF init(0), /* Don't sort by this subtree locator. */ SORT_FORWARD init(1), /* Sort entries in order returned by */ /* hcs_$star_ or archive_ subrs. */ SORT_REVERSE init(2), /* Reverse ordering specified by */ /* sort_sel elements with higher */ /* index values. */ SORT_BY_NAME init(3), /* Sort by primary matching ent name. */ SORT_BY_STANDARD_ENTRY_TYPE init(4), /* Sort by standard entry type. */ SORT_BY_EXTENDED_ENTRY_TYPE init(5), /* Sort by extended entry type. */ SORT_ENTRIES_BEFORE_SUBENTRIES init(6)) /* Sort all entries in a directory before*/ /* looking for any subentries. By */ /* default, subentries below an entry */ /* are expanded immediately after the */ /* entry is encountered in the sorted */ /* sequence of directory entries. */ fixed bin int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named Constants for star_options.data_desired: */ /* values control the amount of data returned to caller's entry handler routine in */ /* star_data.entry_data. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (DATA_TYPE init (1), /* Entry type, only. */ DATA_INITIATE init (2)) /* Entry type, length and count */ fixed bin int static options(constant); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named constant for star_options.data_version: */ /* caller-specified version of star_data he is willing to accept. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl STAR_DATA_VERSION_1 init ("STARDAT1") char(8) int static options(constant); /* star_data version 1 structure. */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* star_data: */ /* information provided to caller-supplied entry handler routine for each selected entry. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl 1 star_data aligned based (star_dataP), 2 version char(8), /* = STAR_DATA_VERSION_1 */ 2 star_optionsP ptr, /* ptr to caller-supplied star_options */ /* structure. This makes */ /* star_options.handler_dataP */ /* available to the handler routine. */ 2 matched, /* count of matching entries: */ 3 ( current, /* index of current entry in sort list */ total, /* count of total entries. */ links, /* count of total links. */ segs, /* count of total non-archive, */ /* non-extended entry segments. */ dirs, /* count of total directories. */ msfs, /* count of total multisegment files. */ msf_comps, /* count of total msf components. */ dm_files, /* count of total data mgt files. */ archives, /* count of total archives. */ arch_comps, /* count of total archive components. */ extended_entries) fixed bin, /* count of total extended entries. */ /* See Named Constants for */ /* sort_options.sorting above. */ 3 mbz_matched (4) fixed bin, /* reserved for future use. */ 2 entry_data, /* Beginning of DATA_xxx return items. */ 3 data_desired fixed bin, /* amount of data in entry_data minor */ /* structure which is valid. */ 3 depth fixed bin, /* depth of this entry below its */ /* corresponding parent in */ /* star_paths.value. */ 3 type char(32) unal, /* extended entry type for matching */ /* entry. See ENTRY_TYPE_xxx */ /* constants below for standard entry */ /* types. Extended types are given */ /* by entry type suffix (eg, mbx). */ /* Data above available when */ /* data_desired set to DATA_TYPE. */ 3 length fixed bin(35), /* length of entry (by entry type): */ /* link => 0 */ /* seg => bit count */ /* dir => 0 */ /* msf => sum of comp bit counts */ /* msf comp => msf comp bit count */ /* dm_file => 0 */ /* arch => bit count of archive */ /* arch comp => bit count of component */ /* ext entry => 0 */ 3 count fixed bin(35), /* length of entry (by entry type): */ /* link => 0 */ /* seg => 0 */ /* dir => inferior entry count */ /* msf => number of components */ /* msf comp => total msf components */ /* dm_file => 0 */ /* arch => number of components */ /* arch comp => total arch components */ /* ext entry => 0 */ 3 entryP ptr, /* ptr to an entry: */ /* link => null */ /* seg => ptr to segment */ /* dir => null */ /* msf => ptr to msf_manager_ */ /* fcb_ptr argument */ /* msf comp => ptr to msf component */ /* dm_file => null */ /* arch => ptr to archive */ /* arch comp => ptr to component */ /* ext entry => null */ /* Data above available when */ /* data_desired set to DATA_INITIATE. */ star_dataP ptr automatic; /* ptr to star_data structure. */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Named constants for star_data.type: */ /* type values describing the type of entry passed to caller-supplied handler routine. Type */ /* strings for file system standard entry types (links, segments, dirs, dm_files, msfs) agree */ /* with those returned by fs_util_$get_type. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl (ENTRY_TYPE_ARCHIVE init ("-archive"), ENTRY_TYPE_ARCHIVE_COMP init ("-archive_component"), ENTRY_TYPE_DIRECTORY init ("-directory"), ENTRY_TYPE_DM_FILE init ("-dm_file"), ENTRY_TYPE_LINK init ("-link"), ENTRY_TYPE_MSF init ("-multisegment_file"), ENTRY_TYPE_MSF_COMP init ("-msf_component"), ENTRY_TYPE_SEGMENT init ("-segment"), ENTRY_TYPE_UNKNOWN init ("-unknown"), ENTRY_TYPE_UNSET init ("") ) char (32) unaligned int static options (constant); dcl STANDARD_ENTRY_TYPES (9) char (32) unal/* array of standard entry type values. */ int static options(constant) init ( "-link", "-segment", "-directory", "-multisegment_file", "-msf_component", "-dm_file", "-archive", "-archive_component", "-unknown"); /* END OF: fs_star_.incl.pl1 * * * * * * * * * * * * */ */ ----------------------------------------------------------- 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 */