Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 1

     1:D        0 (*  sccs info:  @(#)  boot_mod  8.1  84/05/04  00:19:20  *)
     2:S          
     3:D        0 $range off$
     4:D        0 $stackcheck off$
     5:D        0 $iocheck off$
     6:D        0 $ovflcheck off$
     7:D        0 $callabs off$
     8:S          {
     9:S          $debug on $
    10:D        0 }
    11:D        0 $modcal$
    12:D        0 $sysprog$
    13:D        0 $ucsd$
    14:S          
    15:D        0 module ganglia;
    16:D        1 $search 'GDC','BROM:BRDECS'$
    17:D        1 import extdc,
    18:D        1        brdecs;
    19:D        1 export
    20:S          
    20:D        1 $include 'SRM_TYPES'$
    21:D        1 (*  sccs info:  @(#)  srm_types  8.1  84/05/04  00:22:04  *)
    22:S          
    23:D        1 type
    24:D        1   byte          = 0..255;
    25:D        1   halfword      = -32768..32767;
    26:S          
    26:D        1 $include 'PACKETS'$
    27:D        1 (*  sccs info:  @(#)  packets  8.1  84/05/04  00:21:24  *)
    28:S          
    29:S          {****************************************************************************
    30:S           * +----------------------------------------------------------------------+ *
    31:S           * |                                                                      | *
    32:S           * |        G A N G L I A   M E S S A G E   F O R M A T S                 | *
    33:S           * |                                                                      | *
    34:S           * |        A N D   R E L A T E D   D E F I N I T I O N S                 | *
    35:S           * |                                                                      | *
    36:S           * +----------------------------------------------------------------------+ *
    37:D        1  ****************************************************************************}
    38:S          
    39:D        1 CONST
    40:S          
    41:D        1    name_type_len = 16;
    42:S          
    43:S             {+----------------------------------------------------------------------+
    44:S              | Message Packet Sizes For Messages That Are Sent To Ganglia           |
    45:D        1     +----------------------------------------------------------------------+}
    46:D        1    size_to_are_you_alive =    12;
    47:D        1    size_to_cat =             128;   (* plus 36 *`# file name sets *)
    48:D        1    size_to_catprotect =      128;   (* plus 36 * # file name sets *)
    49:S             size_to_changeprotect =   116;   (* plus (36 * # file name sets) +
    50:D        1                                             (24 * # file name sets) *)
    51:D        1    size_to_change_vol_label= 132;
    52:D        1    size_to_close =            56;
    53:D        1    size_to_copy =             32;
    54:S             size_to_create =          152;   (* plus (36 * # file name sets) +
    55:D        1                                             (24 * # protect code sets)  *)
    56:D        1    size_to_createlink =      144;   (* plus 36 * # file name sets *)
    57:D        1    size_to_flock =            20;
    58:D        1    size_to_funlock =          20;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 2

    59:D        1    size_to_gang_cleanup =     16;
    60:D        1    size_to_info =             20;
    61:D        1    size_to_init_vol =        172;   (* plus 24 * # protect code sets *)
    62:D        1    size_to_open =            132;   (* plus 36 * # file name sets *)
    63:D        1    size_to_position =         28;
    64:D        1    size_to_purge =           112;   (* plus 36 * # file name sets *)
    65:D        1    size_to_read =             40;
    66:D        1    size_to_set_eof =          28;
    67:D        1    size_to_set_date =         44;
    68:D        1    size_to_volstatus =        84;
    69:D        1    size_to_write =            48;   (* plus the size of the record <= 512 *)
    70:D        1    size_to_xchg_data =       140;   (* plus 36 * # file name sets *)
    71:D        1    size_to_xchg_open =        20;
    72:S          
    73:S          
    74:S             {+----------------------------------------------------------------------+
    75:S              | Message Packet Sizes For Messages Ganglia Will Send Back             |
    76:D        1     +----------------------------------------------------------------------+}
    77:S          
    78:D        1    size_from_are_you_alive  = 16;
    79:D        1    size_from_cat =            24; (* plus 68 * # entries returned *)
    80:D        1    size_from_catprotect =     24; { plus 20 * # prot code entries returned }
    81:D        1    size_from_changeprotect =  16;
    82:D        1    size_from_change_vol_label=16;
    83:D        1    size_from_close =          16;
    84:D        1    size_from_copy =           20;
    85:D        1    size_from_create =         16;
    86:D        1    size_from_createlink =     16;
    87:D        1    size_from_flock =          20;
    88:D        1    size_from_funlock =        16;
    89:D        1    size_from_gang_cleanup =   16;
    90:D        1    size_from_gang_error =     16;
    91:D        1    size_from_info =           88;
    92:D        1    size_from_init_vol =       16;
    93:D        1    size_from_open =           52;
    94:D        1    size_from_position =       16;
    95:D        1    size_from_purge =          16;
    96:D        1    size_from_read =           36;   (* plus the size of the record <= 512 *)
    97:D        1    size_from_set_eof =        16;
    98:D        1    size_from_set_date =       16;
    99:D        1    size_from_volstatus =      40;
   100:D        1    size_from_write =          20;
   101:D        1    size_from_xchg_data =      16;
   102:D        1    size_from_xchg_open =      16;
   103:S          
   104:S          
   105:S             {+----------------------------------------------------------------------+
   106:S              | Ganglia Message Request Types, Modes, And Codes                      |
   107:D        1     +----------------------------------------------------------------------+}
   108:S          
   109:D        1    {*** File Access Method Requests ***}
   110:D        1    req_old_read          =0;  {Old read packet}
   111:D        1    req_write             =1;  {Write a record to an open file.}
   112:D        1    req_position          =2;  {Position an open file.}
   113:D        1    req_read              =3;  {Read a record from an open file.}
   114:D        1    req_set_eof           =4;
   115:S          
   116:D        1    {*** Sharing Requests ***}
   117:D        1    req_flock             =8;  {Lock an open file for exclusive use.}
   118:D        1    req_funlock           =9;  {Unlock an open file.}
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 3

   119:D        1    req_info              =10;
   120:D        1    req_close             =13; {Close an open file.}
   121:S          
   122:D        1    {*** Directory Access Requests ***}
   123:D        1    req_open              =14;
   124:D        1    req_purgelink         =15;
   125:D        1    req_catalog           =16; {List all the files in a directory.}
   126:D        1    req_create            =17;
   127:D        1    req_createlink        =18;
   128:D        1    req_changeprotect     =19; {Change the passwords on a file.}
   129:D        1    req_catprotect        =20; {List all the passwords on a file.}
   130:D        1    req_xchg_data         =21;
   131:S          
   132:D        1    {*** Volume Access Requests ***}
   133:D        1    req_volstatus         =22;
   134:D        1    req_init_vol          =23;
   135:D        1    req_label             =24;
   136:S          
   137:D        1    {*** File Transfer Requests ***}
   138:D        1    req_xchg_open         =29;
   139:D        1    req_copy              =30;
   140:S          
   141:D        1    {*** Ganglia Requests ***}
   142:D        1    req_gang_cleanup      =1000;
   143:D        1    req_are_you_alive     =1001;
   144:S          
   145:S          
   146:D        1    {*** Record Modes ***}
   147:D        1    data_records =         0;
   148:D        1    directory_records =    1;
   149:S          
   150:D        1    {*** Share Codes ***}
   151:D        1    exclusive_share_code = 0;
   152:D        1    shared_share_code    = 1;
   153:D        1    closed_share_code    = 2;
   154:D        1    corrupt_share_code   = 3;
   155:S          
   156:D        1    {*** Access Codes ***}
   157:D        1    random_access =        0;
   158:D        1    sequential_access =    1;
   159:D        1    primitive_access =     2;
   160:S          
   161:S          
   162:D        1 TYPE
   163:S          
   164:S             {+----------------------------------------------------------------------+
   165:S              | Enumerated Types And Minor Structures Used To Make Up More           |
   166:S              | Major Structures Described In The Next Section                       |
   167:D        1     +----------------------------------------------------------------------+}
   168:S          
   169:D        1    access_code_type =
   170:D        1       (ac_manager,
   171:D        1        ac_read,
   172:D        1        ac_write,
   173:D        1        ac_search,
   174:D        1        ac_purgelink,
   175:D        1        ac_createlink,
   176:D        1        ac_execute,
   177:D        1        ac_generic1,ac_generic09,ac_generic17,
   178:D        1        ac_generic2,ac_generic10,ac_generic18,
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 4

   179:D        1        ac_generic3,ac_generic11,ac_generic19,
   180:D        1        ac_generic4,ac_generic12,ac_generic20,
   181:D        1        ac_generic5,ac_generic13,ac_generic21,
   182:D        1        ac_generic6,ac_generic14,ac_generic22,
   183:D        1        ac_generic7,ac_generic15,ac_generic23,
   184:D        1        ac_generic8,ac_generic16,ac_generic24,
   185:D        1        ac_generic25);
   186:S          
   187:D        1    file_id_type = integer;
   188:S          
   189:D        1    {*** Filler Definitions Used In Padding Out Message Packet Layouts ***}
   190:D        1    gang_boolean_filler = boolean;
   191:D        1    gang_32bit_filler = integer;
   192:D        1    gang_16bit_filler = -32768..32767;
   193:S          
   194:D        1    long_boolean = record case integer of
   195:D        1         1:      (i    : integer);
   196:D        1         2:      (fill1: gang_16bit_filler;
   197:D        1                  fill2: gang_boolean_filler;
   198:D        1                  value: boolean);
   199:D        1         end;
   200:S          
   201:D        1    shortint = -32768..32767;
   202:S          
   203:D        1    gang_file_codes = packed record
   204:D        1       case integer of
   205:D        1       0:  (i: integer);
   206:D        1       1:  (firstword: -32768..32767;
   207:D        1            division_code: 0..63;
   208:D        1            dcd_system_type: 0..15;
   209:D        1            dcd_file_type: 0..63);
   210:D        1       2:  (si1:shortint;
   211:D        1            si2:shortint);
   212:S          
   213:D        1    end;
   214:S          
   215:D        1    gang_open_type =
   216:D        1       (open_data,                {Normal data file}
   217:D        1        open_protected_directory, {Directory not closed on cleanup}
   218:D        1        open_directory            {Directory closed on cleanup}
   219:D        1       );
   220:S          
   221:D        1    name_type = packed array [1..name_type_len] of char;
   222:S          
   223:D        1    path_start_type =
   224:D        1       (start_root,             {Start search at root directory}
   225:D        1        start_alternate         {Start search at a working directory.}
   226:D        1       );
   227:S          
   228:D        1    position_type =
   229:D        1       (pos_absolute,      {Position at absolute location in file}
   230:D        1        pos_seq            {Position relative to current record}
   231:D        1       );
   232:S          
   233:D        1    string80 = string[80];
   234:S          
   235:S          
   236:S             {+----------------------------------------------------------------------+
   237:S              | Data Structures Which Are Part Of Message Packet Layouts             |
   238:D        1     +----------------------------------------------------------------------+}
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 5

   239:S          
   240:D        1    access_capabilities = packed array [ access_code_type ] of boolean;
   241:S          
   242:D        1    date_type = record
   243:D        1       fill: gang_16bit_filler;
   244:D        1       date: packed record
   245:D        1                month: 0..12;
   246:D        1                day: 0..31;
   247:D        1                year: 0..100;
   248:D        1             end;
   249:D        1       seconds_since_midnight : integer
   250:D        1    end;
   251:S          
   252:D        1    device_address_type = record
   253:D        1       address1   : integer;
   254:D        1       haddress   : integer;
   255:D        1       unit_num   : integer;
   256:D        1       volume_num : integer
   257:D        1    end;
   258:S          
   259:D        1    file_header_type = record
   260:D        1       num_file_name_sets : integer;
   261:D        1       working_directory  : file_id_type;
   262:D        1       filler1            : gang_16bit_filler;
   263:D        1       path_type          : path_start_type;
   264:D        1       root_password      : name_type;
   265:D        1    end;
   266:S          
   267:D        1    file_info_type = record
   268:D        1       file_name           : name_type;
   269:D        1       open_flag           : long_boolean;
   270:D        1       share_code          : integer;
   271:D        1       file_code           : gang_file_codes;
   272:D        1       record_mode         : integer;
   273:D        1       max_record_size     : integer;
   274:D        1       max_file_size       : integer;
   275:D        1       creation_date       : date_type;
   276:D        1       last_access_date    : date_type;
   277:D        1       capabilities        : access_capabilities;
   278:D        1       logical_eof         : integer;
   279:D        1       physical_size       : integer;
   280:D        1    end;
   281:S          
   282:D        1    file_name_set = record
   283:D        1       file_name : name_type;
   284:D        1       password  : name_type;
   285:D        1       filler    : gang_32bit_filler
   286:D        1    end;
   287:S          
   288:D        1    linkfillertype = packed record
   289:D        1       requeue:          boolean;
   290:D        1       zit1:             byte;       { unused }
   291:D        1       zit2:             integer;    { unused }
   292:D        1       oddbytefiller:    byte;       { unused }
   293:D        1       destaddr:         byte;
   294:D        1       sourceaddr:       byte;   { These three bytes     }
   295:D        1       len_lobyte:       byte;   { are filled in by      }
   296:D        1       len_hibyte:       byte;   { the transmitting card }
   297:D        1       level:            byte;
   298:D        1    end;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 6

   299:S          
   300:D        1    msg_packet_type = packed array [1..800 {or so} ] of char;
   301:D        1    msg_packet_ptr = ^msg_packet_type;
   302:S          
   303:D        1    owner_id_type = record
   304:D        1       id : integer;
   305:D        1    end;
   306:S          
   307:D        1    protect_code_set = record
   308:D        1       capabilities   : access_capabilities;
   309:D        1       password       : name_type;
   310:D        1       filler         : gang_32bit_filler
   311:D        1    end;
   312:S          
   313:D        1    return_header_type = record
   314:D        1       linkfiller            : linkfillertype;
   315:D        1       message_length        : integer;
   316:D        1       return_request_type   : integer;
   317:D        1       user_sequencing_field : integer;
   318:D        1       status                : integer
   319:D        1    end;
   320:S          
   321:D        1    send_header_type = record
   322:D        1       linkfiller            : linkfillertype;
   323:D        1       message_length        : integer;
   324:D        1       send_request_type     : integer;
   325:D        1       user_sequencing_field : integer
   326:D        1    end;
   327:S          
   328:D        1    volume_header_type = record
   329:D        1       filler1                : gang_32bit_filler;
   330:D        1       driver_name            : name_type;
   331:D        1       catalogue_organization : name_type;
   332:D        1       device_address_present : long_boolean;
   333:D        1       device_address         : device_address_type;
   334:D        1       volume_name            : name_type;
   335:D        1    end;
   336:S          
   337:D        1    volume_info_type = record
   338:D        1       free_blocks   : integer;
   339:D        1       bad_blocks    : integer;
   340:D        1       media_origin  : integer;
   341:D        1       interleave    : integer;
   342:D        1       volume_label  : name_type;
   343:D        1    end;
   344:S          
   345:S          
   346:S          
   347:S             {+----------------------------------------------------------------------+
   348:S              | Send and return record layouts for request: Are You Alive ?!         |
   349:D        1     +----------------------------------------------------------------------+}
   350:S          
   351:D        1    send_are_you_alive = record
   352:D        1       send_mess_header   : send_header_type;
   353:D        1    end;
   354:S          
   355:D        1    return_are_you_alive = record
   356:D        1       return_mess_header : return_header_type;
   357:D        1    end;
   358:S          
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 7

   359:S          
   360:S             {+----------------------------------------------------------------------+
   361:S              | Send and return record layouts for request: Catalogue                |
   362:D        1     +----------------------------------------------------------------------+}
   363:S          
   364:D        1    send_catalogue = record
   365:D        1       send_mess_header   : send_header_type;
   366:D        1       max_num_files      : integer;
   367:D        1       file_index         : integer;
   368:D        1       filler1            : gang_32bit_filler; {actual_num_files}
   369:D        1       volume_name_header : volume_header_type;
   370:D        1       file_name_header   : file_header_type;
   371:D        1       filler2            : gang_32bit_filler;
   372:D        1       start_name_sets    : integer
   373:D        1    end;
   374:S          
   375:D        1    return_catalogue = record
   376:D        1       return_mess_header : return_header_type;
   377:D        1       filler1            : gang_32bit_filler; {file_index}
   378:D        1       actual_num_files   : integer;
   379:D        1       cat_info           : array [1..7] of file_info_type
   380:D        1    end;
   381:S          
   382:S          
   383:S             {+----------------------------------------------------------------------+
   384:S              | Send and return record layouts for request: Catalogue Protect Codes  |
   385:D        1     +----------------------------------------------------------------------+}
   386:S          
   387:D        1    send_cat_passwords = record
   388:D        1       send_mess_header        : send_header_type;
   389:D        1       max_num_passwords       : integer;
   390:D        1       filler1                 : gang_32bit_filler;  {actual_passwords}
   391:D        1       password_index          : integer;
   392:D        1       volume_name_header      : volume_header_type;
   393:D        1       file_name_header        : file_header_type;
   394:D        1       filler2                 : gang_32bit_filler;
   395:D        1       start_name_sets         : integer
   396:D        1    end;
   397:S          
   398:D        1    return_cat_passwords = record
   399:D        1       return_mess_header   : return_header_type;
   400:D        1       actual_num_passwords : integer;
   401:D        1       filler1              : gang_32bit_filler;
   402:D        1       password_info        : array [1..24] of record
   403:D        1                                 password     : name_type;
   404:D        1                                 capabilities : access_capabilities
   405:D        1                              end
   406:D        1    end;
   407:S          
   408:S          
   409:S             {+----------------------------------------------------------------------+
   410:S              | Send and return record layouts for request: Change Protect Codes     |
   411:D        1     +----------------------------------------------------------------------+}
   412:S          
   413:D        1    send_change_protect_codes = record
   414:D        1       send_mess_header        : send_header_type;
   415:D        1       volume_name_header      : volume_header_type;
   416:D        1       file_name_header        : file_header_type;
   417:D        1       num_protect_code_sets   : integer;
   418:D        1       start_name_sets         : integer
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 8

   419:D        1    end;
   420:S          
   421:D        1    return_change_protect_codes = record
   422:D        1       return_mess_header : return_header_type
   423:D        1    end;
   424:S          
   425:S          
   426:S             {+----------------------------------------------------------------------+
   427:S              | Send and return record layouts for request: Change Volume Label      |
   428:D        1     +----------------------------------------------------------------------+}
   429:S          
   430:D        1    send_change_volume_label = record
   431:D        1       send_mess_header        : send_header_type;
   432:D        1       volume_name_header      : volume_header_type;
   433:D        1       password                : name_type;
   434:D        1       new_volume_name         : name_type;
   435:D        1       new_vol_password        : name_type;
   436:D        1    end;
   437:S          
   438:D        1    return_change_volume_label = record
   439:D        1       return_mess_header : return_header_type
   440:D        1    end;
   441:S          
   442:S          
   443:S             {+----------------------------------------------------------------------+
   444:S              | Send and return record layouts for request: Close A File             |
   445:D        1     +----------------------------------------------------------------------+}
   446:S          
   447:D        1    send_closeafile = record
   448:D        1       send_mess_header   : send_header_type;
   449:D        1       file_id            : file_id_type;
   450:D        1       directory_password : name_type;
   451:D        1       file_password      : name_type;
   452:D        1       filler5            : long_boolean;
   453:D        1       nodeallocate       : long_boolean;
   454:D        1    end;
   455:S          
   456:D        1    return_closeafile = record
   457:D        1       return_mess_header : return_header_type
   458:D        1    end;
   459:S          
   460:S          
   461:S             {+----------------------------------------------------------------------+
   462:S              | Send and return record layouts for request: Copy File To File        |
   463:D        1     +----------------------------------------------------------------------+}
   464:S          
   465:D        1    send_copy = record
   466:D        1       send_mess_header       : send_header_type;
   467:D        1       source_file_id         : file_id_type;
   468:D        1       source_offset          : integer;
   469:D        1       destination_file_id    : file_id_type;
   470:D        1       destination_offset     : integer;
   471:D        1       requested              : integer;
   472:D        1    end;
   473:S          
   474:D        1    return_copy = record
   475:D        1       return_mess_header   : return_header_type;
   476:D        1       actual               : integer;
   477:D        1    end;
   478:S          
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 9

   479:S          
   480:S             {+----------------------------------------------------------------------+
   481:S              | Send and return record layouts for request: Create A File            |
   482:D        1     +----------------------------------------------------------------------+}
   483:S          
   484:D        1    send_createafile = record
   485:D        1       send_mess_header        : send_header_type;
   486:D        1       volume_name_header      : volume_header_type;
   487:D        1       file_name_header        : file_header_type;
   488:D        1       file_code               : gang_file_codes;
   489:D        1       record_mode             : integer;
   490:D        1       max_record_size         : integer;
   491:D        1       first_extent            : integer;    {Size in logical records.}
   492:D        1       contiguous_first_extent : long_boolean;
   493:D        1       secondary_extent        : integer;
   494:D        1       max_file_size           : integer;
   495:D        1       boot_start_address      : integer;
   496:D        1       num_protect_code_sets   : integer;
   497:D        1       label_included_flag     : long_boolean;
   498:D        1       start_name_sets         : integer
   499:D        1    end;
   500:S          
   501:D        1    return_createafile = record
   502:D        1       return_mess_header : return_header_type
   503:D        1    end;
   504:S          
   505:S          
   506:S             {+----------------------------------------------------------------------+
   507:S              | Send and return record layouts for request: Create A Link (Rename)   |
   508:D        1     +----------------------------------------------------------------------+}
   509:S          
   510:D        1    send_createlink = record
   511:D        1       send_mess_header     : send_header_type;
   512:D        1       volume_name_header   : volume_header_type;
   513:D        1       old_file_name_header : file_header_type;
   514:D        1       new_file_name_header : file_header_type;
   515:D        1       purge_old_link       : long_boolean;
   516:D        1       start_name_sets      : integer
   517:D        1    end;
   518:S          
   519:D        1    return_createlink = record
   520:D        1       return_mess_header   : return_header_type;
   521:D        1    end;
   522:S          
   523:S          
   524:S             {+----------------------------------------------------------------------+
   525:S              | Send and return record layouts for request: Exchange files           |
   526:D        1     +----------------------------------------------------------------------+}
   527:S          
   528:D        1    send_xchg_data = record
   529:D        1       send_mess_header     : send_header_type;
   530:D        1       volume_name_header   : volume_header_type;
   531:D        1       file_name_header1    : file_header_type;
   532:D        1       file_name_header2    : file_header_type;
   533:D        1       start_name_sets      : integer;
   534:D        1    end;
   535:S          
   536:D        1    return_xchg_data = record
   537:D        1       return_mess_header   : return_header_type;
   538:D        1    end;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 10

   539:S          
   540:S          
   541:S          
   542:S             {+----------------------------------------------------------------------+
   543:S              | Send and return record layouts for request: Exchange open files      |
   544:D        1     +----------------------------------------------------------------------+}
   545:S          
   546:D        1    send_xchg_open = record
   547:D        1       send_mess_header     : send_header_type;
   548:D        1       file_id_1            : file_id_type;
   549:D        1       file_id_2            : file_id_type;
   550:D        1    end;
   551:S          
   552:D        1    return_xchg_open = record
   553:D        1       return_mess_header   : return_header_type;
   554:D        1    end;
   555:S          
   556:S          
   557:S          
   558:S             {+----------------------------------------------------------------------+
   559:S              | Send and return record layouts for request: File Information         |
   560:D        1     +----------------------------------------------------------------------+}
   561:S          
   562:D        1    send_fileinfo = record
   563:D        1       send_mess_header  : send_header_type;
   564:D        1       implicit_unlock   : long_boolean;
   565:D        1       file_id           : file_id_type
   566:D        1    end;
   567:S          
   568:D        1    return_fileinfo = record
   569:D        1       return_mess_header : return_header_type;
   570:D        1       current_record     : integer;
   571:D        1       file_info          : file_info_type;
   572:D        1    end;
   573:S          
   574:S          
   575:S          
   576:S             {+----------------------------------------------------------------------+
   577:S              | Send and return record layouts for request: Ganglia Cleanup          |
   578:D        1     +----------------------------------------------------------------------+}
   579:S          
   580:D        1    send_gang_cleanup = record
   581:D        1       send_mess_header          : send_header_type;
   582:D        1       keep_protected_directories: long_boolean;
   583:D        1    end;
   584:S          
   585:D        1    return_gang_cleanup = record
   586:D        1       return_mess_header : return_header_type
   587:D        1    end;
   588:S          
   589:S          
   590:S          
   591:S             {+----------------------------------------------------------------------+
   592:S              | Send and return record layouts for request: Initialize A Volume      |
   593:D        1     +----------------------------------------------------------------------+}
   594:S          
   595:D        1    send_initialize = record
   596:D        1       send_mess_header        : send_header_type;
   597:D        1       volume_name_header      : volume_header_type;
   598:D        1       password                : name_type;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 11

   599:D        1       num_protect_code_sets   : integer;
   600:D        1       new_volume_name         : name_type;
   601:D        1       new_cat_organization    : name_type;
   602:D        1       sectors_per_block       : integer;
   603:D        1       format_media            : long_boolean;
   604:D        1       interleave_factor       : integer;
   605:D        1       filler3                 : gang_32bit_filler;
   606:D        1       physical_sector_size    : integer;
   607:D        1       new_password            : {global_}name_type;
   608:D        1       start_protect_code_sets : integer;
   609:D        1       init_root_password      : {global_}name_type;
   610:D        1    end;
   611:S          
   612:D        1    return_initialize = record
   613:D        1       return_mess_header : return_header_type
   614:D        1    end;
   615:S          
   616:S          
   617:S             {+----------------------------------------------------------------------+
   618:S              | Send and return record layouts for request: Lock A File              |
   619:D        1     +----------------------------------------------------------------------+}
   620:S          
   621:D        1    send_lockafile = record
   622:D        1       send_mess_header : send_header_type;
   623:D        1       file_id          : file_id_type;
   624:D        1       wait_for_lock    : long_boolean
   625:D        1    end;
   626:S          
   627:D        1    return_lockafile = record
   628:D        1       return_mess_header : return_header_type;
   629:D        1       success            : long_boolean
   630:D        1    end;
   631:S          
   632:S          
   633:S             {+----------------------------------------------------------------------+
   634:S              | Send and return record layouts for request: Open A File              |
   635:D        1     +----------------------------------------------------------------------+}
   636:S          
   637:D        1    send_openafile = record
   638:D        1       send_mess_header       : send_header_type;
   639:D        1       volume_name_header     : volume_header_type;
   640:D        1       file_name_header       : file_header_type;
   641:D        1       filler2                : integer;
   642:D        1       filler3                : integer;
   643:D        1       share_code             : integer;
   644:D        1       filler4                : owner_id_type;
   645:D        1       filler1                : gang_16bit_filler;
   646:D        1       open_type              : gang_open_type;
   647:D        1       start_name_sets        : integer
   648:D        1    end;
   649:S          
   650:D        1    return_openafile = record
   651:D        1       return_mess_header : return_header_type;
   652:D        1       file_id            : file_id_type;
   653:D        1       record_mode        : integer;
   654:D        1       max_record_size    : integer;
   655:D        1       max_file_size      : integer;
   656:D        1       file_code          : gang_file_codes;
   657:D        1       open_logical_eof   : integer;
   658:D        1       sharebits          : integer;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 12

   659:D        1       sec_ext_size       : integer;
   660:D        1       boot_start_address : integer;
   661:D        1    end;
   662:S          
   663:S          
   664:S             {+----------------------------------------------------------------------+
   665:S              | Send and return record layouts for request: Position To A Record     |
   666:D        1     +----------------------------------------------------------------------+}
   667:S          
   668:D        1    send_positiontoarecord = record
   669:D        1       send_mess_header : send_header_type;
   670:D        1       implicit_unlock  : long_boolean;
   671:D        1       file_id          : file_id_type;
   672:D        1       filler3          : gang_16bit_filler;
   673:D        1       type_of_position : position_type;
   674:D        1       byte_offset      : integer
   675:D        1    end;
   676:S          
   677:D        1    return_positiontoarecord = record
   678:D        1       return_mess_header : return_header_type
   679:D        1    end;
   680:S          
   681:S          
   682:S             {+----------------------------------------------------------------------+
   683:S              | Send and return record layouts for request: Purge Link               |
   684:D        1     +----------------------------------------------------------------------+}
   685:S          
   686:D        1    send_purgelink = record
   687:D        1       send_mess_header   : send_header_type;
   688:D        1       volume_name_header : volume_header_type;
   689:D        1       file_name_header   : file_header_type;
   690:D        1       start_name_sets    : integer
   691:D        1    end;
   692:S          
   693:D        1    return_purgelink = record
   694:D        1       return_mess_header : return_header_type
   695:D        1    end;
   696:S          
   697:S          
   698:S             {+----------------------------------------------------------------------+
   699:S              | Send and return record layouts for request:  Read A Record           |
   700:D        1     +----------------------------------------------------------------------+}
   701:S          
   702:D        1    send_readarecord = record
   703:D        1       send_mess_header  : send_header_type;
   704:D        1       implicit_unlock   : long_boolean;
   705:D        1       file_id           : file_id_type;
   706:D        1       access_code       : integer;
   707:D        1       filler3           : array [1..2] of gang_32bit_filler;
   708:D        1       requested         : integer;
   709:D        1       offset            : integer
   710:D        1    end;
   711:S          
   712:D        1    return_readarecord = record
   713:D        1       return_mess_header  : return_header_type;
   714:D        1       actual              : integer;
   715:D        1       filler1             : array [1..4] of gang_32bit_filler;
   716:D        1       data                : packed array[1..512] of char;
   717:D        1    end;
   718:S          
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 13

   719:S          
   720:S             {+----------------------------------------------------------------------+
   721:S              | Send and return record layouts for request: Set Date                 |
   722:D        1     +----------------------------------------------------------------------+}
   723:S          
   724:D        1    send_set_date = record
   725:D        1       send_mess_header : send_header_type;
   726:D        1       implicit_unlock  : long_boolean;
   727:D        1       file_id          : file_id_type;
   728:D        1       set_access_date  : long_boolean;
   729:D        1       access_date      : date_type;
   730:D        1       set_creation_date: long_boolean;
   731:D        1       creation_date    : date_type
   732:D        1    end;
   733:S          
   734:D        1    return_set_date = record
   735:D        1       return_mess_header : return_header_type
   736:D        1    end;
   737:S          
   738:S          
   739:S             {+----------------------------------------------------------------------+
   740:S              | Send and return record layouts for request: Set Eof                  |
   741:D        1     +----------------------------------------------------------------------+}
   742:S          
   743:D        1    send_set_eof = record
   744:D        1       send_mess_header : send_header_type;
   745:D        1       implicit_unlock  : long_boolean;
   746:D        1       file_id          : file_id_type;
   747:D        1       use_current_ptr  : long_boolean;
   748:D        1       byte_offset      : integer
   749:D        1    end;
   750:S          
   751:D        1    return_set_eof = record
   752:D        1       return_mess_header : return_header_type
   753:D        1    end;
   754:S          
   755:S          
   756:S             {+----------------------------------------------------------------------+
   757:S              | Send and return record layouts for request: Unlock A File            |
   758:D        1     +----------------------------------------------------------------------+}
   759:S          
   760:D        1    send_unlockafile = record
   761:D        1       send_mess_header : send_header_type;
   762:D        1       file_id          : file_id_type;
   763:D        1       explicit_unlock  : long_boolean;
   764:D        1    end;
   765:S          
   766:D        1    return_unlockafile = record
   767:D        1       return_mess_header : return_header_type;
   768:D        1    end;
   769:S          
   770:S          
   771:S             {+----------------------------------------------------------------------+
   772:S              | Send and return record layouts for request: Volume Status            |
   773:D        1     +----------------------------------------------------------------------+}
   774:S          
   775:D        1    send_volume_status = record
   776:D        1       send_mess_header        : send_header_type;
   777:D        1       volume_name_header      : volume_header_type;
   778:D        1    end;
Pascal [Rev 3.0M  6/ 4/84] PACKETS.TEXT            28-Jun-89 17:45:42 Page 14

   779:S          
   780:D        1    return_volume_status = record
   781:D        1       return_mess_header   : return_header_type;
   782:D        1       exist                : long_boolean;
   783:D        1       interleave           : integer;
   784:D        1       volume_name          : name_type
   785:D        1    end;
   786:S          
   787:S          
   788:S             {+----------------------------------------------------------------------+
   789:S              | Send and return record layouts for request: Write A Record           |
   790:D        1     +----------------------------------------------------------------------+}
   791:S          
   792:D        1    send_writearecord = record
   793:D        1       send_mess_header  : send_header_type;
   794:D        1       implicit_unlock   : long_boolean;
   795:D        1       file_id           : file_id_type;
   796:D        1       access_code       : integer;
   797:D        1       filler3           : array [1..2] of gang_32bit_filler;
   798:D        1       requested         : integer;
   799:D        1       offset            : integer;
   800:D        1       filler8           : long_boolean;
   801:D        1       flush_buffer      : long_boolean;
   802:D        1       data              : packed array [1..512] of char
   803:D        1    end;
   804:S          
   805:D        1    return_writearecord = record
   806:D        1       return_mess_header  : return_header_type;
   807:D        1       actual              : integer;
   808:D        1    end;
   809:S          
   810:S          
   811:D        1 {^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^}
   812:S          
   813:D        1 $include 'PACKETS'$
   814:S          
   815:D        1 type
   816:D        1   ptrmp            = msg_packet_ptr;
   817:D        1   ptrsareyoualive  = ^send_are_you_alive;
   818:D        1   ptrrareyoualive  = ^return_are_you_alive;
   819:D        1   ptrscat          = ^send_catalogue;
   820:D        1   ptrrcat          = ^return_catalogue;
   821:D        1   ptrscatpass      = ^send_cat_passwords;
   822:D        1   ptrrcatpass      = ^return_cat_passwords;
   823:D        1   ptrschangeprotect= ^send_change_protect_codes;
   824:D        1   ptrrchangeprotect= ^return_change_protect_codes;
   825:D        1   ptrschangevolume = ^send_change_volume_label;
   826:D        1   ptrrchangevolume = ^return_change_volume_label;
   827:D        1   ptrsclose        = ^send_closeafile;
   828:D        1   ptrrclose        = ^return_closeafile;
   829:D        1   ptrscopy         = ^send_copy;
   830:D        1   ptrrcopy         = ^return_copy;
   831:D        1   ptrscreatefile   = ^send_createafile;
   832:D        1   ptrrcreatefile   = ^return_createafile;
   833:D        1   ptrscreatelink   = ^send_createlink;
   834:D        1   ptrrcreatelink   = ^return_createlink;
   835:D        1   ptrsexchange     = ^send_xchg_data;
   836:D        1   ptrrexchange     = ^return_xchg_data;
   837:D        1   ptrsfileinfo     = ^send_fileinfo;
   838:D        1   ptrrfileinfo     = ^return_fileinfo;
Pascal [Rev 3.0M  6/ 4/84] SRM_TYPES.TEXT          28-Jun-89 17:45:42 Page 15

   839:D        1   ptrsgangclean    = ^send_gang_cleanup;
   840:D        1   ptrrgangclean    = ^return_gang_cleanup;
   841:D        1   ptrsinit         = ^send_initialize;
   842:D        1   ptrrinit         = ^return_initialize;
   843:D        1   ptrslock         = ^send_lockafile;
   844:D        1   ptrrlock         = ^return_lockafile;
   845:D        1   ptrsopen         = ^send_openafile;
   846:D        1   ptrropen         = ^return_openafile;
   847:D        1   ptrspos          = ^send_positiontoarecord;
   848:D        1   ptrrpos          = ^return_positiontoarecord;
   849:D        1   ptrspurge        = ^send_purgelink;
   850:D        1   ptrrpurge        = ^return_purgelink;
   851:D        1   ptrsread         = ^send_readarecord;
   852:D        1   ptrrread         = ^return_readarecord;
   853:D        1   ptrssetdate      = ^send_set_date;
   854:D        1   ptrrsetdate      = ^return_set_date;
   855:D        1   ptrsseteof       = ^send_set_eof;
   856:D        1   ptrrseteof       = ^return_set_eof;
   857:D        1   ptrsunlock       = ^send_unlockafile;
   858:D        1   ptrrunlock       = ^return_unlockafile;
   859:D        1   ptrsvol          = ^send_volume_status;
   860:D        1   ptrrvol          = ^return_volume_status;
   861:D        1   ptrswrite        = ^send_writearecord;
   862:D        1   ptrrwrite        = ^return_writearecord;
   863:S          
   864:D        1   pk_ptr = record case integer of
   865:D        1               0 : (mp            : ptrmp);
   866:D        1               1 : (sareyoualive  : ptrsareyoualive);
   867:D        1               2 : (rareyoualive  : ptrrareyoualive);
   868:D        1               3 : (scat          : ptrscat);
   869:D        1               4 : (rcat          : ptrrcat);
   870:D        1               5 : (scatpass      : ptrscatpass);
   871:D        1               6 : (rcatpass      : ptrrcatpass);
   872:D        1               7 : (schangeprotect: ptrschangeprotect);
   873:D        1               8 : (rchangeprotect: ptrrchangeprotect);
   874:D        1               9 : (schangevolume : ptrschangevolume);
   875:D        1              10 : (rchangevolume : ptrrchangevolume);
   876:D        1              11 : (sclose        : ptrsclose);
   877:D        1              12 : (rclose        : ptrrclose);
   878:D        1              13 : (scopy         : ptrscopy);
   879:D        1              14 : (rcopy         : ptrrcopy);
   880:D        1              15 : (screatefile   : ptrscreatefile);
   881:D        1              16 : (rcreatefile   : ptrrcreatefile);
   882:D        1              17 : (screatelink   : ptrscreatelink);
   883:D        1              18 : (rcreatelink   : ptrrcreatelink);
   884:D        1              19 : (sexchange     : ptrsexchange);
   885:D        1              20 : (rexchange     : ptrrexchange);
   886:D        1              21 : (sfileinfo     : ptrsfileinfo);
   887:D        1              22 : (rfileinfo     : ptrrfileinfo);
   888:D        1              23 : (sgangclean    : ptrsgangclean);
   889:D        1              24 : (rgangclean    : ptrrgangclean);
   890:D        1              25 : (sinit         : ptrsinit);
   891:D        1              26 : (rinit         : ptrrinit);
   892:D        1              27 : (slock         : ptrslock);
   893:D        1              28 : (rlock         : ptrrlock);
   894:D        1              29 : (sopen         : ptrsopen);
   895:D        1              30 : (ropen         : ptrropen);
   896:D        1              31 : (spos          : ptrspos);
   897:D        1              32 : (rpos          : ptrrpos);
   898:D        1              33 : (spurge        : ptrspurge);
Pascal [Rev 3.0M  6/ 4/84] SRM_TYPES.TEXT          28-Jun-89 17:45:42 Page 16

   899:D        1              34 : (rpurge        : ptrrpurge);
   900:D        1              35 : (sread         : ptrsread);
   901:D        1              36 : (rread         : ptrrread);
   902:D        1              37 : (ssetdate      : ptrssetdate);
   903:D        1              38 : (rsetdate      : ptrrsetdate);
   904:D        1              39 : (sseteof       : ptrsseteof);
   905:D        1              40 : (rseteof       : ptrrseteof);
   906:D        1              41 : (sunlock       : ptrsunlock);
   907:D        1              42 : (runlock       : ptrrunlock);
   908:D        1              43 : (svol          : ptrsvol);
   909:D        1              44 : (rvol          : ptrrvol);
   910:D        1              45 : (swrite        : ptrswrite);
   911:D        1              46 : (rwrite        : ptrrwrite);
   912:D        1            end;
   913:S          
   914:D        1   name_set_array= array [1..6] of
   915:D        1                     file_name_set;
   916:D        1   pnsa          = ^name_set_array;
   917:S          
   918:D        1   protectcode_set_array = array [1..10] of
   919:D        1                     protect_code_set;
   920:D        1   ppsa          = ^protectcode_set_array;
   921:S          
   922:D        1 $include 'SRM_TYPES'$
   922:D        1 $include 'ERRORS'$
   923:D        1 (*  sccs info:  @(#)  errors  8.1  84/05/04  00:20:53  *)
   924:S          
   925:D        1 {vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv}
   926:S          
   927:D        1 CONST ios_error_base = 31000;
   928:D        1      ios_software_bug                    = 31000;
   929:D        1      ios_bad_select_code                 = 31001;
   930:D        1      ios_unallocated_extent              = 31002;
   931:D        1      ios_ds_rom_missing                  = 31003;
   932:D        1      ios_unsupported_dam                 = 31004;
   933:D        1      ios_device_drivers_dont_match       = 31005;
   934:D        1      ios_invalid_ios_request             = 31006;
   935:D        1      ios_attach_table_full               = 31007;
   936:D        1      ios_improper_mass_storage_device    = 31008;
   937:D        1      ios_directory_formats_dont_match    = 31009;
   938:D        1      ios_invalid_file_size               = 31010;
   939:D        1      ios_invalid_file_id                 = 31011;
   940:D        1      ios_volume_recoverable_error        = 31012;
   941:D        1      ios_volume_io_error                 = 31013;
   942:D        1      ios_file_pathname_missing           = 31014;
   943:D        1      ios_illegal_byte_number             = 31015;
   944:D        1      ios_corrupt_directory               = 31016;
   945:D        1      ios_successful_completion           = 31017;
   946:D        1      ios_system_down                     = 31018;
   947:D        1      ios_file_unopened                   = 31019;
   948:D        1      ios_volume_offline                  = 31020;
   949:D        1      ios_volume_labels_dont_match        = 31021;
   950:D        1      ios_password_not_allowed            = 31022;
   951:D        1      ios_access_to_file_not_allowed      = 31023;
   952:D        1      ios_unsupported_directory_operation = 31024;
   953:D        1      ios_conflicting_share_modes         = 31025;
   954:D        1      ios_bad_file_name                   = 31026;
   955:D        1      ios_file_in_use                     = 31027;
   956:D        1      ios_insufficient_disk_space         = 31028;
   957:D        1      ios_duplicate_filenames             = 31029;
Pascal [Rev 3.0M  6/ 4/84] ERRORS.TEXT             28-Jun-89 17:45:42 Page 17

   958:D        1      ios_phys_eof_encountered            = 31030;
   959:D        1      ios_no_capability_for_file          = 31031;
   960:D        1      ios_file_not_found                  = 31032;
   961:D        1      ios_volume_in_use                   = 31033;
   962:D        1      ios_file_not_directory              = 31034;
   963:D        1      ios_directory_not_empty             = 31035;
   964:D        1      ios_volume_not_found                = 31036;
   965:D        1      ios_invalid_protect_code            = 31037;
   966:D        1      ios_volume_unrecoverable_error      = 31038;
   967:D        1      ios_password_not_found              = 31039;
   968:D        1      ios_duplicate_passwords             = 31040;
   969:D        1      ios_deadlock_detected               = 31041;
   970:D        1      ios_link_to_directory_not_allowed   = 31042;
   971:D        1      ios_rename_across_volumes           = 31043;
   972:D        1      ios_volume_down                     = 31044;
   973:D        1      ios_eof_encountered                 = 31045;
   974:D        1      ios_invalid_file_code               = 31046;
   975:D        1      ios_file_locked_please_retry        = 31047;
   976:D        1      ios_no_reply                        = 31048;
   977:D        1      ios_purge_on_open                   = 31049;
   978:S          
   979:D        1      ios_error_top                       = 31049;
   980:D        1      { Dave Hendricks' errors start at 31050 }
   981:S          
   982:D        1 { System escapes }
   983:S          
   984:D        1      sysesc_stack_overflow               = 22;
   985:D        1      sysesc_normal_program_termination   = 23;
   986:D        1      sysesc_integer_overflow             = 24;
   987:D        1      sysesc_divide_by_zero               = 25;
   988:D        1      sysesc_case_statement_error         = 26;
   989:D        1      sysesc_value_subscrpt_range_err     = 27;
   990:D        1      sysesc_real_overflow                = 28;
   991:D        1      sysesc_real_underflow               = 29;
   992:D        1      sysesc_NIL_pointer_reference        = 30;
   993:S          
   994:D        1      sysesc_bus_error                    = 40;
   995:D        1      sysesc_address_error                = 41;
   996:D        1      sysesc_illegal_instruction          = 42;
   997:D        1      sysesc_hardware_divide_by_zero      = 43;
   998:D        1      sysesc_CHK_instruction              = 44;
   999:D        1      sysesc_TRAPV_integer_overflow       = 45;
  1000:D        1      sysesc_privilege_violation          = 46;
  1001:S          
  1002:D        1      sysesc_1010_opcode                  = 48;
  1003:D        1      sysesc_1111_opcode                  = 49;
  1004:S          
  1005:D        1 { HP-IB driver escapes }
  1006:S          
  1007:D        1      HPIB_min                            = 29001;
  1008:D        1      HPIB_max                            = 29017;
  1009:S          
  1010:D        1      HPIB_wait_timeout                   = 29001;
  1011:D        1      HPIB_DMA_failure                    = 29002;
  1012:D        1      HPIB_SRQ_read_error                 = 29003;
  1013:D        1      HPIB_Powerfail                      = 29004;
  1014:D        1      HPIB_Parityerror                    = 29005;
  1015:D        1      HPIB_Paperout                       = 29006;
  1016:D        1      HPIB_Notready                       = 29007;
  1017:D        1      HPIB_Notonline                      = 29008;
Pascal [Rev 3.0M  6/ 4/84] ERRORS.TEXT             28-Jun-89 17:45:42 Page 18

  1018:D        1      HPIB_Bus_error                      = 29009;
  1019:D        1      HPIB_Bad_status                     = 29010;
  1020:D        1      HPIB_MechError                      = 29011;
  1021:D        1      HPIB_Testfail                       = 29012;
  1022:D        1      HPIB_DMA_timeout                    = 29013;
  1023:D        1      HPIB_Printer_fault                  = 29014;
  1024:D        1      HPIB_Wrong_file_type                = 29015;
  1025:D        1      HPIB_Illegal_device                 = 29016;
  1026:D        1      HPIB_no_DMA                         = 29017;
  1027:S          
  1028:D        1 { Theodore card driver escapes }
  1029:S          
  1030:D        1      Theo_too_many_chars_without_term    = 304;
  1031:D        1      Theo_interface_card_selftest_failed = 306;
  1032:D        1      Theo_USART_receive_buffer_overflow  = 313;
  1033:D        1      Theo_receive_buffer_overflow        = 314;
  1034:D        1      Theo_missing_clock                  = 315;
  1035:D        1      Theo_CTS_false_too_long             = 316;
  1036:D        1      Theo_register_address_out_of_range  = 326;
  1037:D        1      Theo_register_value_out_of_range    = 327;
  1038:D        1      Theo_USART_transmit_underrun        = 328;
  1039:D        1      Theo_Data_link_failure              = 353;
  1040:D        1      Theo_cant_send_bad_packet           = 394;
  1041:D        1      Theo_card_lunched_after_powerup     = 395;
  1042:D        1      Theo_operation_timed_out            = 396;
  1043:D        1      Theo_unknown_cmd_BUSY_WAIT_or_READ  = 397;
  1044:D        1      Theo_wrong_interrupt_level          = 398;
  1045:D        1      Theo_no_teddy_card_at_selectcode    = 399;
  1046:S          
  1047:S           { Other I/O escapes ]
  1048:S          
  1049:S               DISCKIO___timeout                   = 4;
  1050:S               INITVECTS_stop_key_hit              = 8;
  1051:S               NEWUNITIO_no_such_unit_on_line      = 9;
  1052:S               NEWFILES__bad_unit_number           = 11;
  1053:S               HARDDISK__block_num_out_of_range    = 15;
  1054:S               HARDDISK__bad_device_designator     = 16;
  1055:S               DISCKIO___disc_write_protected      = 18;
  1056:S               DISCKIO___hardware_failed           = 20;
  1057:S               HARDDISK__hardware_failure          = 20;
  1058:S          
  1059:D        1  { Gangsys errors }
  1060:S          
  1061:D        1      gang_bad_request_type               = 20001;
  1062:D        1      gang_bad_access_code                = 20004;
  1063:D        1      gang_parse_error                    = 20005;
  1064:S          
  1065:D        1 { IOP errors - range 55-79 }
  1066:S          
  1067:D        1 { buffer manager errors  }
  1068:S          
  1069:D        1      task_out_of_tcbs                    = 1000;
  1070:D        1      buf_cannot_find_a_buffer            = 10008;
  1071:S          
  1072:D        1 { DDM errors }
  1073:S          
  1074:D        1      ddm_errs_start                      = 80;
  1075:D        1      ddm_device_not_ready                = 80;
  1076:D        1      ddm_media_writeprotected            = 81;
  1077:D        1      ddm_media_misload                   = 82;
Pascal [Rev 3.0M  6/ 4/84] ERRORS.TEXT             28-Jun-89 17:45:42 Page 19

  1078:D        1      ddm_format_not_enabled              = 83;
  1079:D        1      ddm_data_error                      = 84;
  1080:D        1      ddm_phys_rec_not_found              = 85;
  1081:D        1      ddm_verification_failure            = 86;
  1082:D        1      ddm_possible_media_change           = 88;
  1083:D        1      ddm_internal_use_only               = 89;
  1084:D        1      ddm_software_bug                    = 90;
  1085:D        1      ddm_unknown_error                   = 91;
  1086:D        1      ddm_access_unsafe                   = 94;
  1087:D        1      ddm_bad_sense_control_type          = 95;
  1088:D        1      ddm_term_mode_not_supported         = 97;
  1089:D        1      ddm_eoi_requires_data               = 98;
  1090:D        1      ddm_driver_not_opened               = 99;
  1091:D        1      ddm_illegal_phys_rec_num            = 100;
  1092:D        1      ddm_illegal_phys_rec_size           = 101;
  1093:D        1      ddm_illegal_transfer_type           = 102;
  1094:D        1      ddm_driver_is_locked                = 103;
  1095:D        1      ddm_bad_interleave                  = 109;
  1096:D        1      ddm_bad_subaddress                  = 110;
  1097:D        1      ddm_disc_too_big                    = 111;
  1098:D        1      ddm_illegal_register_access         = 112;
  1099:D        1      ddm_tct_not_last_byte               = 113;
  1100:D        1      ddm_unsupported_operation           = 114;
  1101:D        1      ddm_id_no_driver_available          = 115;
  1102:D        1      ddm_id_no_interface_present         = 116;
  1103:D        1      ddm_verify_not_supported            = 117;
  1104:D        1      ddm_transfer_not_supported          = 118;
  1105:D        1      ddm_illegal_register_value          = 119;
  1106:D        1      ddm_beginning_of_tape               = 123;
  1107:D        1      ddm_can_not_be_active_controller    = 124;
  1108:D        1      ddm_data_overrun                    = 125;
  1109:D        1      ddm_device_error                    = 126;
  1110:D        1      ddm_device_not_present              = 127;
  1111:D        1      ddm_end_of_tape                     = 128;
  1112:D        1      ddm_failed_diagnostic               = 129;
  1113:D        1      ddm_hpib_too_slow                   = 130;
  1114:D        1      ddm_end_of_file                     = 131;
  1115:D        1      ddm_device_busy                     = 132;
  1116:D        1      ddm_media_absent                    = 133;
  1117:D        1      ddm_media_not_formatted             = 134;
  1118:D        1      ddm_media_unformattable             = 135;
  1119:D        1      ddm_no_spares_left                  = 136;
  1120:D        1      ddm_not_active_controller           = 137;
  1121:D        1      ddm_not_system_controller           = 138;
  1122:D        1      ddm_tape_runaway                    = 139;
  1123:D        1      ddm_excess_data_lost                = 140;
  1124:D        1      ddm_wrong_type_of_media             = 141;
  1125:D        1      ddm_media_fault                     = 142;
  1126:D        1      ddm_not_addressed                   = 143;
  1127:D        1      ddm_data_xfer_abort                 = 144;
  1128:D        1      ddm_write_incomplete                = 145;
  1129:D        1      ddm_read_incomplete                 = 146;
  1130:D        1      ddm_controller_or_unit_fault        = 147;
  1131:D        1      ddm_status_transaction_error        = 148;
  1132:D        1      ddm_interface_timeout               = 149;
  1133:D        1      ddm_no_dma_card                     = 150;
  1134:D        1      ddm_disc_interface_not_present      = 151;
  1135:D        1      ddm_disc_intfc_at_wrong_int_lvl     = 152;
  1136:D        1      ddm_errs_end                        = 152;
  1137:S          
Pascal [Rev 3.0M  6/ 4/84] ERRORS.TEXT             28-Jun-89 17:45:42 Page 20

  1138:S          { memory manager errors: ]
  1139:S          
  1140:S               mem_insufficient_memory             = 7000;
  1141:S               mem_memory_overflow                 = 7001;
  1142:S               mem_apartition_overflow             = 7002;
  1143:S               mem_st_overflow                     = 7003;
  1144:S               mem_block_overflow                  = 7004;
  1145:S               mem_avail_pt_overflow               = 7005;
  1146:S               mem_invalid_segment_number          = 7006;
  1147:S               mem_segment_size_invalid            = 7007;
  1148:S               mem_segment_map_corruption          = 7008;
  1149:S               mem_blk_map_corruption              = 7009;
  1150:S               mem_invalid_seg_address             = 7010;
  1151:S               mem_blk_not_allocated               = 7011;
  1152:S          
  1153:D        1 { Boot ROM mini driver errors: }
  1154:S          
  1155:D        1      Miniboot_INITIALIZE_failed          =    66;
  1156:D        1      Miniboot_no_medium                  =    80;
  1157:D        1      Miniboot_hardware_failure           =    81;
  1158:D        1      Miniboot_write_protected            =    83;
  1159:D        1      Miniboot_record_not_found           =    84;
  1160:D        1      Miniboot_record_address_error       =    87;
  1161:D        1      Miniboot_read_data_error            =    88;
  1162:D        1      Miniboot_mass_storage_sys_error     =    90;
  1163:D        1      Miniboot_not_srm_disc               =    99;
  1164:S          
  1165:S          
  1166:D        1 {^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^}
  1167:S          
  1168:D        1 $include 'ERRORS'$
  1169:S          
  1170:D        1 type
  1171:D        1   pointer       = ^char;
  1172:D        1   shortfilecode = packed record case boolean of
  1173:D        1                     false: (si                  : shortint);
  1174:D        1                     true:  (division_code       : 0..63;
  1175:D        1                             dcd_system_type     : 0..15;
  1176:D        1                             dcd_file_type       : 0..63);
  1177:D        1                   end;
  1178:D        1   type_device   = integer;
  1179:S          
  1180:D        1 const
  1181:D        1   startmsus     = msus_type[fmt : f7,
  1182:D        1                             dev : d1,
  1183:D        1                             un  : 8,
  1184:D        1                             sc  : 0,
  1185:D        1                             ba  : 0];
  1186:S          
  1187:D        1   defaultmsus   = msus_type[fmt : f7,
  1188:D        1                             dev : d1,
  1189:D        1                             un  : 8,
  1190:D        1                             sc  : 21,
  1191:D        1                             ba  : 0];
  1192:S          
  1193:S          
  1194:D        1 function init   : boolean;
  1195:S          
  1196:D        1 function fopen(var filename     : string255;
  1197:D        2                var x_adr        : integer;
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 21

  1198:D        2                var length       : integer;
  1199:D        2                var ftype        : shortfilecode) : boolean;
  1200:S          
  1201:D        1 procedure read(sector           : integer;
  1202:D        2                bytecount        : integer;
  1203:D        2                ramaddress       : pointer;
  1204:D        2                medium           : boolean);
  1205:S          
  1206:D        1 procedure fclose;
  1207:S          
  1208:D        1 function active1(bootpass       : shortint;
  1209:D        2                  doinit         : boolean;
  1210:D        2              var msus           : msus_type;
  1211:D        2              var msusvalid      : boolean;
  1212:D        2                  statepresent   : boolean) : boolean;
  1213:S          
  1214:D        1 function active2(bootpass       : shortint;
  1215:D        2                  doinit         : boolean;
  1216:D        2              var msus           : msus_type;
  1217:D        2              var msusvalid      : boolean;
  1218:D        2                  statepresent   : boolean) : boolean;
  1219:S          
  1220:D        1 function next_system(var filename       : string255) : boolean;
  1221:S          
  1222:D        1 implement
  1223:D        1 const
  1224:D        1   {size of buffer pointed at by farea^.mb_ptr}
  1225:D        1   mbptr_buffersize      = 200;  {must be at least 197}
  1226:S          
  1227:D        1   {offsets into buffer pointed at by farea^.mb_ptr}
  1228:D        1   offset_iotemp = 18;   {the boot rom will use first 18 bytes}
  1229:D        1   offset_packet = offset_iotemp + 34;
  1230:S          
  1231:D        1   {room for the name set array (nsa) is in fubuffer}
  1232:S          
  1233:D        1   {size of biggest "packet" that will be read from card into buffer}
  1234:D        1   maxpacketsize = mbptr_buffersize - (offset_packet + 9);
  1235:S          
  1236:D        1 (****************************************************************************)
  1237:S          
  1238:D        1 CONST
  1239:D        1       iominisc   = 0 ;                 { 0 - 7  internal }
  1240:D        1       iomaxisc   = 31;                 { 8 - 31 external 8..31 }
  1241:S          
  1242:D        1 TYPE
  1243:S          
  1244:D        1       { general declarations }
  1245:S          
  1246:D        1       type_isc        = iominisc..iomaxisc ;
  1247:D        1       io_byte         = 0..255 ;
  1248:D        1       io_word         = -32768..32767 ;
  1249:S          
  1250:D        1       { interface driver space }
  1251:S          
  1252:D        1       io_temp_type    = PACKED RECORD
  1253:D        1                           card_ptr  : ANYPTR ;
  1254:D        1                           timeout   : INTEGER ;                { in milliseconds }
  1255:D        1                           drv_misc  : ARRAY[1..26] OF CHAR ;
  1256:D        1                         END;
  1257:S          
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 22

  1258:D        1       pio_temp        = ^io_temp_type;
  1259:S          
  1260:D        1 FUNCTION  ioread_byte ( io_temp    : pio_temp ;
  1261:D        2                         register   : io_word )
  1262:D        2                       : io_byte ;
  1263:D        2 TYPE mycharptr = ^CHAR;
  1264:C        2 BEGIN
  1265:C        2   ioread_byte:=ORD(mycharptr(ADDR(mycharptr(io_temp^.card_ptr)^,register))^);
  1266:C        2 END; { of ioread_word }
  1267:S          
  1268:D        1 FUNCTION  initialize  ( io_temp    : pio_temp ;
  1269:D        2                         io_isc     : type_isc )
  1270:D        2                       : BOOLEAN;
  1271:D    -4  2 VAR dc_dummy : INTEGER;
  1272:D    -8  2     dummy    : INTEGER;
  1273:C        2 BEGIN
  1274:S          
  1275:C        2   initialize := FALSE;
  1276:S          
  1277:C        2   if (f_area^.iocards[31-io_isc]) and (io_isc<32) then
  1278:C        3     begin
  1279:C        3       WITH io_temp^ DO BEGIN
  1280:C        4         card_ptr  := ANYPTR(HEX('600000')+((io_isc MOD 32)*65536));
  1281:C        4         FOR dummy:=1 TO sizeof(drv_misc) DO drv_misc[dummy]:=CHR(0);
  1282:C        4         dummy := ioread_byte(io_temp,1);
  1283:C        4         dummy := dummy MOD 128;       { mask off remote id bit }
  1284:S          
  1285:C        4         IF dummy=52
  1286:C        5           THEN BEGIN
  1287:C        5             dc_dummy := ioread_byte(io_temp,16395)*256+ioread_byte(io_temp,16393);
  1288:C        5             IF dc_dummy < 32768
  1289:C        6               THEN BEGIN
  1290:C        6                 dc_dummy := ioread_byte(io_temp,dc_dummy*2+1);
  1291:C        6                 IF ( (dc_dummy MOD 128)               = 1 ) AND
  1292:C        7                    ( ioread_byte(io_temp,HEX('402F')) = 3 )
  1293:C        7                   THEN BEGIN
  1294:C        7                     initialize := TRUE;
  1295:C        7                   END; { of IF }
  1296:C        6               END; { of IF }
  1297:C        5           END; { of IF }
  1298:S          
  1299:C        4       END; { of WITH DO BEGIN }
  1300:C        3     end;
  1301:S          
  1302:C        2 END; { of initialize }
  1303:S          
  1304:D        1 (****************************************************************************)
  1305:S          
  1306:D        1 procedure dsp_ri_error;
  1307:D        2 external;
  1308:S          
  1309:D        1 (*****************************************************************************)
  1310:D        1 procedure clean_gang(select_code:integer);
  1311:D        2    {Cleanup Ganglia card before passing escape along.}
  1312:D        2 var
  1313:D    -4  2   temp_escape   : integer;
  1314:D    -5  2   zilch         : boolean;
  1315:C        2 begin
  1316:C        2   temp_escape := escapecode; {Remember Current Escape Code.}
  1317:C        2   try {Reset Ganglia Card and Ignore Escapes From Ganglia Card Reset Routine.}
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 23

  1318:C        3     zilch := gang_reset(ANYPTR(HEX('600000')+((select_code MOD 32)*65536)));
  1319:C        3   recover;
  1320:C        2   escape(temp_escape); {Pass Original Escape Code Forward.}
  1321:C        2 end;
  1322:S          
  1323:D        1 (****************************************************************************)
  1324:S          
  1325:D        1 procedure packetout(selectcode  : type_device;
  1326:D        2                     node        : integer;
  1327:D        2                     basesize    : integer;
  1328:D        2                     nsasize     : integer;
  1329:D        2                     nsaptr      : anyptr);
  1330:D        2 var
  1331:D    -4  2   iotempptr     : pio_temp;
  1332:D    -8  2   packetptr     : ptrmp;
  1333:C        2 begin
  1334:C        2   with f_area^ do
  1335:C        3     begin
  1336:C        3       iotempptr := pio_temp(integer(mb_ptr)+offset_iotemp);
  1337:C        3       packetptr := ptrmp(integer(mb_ptr)+offset_packet);
  1338:C        3       if initialize(iotempptr,selectcode) then
  1339:C        4         try {Clean-up Card If This Escapes.}
  1340:C        5           begin
  1341:C        5             ptrmp(packetptr)^[8]  := chr(node);
  1342:C        5             ptrmp(packetptr)^[9]  := chr(0);
  1343:C        5             ptrmp(packetptr)^[10] := chr(0);
  1344:C        5             ptrmp(packetptr)^[11] := chr(0);
  1345:C        5             ptrmp(packetptr)^[12] := chr(7);
  1346:C        5             output_data(iotempptr,
  1347:C        5                         addr(ptrmp(packetptr)^[8]),
  1348:C        5                         basesize+5);
  1349:C        5             if nsasize > 0 then
  1350:C        6               output_data(iotempptr,nsaptr,nsasize);
  1351:C        5             output_end(iotempptr);
  1352:C        5           end;
  1353:C        5        recover clean_gang(selectcode);
  1354:C        3     end;
  1355:C        2 end;
  1356:D        1 (****************************************************************************)
  1357:S          
  1358:D        1 procedure packetin(selectcode   : type_device;
  1359:D        2                    sendreq      : integer);
  1360:D        2 var
  1361:D    -4  2   count         : integer;
  1362:D    -8  2   iotempptr     : pio_temp;
  1363:D   -12  2   packetptr     : ptrmp;
  1364:C        2 begin
  1365:C        2   with f_area^ do
  1366:C        3     begin
  1367:C        3       iotempptr := pio_temp(integer(mb_ptr)+offset_iotemp);
  1368:C        3       packetptr := ptrmp(integer(mb_ptr)+offset_packet);
  1369:C        3       if initialize(iotempptr,selectcode) then
  1370:C        4         with ptrrread(packetptr)^,
  1371:C        5              return_mess_header do
  1372:C        5           begin
  1373:C        5             try {Clean-up Card If This Escapes.}
  1374:C        6               repeat
  1375:C        7                 fillchar(linkfiller, 28, chr(0));
  1376:S          
  1377:C        7                 if sendreq <> req_read then
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 24

  1378:C        8                   begin
  1379:C        8                     count := maxpacketsize;
  1380:C        8                     enter_data(iotempptr,
  1381:C        8                                anyptr(integer(packetptr)+8),{addr(sourceaddr)}
  1382:C        8                                count);
  1383:C        8                   end
  1384:C        8                 else
  1385:C        8                   begin
  1386:C        8                     count := size_from_read + 4;
  1387:C        8                     enter_data(iotempptr,
  1388:C        8                                anyptr(integer(packetptr)+8),{addr(sourceaddr)}
  1389:C        8                                count);
  1390:S          
  1391:C        8                     if (return_request_type = -req_read)
  1392:C        9                     and (message_length > size_from_read) then
  1393:C        9                       begin
  1394:C        9                         count := actual;
  1395:C        9                         enter_data(iotempptr,
  1396:C        9                                    anyptr(user_sequencing_field),
  1397:C        9                                    count);
  1398:C        9                       end;
  1399:C        8                   end;
  1400:C        7               until return_request_type = -sendreq;
  1401:C        6             recover clean_gang(selectcode);
  1402:S          
  1403:C        5             if status <> 0 then
  1404:C        6               begin
  1405:C        6                 if (status - ios_error_base) in
  1406:C        7                    [ios_system_down      - ios_error_base,
  1407:C        7                     ios_volume_offline   - ios_error_base,
  1408:C        7                     ios_volume_not_found - ios_error_base,
  1409:C        7                     ios_volume_down      - ios_error_base]
  1410:C        7                       then escape(ec_no_device)
  1411:C        7                 else
  1412:C        7                 if (status - ios_error_base) in
  1413:C        8                    [ios_password_not_allowed           - ios_error_base,
  1414:C        8                     ios_access_to_file_not_allowed     - ios_error_base,
  1415:C        8                     ios_unsupported_directory_operation- ios_error_base,
  1416:C        8                     ios_conflicting_share_modes        - ios_error_base,
  1417:C        8                     ios_bad_file_name                  - ios_error_base,
  1418:C        8                     ios_file_in_use                    - ios_error_base,
  1419:C        8                     ios_phys_eof_encountered           - ios_error_base,
  1420:C        8                     ios_no_capability_for_file         - ios_error_base,
  1421:C        8                     ios_file_not_found                 - ios_error_base,
  1422:C        8                     ios_file_not_directory             - ios_error_base,
  1423:C        8                     ios_eof_encountered                - ios_error_base,
  1424:C        8                     ios_file_locked_please_retry       - ios_error_base]
  1425:C        8                       then escape(ec_read_error)
  1426:C        8                 else
  1427:C        8                   escape(ec_bad_error_state);
  1428:C        6               end;
  1429:C        5           end;
  1430:C        3     end;
  1431:C        2 end;
  1432:D        1 (****************************************************************************)
  1433:S          
  1434:D        1 procedure setup_smh(var smh     : send_header_type;
  1435:D        2                     ml,
  1436:D        2                     srt         : integer);
  1437:C        2 begin
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 25

  1438:C        2   with smh do
  1439:C        3     begin
  1440:C        3       message_length    := ml;
  1441:C        3       send_request_type := srt;
  1442:C        3       user_sequencing_field := 0;
  1443:C        3     end;
  1444:C        2 end;
  1445:D        1 (****************************************************************************)
  1446:S          
  1447:D        1 procedure setup_vnh(var vnh     : volume_header_type;
  1448:D        2                     ad1         : integer);
  1449:C        2 begin
  1450:C        2   with vnh do
  1451:C        3     begin
  1452:C        3       filler1                   := 0;
  1453:C        3       driver_name               := ' ';
  1454:C        3       catalogue_organization    := ' ';
  1455:C        3       device_address_present.i  := 1;   {true}
  1456:C        3       with device_address do
  1457:C        4         begin
  1458:C        4           address1              := ad1;{unit number}
  1459:C        4           haddress              := 0;
  1460:C        4           unit_num              := 0;
  1461:C        4           volume_num            := 0;
  1462:C        4         end;
  1463:C        3       volume_name := ' ';
  1464:C        3     end;
  1465:C        2 end;
  1466:D        1 (****************************************************************************)
  1467:S          
  1468:D        1 procedure setup_fnh(var fnh     : file_header_type;
  1469:D        2                     num         : integer);
  1470:C        2 begin
  1471:C        2   with fnh do
  1472:C        3     begin
  1473:C        3       num_file_name_sets := num;
  1474:C        3       working_directory  := 0;
  1475:C        3       filler1            := 0;
  1476:C        3       path_type          := start_root;
  1477:C        3       root_password      := ' ';
  1478:C        3     end;
  1479:C        2 end;
  1480:D        1 (****************************************************************************)
  1481:S          
  1482:D        1 function  parsename(var instring: string255;
  1483:D        2                     var nfns    : integer;
  1484:D        2                         nsaptr  : pnsa) : boolean;
  1485:D        2 var
  1486:D    -1  2   error         : boolean;
  1487:D    -2  2   namemode      : boolean;
  1488:D    -6  2   sindx         : integer;
  1489:D   -10  2   indx          : integer;
  1490:C        2 begin
  1491:C        2   error := strlen(instring) = 0;
  1492:S          
  1493:C        2   if not error then
  1494:C        3     begin
  1495:C        3       if instring[strlen(instring)] = '/' then
  1496:C        4         error := true
  1497:C        4       else
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 26

  1498:C        4         begin
  1499:C        4           if instring[1] = '/' then
  1500:C        5             begin
  1501:C        5               nfns      := 1;
  1502:C        5               sindx     := 2;
  1503:C        5             end
  1504:C        5           else
  1505:C        5             begin                               {default path name}
  1506:C        5               nsaptr^[1].file_name      := 'SYSTEMS';
  1507:C        5               nsaptr^[1].password       := ' ';
  1508:C        5               nfns                      := 2;
  1509:C        5               sindx                     := 1;
  1510:C        5             end;
  1511:C        4           namemode := true;
  1512:C        4           nsaptr^[nfns].file_name       := ' ';
  1513:C        4           nsaptr^[nfns].password        := ' ';
  1514:C        4           indx                          := 1;
  1515:C        4         end;
  1516:C        3     end;
  1517:S          
  1518:C        2   while (sindx <= strlen(instring)) and (not error) do
  1519:C        3     begin
  1520:C        3       if namemode then
  1521:C        4         begin
  1522:C        4           if instring[sindx] = '/' then
  1523:C        5             begin
  1524:C        5               nfns := nfns + 1;
  1525:C        5               nsaptr^[nfns].file_name := ' ';
  1526:C        5               nsaptr^[nfns].password  := ' ';
  1527:C        5               indx := 1;
  1528:C        5             end
  1529:C        5           else if instring[sindx] = '<' then
  1530:C        6             begin
  1531:C        6               namemode := false;
  1532:C        6               indx := 1;
  1533:C        6             end
  1534:C        6           else if indx < 17 then
  1535:C        7             begin
  1536:C        7               nsaptr^[nfns].file_name[indx] := instring[sindx];
  1537:C        7               indx  := indx + 1;
  1538:C        7             end
  1539:C        7           else
  1540:C        7             error := true;
  1541:C        4         end
  1542:C        4       else
  1543:C        4         begin
  1544:C        4           if instring[sindx] = '/' then
  1545:C        5             error := true
  1546:C        5           else if instring[sindx] = '>' then
  1547:C        6             begin
  1548:C        6               sindx := sindx + 1;
  1549:C        6               if sindx <= strlen(instring) then
  1550:C        7                 begin
  1551:C        7                   if (instring[sindx] <> '/') then
  1552:C        8                     error := true
  1553:C        8                   else
  1554:C        8                     begin
  1555:C        8                       namemode := true;
  1556:C        8                       nfns := nfns + 1;
  1557:C        8                       nsaptr^[nfns].file_name := ' ';
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 27

  1558:C        8                       nsaptr^[nfns].password  := ' ';
  1559:C        8                       indx := 1;
  1560:C        8                     end;
  1561:C        7                 end;
  1562:C        6             end
  1563:C        6           else if indx < 17 then
  1564:C        7             begin
  1565:C        7               nsaptr^[nfns].password[indx] := instring[sindx];
  1566:C        7               indx  := indx + 1;
  1567:C        7             end
  1568:C        7           else
  1569:C        7             error := true;
  1570:C        4         end;
  1571:C        3       sindx := sindx + 1;
  1572:C        3     end;
  1573:C        2   parsename := not error;
  1574:C        2 end;
  1575:D        1 (****************************************************************************)
  1576:S          
  1577:D        1 procedure catpack(selectcode    : type_device;
  1578:D        2                   node          : integer;
  1579:D        2                   nfns          : integer;
  1580:D        2                   nsaptr        : pnsa;
  1581:D        2                   un            : integer;
  1582:D        2                   indx          : integer);
  1583:D        2 var
  1584:D    -4  2   nsasize       : integer;
  1585:C        2 begin
  1586:C        2   with ptrscat(integer(f_area^.mb_ptr)+offset_packet)^ do
  1587:C        3     begin
  1588:C        3       nsasize   := nfns*36;
  1589:S          
  1590:C        3       setup_smh(send_mess_header,
  1591:C        3                 size_to_cat+nsasize,
  1592:C        3                 req_catalog);
  1593:S          
  1594:C        3       max_num_files := 1;
  1595:C        3       file_index    := indx;
  1596:C        3       filler1       := 0;
  1597:S          
  1598:C        3       setup_vnh(volume_name_header,
  1599:C        3                 un);
  1600:S          
  1601:C        3       filler2 := 0;
  1602:S          
  1603:C        3       setup_fnh(file_name_header,
  1604:C        3                 nfns);
  1605:C        3     end;
  1606:C        2   packetout(selectcode,node,size_to_cat,nsasize,nsaptr);
  1607:C        2   packetin(selectcode,req_catalog);
  1608:C        2 end;
  1609:D        1 (****************************************************************************)
  1610:S          
  1611:D        1 procedure gangcleanpack(selectcode      : type_device;
  1612:D        2                         node            : integer);
  1613:C        2 begin
  1614:C        2   with ptrsgangclean(integer(f_area^.mb_ptr)+offset_packet)^ do
  1615:C        3     begin
  1616:C        3       setup_smh(send_mess_header,
  1617:C        3                 size_to_gang_cleanup,
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 28

  1618:C        3                 req_gang_cleanup);
  1619:S          
  1620:C        3       keep_protected_directories.i := 0;
  1621:C        3     end;
  1622:S          
  1623:C        2   packetout(selectcode,node,size_to_gang_cleanup,0,nil);
  1624:C        2 end;
  1625:D        1 (****************************************************************************)
  1626:S          
  1627:D        1 procedure openpack(selectcode   : type_device;
  1628:D        2                    node         : integer;
  1629:D        2                    nfns         : integer;
  1630:D        2                    nsaptr       : pnsa;
  1631:D        2                    un           : integer);
  1632:D        2 var
  1633:D    -4  2   nsasize       : integer;
  1634:C        2 begin
  1635:C        2   with ptrsopen(integer(f_area^.mb_ptr)+offset_packet)^ do
  1636:C        3     begin
  1637:C        3       nsasize   := nfns*36;
  1638:S          
  1639:C        3       setup_smh(send_mess_header,
  1640:C        3                 size_to_open+nsasize,
  1641:C        3                 req_open);
  1642:S          
  1643:C        3       setup_vnh(volume_name_header,
  1644:C        3                 un);
  1645:S          
  1646:C        3       setup_fnh(file_name_header,
  1647:C        3                 nfns);
  1648:S          
  1649:C        3       filler2           := 0;
  1650:C        3       filler3           := 0;
  1651:C        3       share_code        := shared_share_code;
  1652:C        3       filler4.id        := 0;
  1653:C        3       filler1           := 0;
  1654:C        3       open_type         := open_data;
  1655:C        3     end;
  1656:S          
  1657:C        2   packetout(selectcode,node,size_to_open,nsasize,nsaptr);
  1658:C        2   packetin(selectcode,req_open);
  1659:C        2 end;
  1660:D        1 (****************************************************************************)
  1661:S          
  1662:D        1 procedure readpack(selectcode   : type_device;
  1663:D        2                    node         : integer;
  1664:D        2                    fid          : file_id_type;
  1665:D        2                    access       : integer;
  1666:D        2                    req          : integer;
  1667:D        2                    off          : integer;
  1668:D        2                    dat          : anyptr);
  1669:D        2 var
  1670:D    -4  2   packetptr     : ptrmp;
  1671:C        2 begin
  1672:C        2   with f_area^ do
  1673:C        3     begin
  1674:C        3       packetptr := ptrmp(integer(mb_ptr)+offset_packet);
  1675:C        3       with ptrsread(packetptr)^ do
  1676:C        4         begin
  1677:C        4           setup_smh(send_mess_header,
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 29

  1678:C        4                     size_to_read,
  1679:C        4                     req_read);
  1680:C        4           send_mess_header.user_sequencing_field := integer(dat);
  1681:S          
  1682:C        4           implicit_unlock.i := 1;
  1683:C        4           file_id           := fid;
  1684:C        4           access_code       := access;
  1685:C        4           filler3[1]        := 0;
  1686:C        4           filler3[2]        := 0;
  1687:C        4           requested         := req;
  1688:C        4           offset            := off;
  1689:C        4         end;
  1690:S          
  1691:C        3       packetout(selectcode,node,size_to_read,0,nil);
  1692:C        3     end;
  1693:C        2 end;
  1694:D        1 (****************************************************************************)
  1695:S          
  1696:D        1 procedure volpack(selectcode    : type_device;
  1697:D        2                   node          : integer;
  1698:D        2                   un            : integer);
  1699:C        2 begin
  1700:C        2   with ptrsvol(integer(f_area^.mb_ptr)+offset_packet)^ do
  1701:C        3     begin
  1702:C        3       setup_smh(send_mess_header,
  1703:C        3                 size_to_volstatus,
  1704:C        3                 req_volstatus);
  1705:S          
  1706:C        3       setup_vnh(volume_name_header,
  1707:C        3                 un);
  1708:C        3     end;
  1709:S          
  1710:C        2   packetout(selectcode,node,size_to_volstatus,0,nil);
  1711:C        2   packetin(selectcode,req_volstatus);
  1712:C        2 end;
  1713:S          
  1714:D        1 (*****************************************************************************)
  1715:D        1 function init : boolean;
  1716:D        2   {assumes f_area^.m_msus is set, and that mb_ptr is initialized}
  1717:D        2 type
  1718:D        2   srmnode       = ^boolean;
  1719:D        2 var
  1720:D    -4  2   iotempptr     : pio_temp;
  1721:D    -8  2   packetptr     : ptrmp;
  1722:C        2 begin
  1723:C        2   try
  1724:C        3     with f_area^ do
  1725:C        4       begin
  1726:C        4         iotempptr       := pio_temp(integer(mb_ptr)+offset_iotemp);
  1727:C        4         packetptr       := ptrmp(integer(mb_ptr)+offset_packet);
  1728:C        4         init            := false;
  1729:C        4         iotempptr^.timeout:=60000;  {Long Time-out since we know it's there.}
  1730:C        4         m_filesec       := 0;
  1731:C        4         m_dirent        := 0;
  1732:C        4         with m_msus do
  1733:C        5           if initialize(iotempptr,sc) then
  1734:C        6             with ptrrvol(packetptr)^ do
  1735:C        7             begin
  1736:C        7               if gang_reset(ANYPTR(HEX('600000')+((sc MOD 32)*65536))) then
  1737:C        8                 begin
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 30

  1738:C        8                   gangcleanpack(sc,ba);
  1739:C        8                   volpack(sc,ba,un);
  1740:C        8                   if (exist.value) and
  1741:C        9                      (return_mess_header.status=0) then
  1742:C        9                     begin
  1743:C        9                       init := true;
  1744:C        9                     end;
  1745:C        8                 end;
  1746:C        7             end;
  1747:C        4       end;
  1748:C        3   recover
  1749:C        3     begin
  1750:C        3       if not (escapecode in [ec_no_device, ec_no_medium]) then
  1751:C        4         escape(escapecode);
  1752:C        3     end;
  1753:C        2 end;
  1754:S          
  1755:D        1 (*****************************************************************************)
  1756:D        1 function fopen(var filename     : string255;
  1757:D        2                var x_adr        : integer;
  1758:D        2                var length       : integer;
  1759:D        2                var ftype        : shortfilecode) : boolean;
  1760:S          
  1761:D        2 var
  1762:D    -1  2   done          : boolean;
  1763:D    -2  2   match         : boolean;
  1764:D    -3  2   wildcard      : boolean;
  1765:D    -8  2   nfns          : integer;
  1766:D   -10  2   i             : byte;
  1767:D   -12  2   j             : byte;
  1768:D   -28  2   temp_file_name: name_type;
  1769:D   -32  2   packetptr     : ptrmp;
  1770:D   -36  2   nsaptr        : pnsa;
  1771:S          
  1772:D        2 procedure doopen;
  1773:C        3 begin
  1774:C        3   with f_area^, m_msus do
  1775:C        4     begin
  1776:C        4       openpack(sc,ba,nfns,nsaptr,un);
  1777:C        4       with ptrropen(packetptr)^ do
  1778:C        5         if (ftype.si = -1)
  1779:C        6           or (ftype.si = file_code.si2) then
  1780:C        6           begin
  1781:C        6             m_filesec     := file_id;
  1782:C        6             fopen         := true;
  1783:C        6             done          := true;
  1784:C        6             x_adr         := boot_start_address;
  1785:C        6             length        := open_logical_eof;
  1786:C        6             ftype.si      := file_code.si2;
  1787:C        6           end
  1788:C        6     end;
  1789:C        3 end;
  1790:S          
  1791:C        2 begin {fopen}
  1792:C        2   fopen := false;
  1793:C        2   fclose;
  1794:C        2   done := false;
  1795:C        2   with f_area^, m_msus do
  1796:C        3     begin
  1797:C        3       packetptr := ptrmp(integer(mb_ptr)+offset_packet);
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 31

  1798:C        3       nsaptr    := pnsa(addr(fubuffer));
  1799:C        3       if parsename(filename,nfns,nsaptr) then
***WARNING: (line 1800): STRPOS does not conform to HP standard, see $SWITCH_STRPOS$
  1800:C        4         if strpos(#0,filename) = 0 then
  1801:C        5           begin
  1802:C        5             try
  1803:C        6               doopen;
  1804:C        6             recover
  1805:C        6               if escapecode <> ec_read_error then
  1806:C        7                 escape(escapecode);
  1807:C        5           end
  1808:C        5         else
  1809:C        5           repeat
  1810:C        6             m_dirent    := m_dirent + 1;
  1811:C        6             try
  1812:C        7               catpack(sc,ba,nfns-1,nsaptr,un,m_dirent);
  1813:C        7               with ptrrcat(packetptr)^, cat_info[1] do
  1814:C        8                 if actual_num_files < 1 then
  1815:C        9                   done := true
  1816:C        9                 else
  1817:S                            { does this need to be done?  I don't think so.
  1818:S                            if record_mode = data_records then
  1819:C        9                   }
  1820:C        9                 if (ftype.si = -1)
  1821:C       10                   or (ftype.si = file_code.si2) then
  1822:C       10                     begin
  1823:C       10                       match   := true;
  1824:C       10                       wildcard:= false;
  1825:C       10                       for i := 1 to name_type_len do
  1826:C       11                         if not wildcard then
  1827:C       12                           if (nsaptr^[nfns].file_name[i] = chr(0)) then
  1828:C       13                             wildcard := true
  1829:C       13                           else
  1830:C       13                             if (nsaptr^[nfns].file_name[i]
  1831:C       14                                <> file_name[i]) then
  1832:C       14                                  match := false;
  1833:C       10                       if match then
  1834:C       11                         begin
  1835:C       11                           temp_file_name := nsaptr^[nfns].file_name;
  1836:C       11                           nsaptr^[nfns].file_name := file_name;
  1837:S          
  1838:C       11                           i := strlen(filename);
  1839:C       11                           repeat
  1840:C       12                             i := i - 1;
  1841:C       12                           until (filename[i] = '/') or (i=0);
  1842:C       11                           setstrlen(filename,i+name_type_len);
  1843:C       11                           for j := 1 to name_type_len do
  1844:C       12                             filename[i+j] := file_name[j];
  1845:S          
  1846:C       11                           try
  1847:C       12                             doopen;
  1848:C       12                           recover
  1849:C       12                             if escapecode <> ec_read_error then
  1850:C       13                               escape(escapecode)
  1851:C       13                             else
  1852:C       13                               nsaptr^[nfns].file_name := temp_file_name;
  1853:C       11                         end;
  1854:C       10                     end;
  1855:C        7             recover
  1856:C        7               if escapecode = ec_read_error then
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 32

  1857:C        8                 done := true
  1858:C        8               else
  1859:C        8                 escape(escapecode);
  1860:C        6           until done;
  1861:C        3     end;
  1862:C        2 end;
  1863:S          
  1864:D        1 (*****************************************************************************)
  1865:D        1 procedure read(sector           : integer;
  1866:D        2                bytecount        : integer;
  1867:D        2                ramaddress       : pointer;
  1868:D        2                medium           : boolean);
  1869:D        2 var
  1870:D    -4  2   sent          : integer;
  1871:D    -8  2   access        : integer;
  1872:D   -12  2   offset        : integer;
  1873:D   -16  2   packetptr     : ptrmp;
  1874:C        2 begin
  1875:C        2   with f_area^ do
  1876:C        3     begin
  1877:C        3       packetptr := ptrmp(integer(mb_ptr)+offset_packet);
  1878:C        3       if (not medium) and (m_filesec <> 0) then
  1879:C        4         begin
  1880:C        4           with m_msus, ptrrread(packetptr)^ do
  1881:C        5             begin
  1882:C        5               sent  := 0;
  1883:C        5               access := random_access;
  1884:C        5               offset := sector*256;
  1885:S          
  1886:C        5               if bytecount > 512 then
  1887:C        6                 begin
  1888:C        6                   readpack(sc,ba,m_filesec,access,512,offset,ramaddress);
  1889:C        6                   sent              := 512;
  1890:C        6                   ramaddress        := addr(ramaddress^,512);
  1891:C        6                   access := sequential_access;
  1892:C        6                   offset := 0;
  1893:S          
  1894:C        6                   while bytecount - sent > 512 do
  1895:C        7                     begin
  1896:C        7                       readpack(sc,ba,m_filesec,access,512,offset,ramaddress);
  1897:C        7                       sent      := sent + 512;
  1898:C        7                       ramaddress:= addr(ramaddress^,512);
  1899:C        7                       packetin(sc,req_read);
  1900:C        7                     end;
  1901:C        6                 end;
  1902:S          
  1903:C        5               readpack(sc,ba,m_filesec,access,bytecount-sent,offset,ramaddress);
  1904:C        5               packetin(sc,req_read);
  1905:S          
  1906:C        5               if bytecount > 512 then
  1907:C        6                 packetin(sc,req_read);
  1908:C        5             end;
  1909:C        4         end;
  1910:C        3     end;
  1911:C        2 end;
  1912:S          
  1913:D        1 (*****************************************************************************)
  1914:D        1 procedure fclose;
  1915:C        2 begin
  1916:C        2   with f_area^.m_msus do
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 33

  1917:C        3     gangcleanpack(sc,ba);
  1918:C        2 end;
  1919:S          
  1920:D        1 (*****************************************************************************)
  1921:D        1 function active1(bootpass       : shortint;
  1922:D        2                  doinit         : boolean;
  1923:D        2              var msus           : msus_type;
  1924:D        2              var msusvalid      : boolean;
  1925:D        2                  statepresent   : boolean) : boolean;
  1926:D        2 var
  1927:D    -1  2   dosearch      : boolean;
  1928:D    -6  2   iotempptr     : pio_temp;
  1929:D   -10  2   packetptr     : ptrmp;
  1930:C        2 begin
  1931:C        2   try
  1932:C        3     with f_area^, m_msus do
  1933:C        4       begin
  1934:C        4         iotempptr       := pio_temp(integer(mb_ptr)+offset_iotemp);
  1935:C        4         packetptr       := ptrmp(integer(mb_ptr)+offset_packet);
  1936:C        4         msusvalid     := false;
  1937:C        4         if doinit then
  1938:C        5           begin
  1939:C        5             m_msus    := defaultmsus;
  1940:C        5             if (bootpass = 1) and statepresent then
  1941:C        6               m_gscsearched.i  := 0;
  1942:C        5           end
  1943:C        5         else    {get next m_msus}
  1944:S                    m_msus := startmsus;  {Set MSUS to one that will cause active1
  1945:C        4                                  to return false next time it is called.}
  1946:S          
  1947:C        4         if initialize(iotempptr,sc) then
  1948:C        5           begin
  1949:C        5             dosearch := true;
  1950:C        5             if statepresent then
  1951:C        6               if m_gscsearched.f[sc] then
  1952:C        7                 dosearch := false;
  1953:C        5             if dosearch then
  1954:S                        if m_msus.int = defaultmsus.int then {Only Look at it m_msus is set to
  1955:C        7                                                     the high priority MSUS.}
  1956:C        7                   with ptrrvol(packetptr)^, return_mess_header do
  1957:C        8                     begin
  1958:C        8                       iotempptr^.timeout:=5000;
  1959:C        8                       gangcleanpack(sc,ba);
  1960:C        8                       volpack(sc,ba,un);
  1961:C        8                       if (status=0) and (exist.value) then
  1962:C        9                         begin
  1963:C        9                           msus          := m_msus;
  1964:C        9                           msusvalid     := init;
  1965:C        9                           if statepresent and msusvalid then
  1966:C       10                             m_gscsearched.f[sc] := true;
  1967:C        9                         end;
  1968:C        8                     end;
  1969:C        5           end;
  1970:C        4         active1 := msusvalid;
  1971:C        4       end;
  1972:C        3   recover
  1973:C        3     begin
  1974:C        3       active1 := false;
  1975:C        3       if not (escapecode in [ec_no_device, ec_no_medium]) then
  1976:C        4         dsp_ri_error;
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 34

  1977:C        3     end;
  1978:C        2 end;
  1979:S          
  1980:D        1 (*****************************************************************************)
  1981:D        1 function active2(bootpass       : shortint;
  1982:D        2                  doinit         : boolean;
  1983:D        2              var msus           : msus_type;
  1984:D        2              var msusvalid      : boolean;
  1985:D        2                  statepresent   : boolean) : boolean;
  1986:D        2 var
  1987:D    -1  2   dosearch      : boolean;
  1988:D    -6  2   iotempptr     : pio_temp;
  1989:D   -10  2   packetptr     : ptrmp;
  1990:C        2 begin
  1991:C        2   try
  1992:C        3     with f_area^, m_msus do
  1993:C        4       begin
  1994:C        4         iotempptr       := pio_temp(integer(mb_ptr)+offset_iotemp);
  1995:C        4         packetptr       := ptrmp(integer(mb_ptr)+offset_packet);
  1996:C        4         msusvalid               := false;
  1997:C        4         if doinit then
  1998:C        5           begin
  1999:C        5             m_msus              := startmsus;
  2000:C        5             m_b.mb_current      := false;
  2001:C        5             if (bootpass = 1) and statepresent then
  2002:C        6               m_gscsearched.i   := 0;
  2003:C        5           end;
  2004:S          
  2005:C        4         while (sc < 32) and not msusvalid do
  2006:C        5           begin
  2007:C        5             if doinit then
  2008:C        6               doinit := false
  2009:C        6             else        {get next m_msus}
  2010:C        6               if (m_b.mb_current) and (not m_nodearray.f[ba]) then
  2011:C        7                 un := 24;
  2012:C        5             if un < 24 then
  2013:C        6               begin
  2014:C        6                 if un = 8 then
  2015:C        7                   un := 7
  2016:C        7                 else if un = 7 then
  2017:C        8                   un := 9
  2018:C        8                 else
  2019:C        8                   un := un + 1;
  2020:C        6               end
  2021:C        6             else
  2022:C        6               begin
  2023:C        6                 un := 8;
  2024:C        6                 if ba < 64 then
  2025:C        7                   repeat
  2026:C        8                     ba := ba + 1;
  2027:C        8                   until (not m_b.mb_current) or (m_nodearray.f[ba]) or (ba > 63);
  2028:C        6                 if ba > 63 then
  2029:C        7                   begin
  2030:C        7                     if m_b.mb_current then
  2031:C        8                       if    (statepresent)
  2032:C        9                       and ((m_nodearray.i1 <> 0) or (m_nodearray.i2 <> 0)) then
  2033:C        9                         m_gscsearched.f[sc] := true;
  2034:C        7                     m_b.mb_current:= false;
  2035:C        7                     ba            := 0;
  2036:C        7                     un            := 8;
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 35

  2037:C        7                     repeat
  2038:C        8                       sc := sc + 1;
  2039:C        8                     until (initialize(iotempptr,sc)) or (sc > 31);
  2040:C        7                   end;
  2041:C        6               end;
  2042:S          
  2043:C        5             if initialize(iotempptr,sc) then
  2044:C        6               begin
  2045:C        6                 dosearch := true;
  2046:C        6                 if statepresent then
  2047:C        7                   if m_gscsearched.f[sc] then
  2048:C        8                     dosearch := false;
  2049:C        6                 if dosearch then
  2050:C        7                   begin
  2051:C        7                     if not m_b.mb_current then     {updatef_area^.m_nodearray for this select code}
  2052:C        8                       with ptrrvol(packetptr)^.return_mess_header.linkfiller do
  2053:C        9                         begin
  2054:C        9                           try
  2055:C       10                             m_nodearray.i1 := 0;
  2056:C       10                             m_nodearray.i2 := 0;
  2057:C       10                             m_b.mb_current := true;
  2058:C       10                             iotempptr^.timeout:=5000;
  2059:C       10                             gangcleanpack(sc,255);
  2060:C       10                             volpack(sc,255,un);
  2061:C       10                             m_nodearray.f[sourceaddr] := true;
  2062:C       10                             repeat
  2063:C       11                               packetin(sc,req_volstatus);
  2064:C       11                               m_nodearray.f[sourceaddr] := true;
  2065:C       11                             until false;
  2066:C       10                           recover
  2067:C       10                             if escapecode <> ec_no_device then
  2068:C       11                               escape(escapecode);
  2069:C        9                         end;
  2070:S                              { Look at it Only if there is a ganglia there and
  2071:C        7                       this is not the one looked at by active1. }
  2072:C        7                     if m_nodearray.f[ba]
  2073:C        8                       and (m_msus.int <> defaultmsus.int) then
  2074:C        8                       begin
  2075:C        8                         msus           := m_msus;
  2076:C        8                         msusvalid      := init;
  2077:C        8                       end;
  2078:C        7                   end;
  2079:C        6               end;
  2080:C        5           end;
  2081:C        4         active2 := msusvalid;
  2082:C        4       end;
  2083:C        3   recover
  2084:C        3     begin
  2085:C        3       active2 := false;
  2086:C        3       if not (escapecode in [ec_no_device, ec_no_medium]) then
  2087:C        4         dsp_ri_error;
  2088:C        3     end;
  2089:C        2 end;
  2090:S          
  2091:D        1 (*****************************************************************************)
  2092:D        1 function next_system(var filename       : string255) : boolean;
  2093:D        2 var
  2094:D        2   x,
  2095:D    -8  2   l             : integer;
  2096:D   -10  2   system        : shortfilecode;
Pascal [Rev 3.0M  6/ 4/84] BOOT_MOD.TEXT           28-Jun-89 17:45:42 Page 36

  2097:C        2 begin
  2098:C        2   try
  2099:C        3     system.si     := -5822;
  2100:C        3     next_system   := fopen(filename,x,l,system);
  2101:C        3     fclose;
  2102:C        3   recover
  2103:C        3     begin
  2104:C        3       next_system := false;
  2105:C        3       dsp_ri_error;
  2106:C        3     end;
  2107:C        2 end;
  2108:S          
  2109:C        1 end {module ganglia}.

No errors. 1 warnings.
               ***** Nonstandard language features enabled *****
