DataMuseum.dk

Presents historical artifacts from the history of:

Bogika Butler

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Bogika Butler

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download

⟦069bf1a10⟧ TextFile

    Length: 6272 (0x1880)
    Types: TextFile
    Names: »MCTYPE.BAK«

Derivation

└─⟦ec7c10e12⟧ Bits:30009789/_.ft.Ibm2.50007351.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »MCTYPE.BAK« 

TextFile

(******************************************************************************)
(*                                                                            *)
(*   MOTOROLA SPECIFIC DECLARATIONS                                           *)
(*                                                                            *)
(******************************************************************************)

   TYPE
      text_2 = ARRAY(.1..2.) OF char;
      text_4 = ARRAY(.1..4.) OF char;
      text_8 = ARRAY(.1..8.) OF char;
      byte_6 = ARRAY(.1..6.) OF byte;
      byte_8 = ARRAY(.1..8.) OF byte;

      long_base = (rx0, rx1, rx2, rx3);
      psn_type = ARRAY(.long_base.) OF byte;

   CONST
      null_psn: psn_type = (0,0,0,0);
      vid_psn:  psn_type = null_psn;

(******************************************************************************)
(*                                                                            *)
(*   MOTOROLA BLOCK FORMATS                                                   *)
(*                                                                            *)
(******************************************************************************)

   TYPE
      vid_type = RECORD
                    vol: text_4;     (* volume ascii identifier *)
                    usn: integer;    (* user number *)
                    sat: psn_type;   (* start of SAT *)
                    sal: integer;    (* length of SAT *)
                    sds: psn_type;   (* secondary directory start *)
                    pdl: psn_type;   (* primary directory PSN list start *)
                    residual: ARRAY (.1..236.) OF byte
                 END;

      sde_type = RECORD
                    usn: integer;    (* user number *)
                    clg: text_8;     (* catalog name *)
                    pdp: psn_type;   (* psn of first pdb for catalog
                                        (zero = empty entry) *)
                    aci,             (* reserved *)
                    rsi: byte;       (* reserved *)
                 END;

      sdb_type = RECORD
                    fpt: psn_type;   (* psn of next sdb (zero if none) *)
                    pad: ARRAY (.1..12.) OF byte;
                    sde: ARRAY (.1..15.) OF sde_type;
                 END;

      pde_type = RECORD
                    fil: text_8;     (* file name *)
                    ext: text_2;     (* extension *)
                    rsi: integer;    (* reserved *)
                    fs:  psn_type;   (* file starting PSN (contiguous) or
                                        first FAB pointer (noncontiguous) *)
                    fe:  psn_type;   (* physical EOF logical sector number
                                        (LSN) (contiguous) or last FAB pointer
                                        (noncontiguous) *)
                    eof: psn_type;   (* end of file LSN (zero if contiguous) *)
                    eor: psn_type;   (* end of file logical record number (LRN)
                                        (zero if ccontiguous) *)
                    wcd: byte;       (* write access code *)
                    rcd: byte;       (* read access code *)
                    att: byte;       (* file attributes *)
                    lbz: byte;       (* last data block size (zero if
                                        contiguous) = pde.dat *)
                    lrl: integer;    (* record size (zero if variable record
                                        length or contiguous) *)
                    rsz: byte;       (* reserved *)
                    key: byte;       (* key size (zero if null keys or non-
                                        indexed sequential access mode
                                        (non-ISAM) *)
                    fab: byte;       (* FAB size (zero if contiguous) *)
                    dat: byte;       (* data block size (zero if contiguous) *)
                    dtec: integer;   (* date file created or updated *)
                    dtea: integer;   (* last date file assigned *)
                    rs3: byte_8;     (* reserved *)
                 END;

      pdb_type = RECORD
                    fpt: psn_type;   (* PSN of next pdb (zero if none) *)
                    usn: text_2;     (* user number *)
                    clg: text_8;     (* catalog name *)
                    pad1: integer;   (* reserved *)
                    pde: ARRAY (.1..20.) OF pde_type;
                    pad2: byte_8;    (* zero filler to end of sector *)
                 END;

      fsd_type = RECORD
                    psn: psn_type;   (* PSN of data block start (zero if rest
                                        of FAB is empty *)
                    rec: integer;    (* number of records in data block *)
                    sgs: byte;       (* number of sectors in data block *)
                    key: byte;       (* key of last record in data block *)
                 END;

      fab_type = RECORD
                    flk: psn_type;   (* pointer to next FAB (zero if none) *)
                    blk: psn_type;   (* pointer to previous FAB (xero if
                                        none) *)
                    use: byte;       (* fraction of fab in use *)
                    pky: byte;       (* length of previous FAB's last key *)
                    fsd: ARRAY(.1..30.) OF fsd_type;
                    pad1: byte_6;    (* zero filler to end of sector *)
                 END;

      dab_type = ARRAY(.0..255.) OF byte;

(******************************************************************************)

      block_kind_type = (vid_tag, sdb_tag, pdb_tag, fab_tag, dab_tag);
      block_type = RECORD
                      CASE kind: block_kind_type OF
                         vid_tag:(vid: vid_type);
                         sdb_tag:(sdb: sdb_type);
                         pdb_tag:(pdb: pdb_type);
                         fab_tag:(fab: fab_type);
                         dab_tag:( db: dab_type);
                      END;
«eof»