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

⟦743450161⟧ TextFile

    Length: 13952 (0x3680)
    Types: TextFile
    Names: »LNKDF7.BAK«, »LNKDF7.PAS«

Derivation

└─⟦2079929d2⟧ Bits:30009789/_.ft.Ibm2.50006583.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »LNKDF7.PAS« 
└─⟦243948191⟧ Bits:30009789/_.ft.Ibm2.50007349.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »LNKDF7.PAS« 
└─⟦94d85ef43⟧ Bits:30009789/_.ft.Ibm2.50006584.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »LNKDF7.PAS« 
└─⟦da8d53b95⟧ Bits:30009789/_.ft.Ibm2.50006585.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »LNKDF7.PAS« 
└─⟦dbb5cfece⟧ Bits:30009789/_.ft.Ibm2.50007354.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »LNKDF7.BAK« 
    └─⟦this⟧ »LNKDF7.PAS« 

TextFile

(******************************************************************************)
(*                                                                            *)
(*   Copyright (1985) by Metanic Aps., Denmark                                *)
(*                                                                            *)
(*   Author: Lars Gregers Jakobsen.                                           *)
(*                                                                            *)
(******************************************************************************)


      PROCEDURE WriteSymbolName(VAR F: text
                               ;    SymbolName: SymbolNameType
                               ;    FieldSize: i8
                               );

         VAR
            I: i8;
            N: i8;

        BEGIN (*WRITESYMBOLNAME*)
         WITH SymbolName DO
           BEGIN
            IF Length < FieldSize THEN
               N := Length
            ELSE
               N := FieldSize;
            FOR I := 1 TO N DO
               IF Name(.I.) in (.32..127.) THEN
                  write(F, chr(Name(.I.)) );
            FOR I := N+1 TO FieldSize DO
               write(F, ' ');
           END
        END;  (*WRITESYMBOLNAME*)

      PROCEDURE LogInit(VAR LogFile: LogFileType
                       ;    FileName: FileNameType
                       );

        BEGIN (*LOGINIT*)
         WITH LogFile DO
           BEGIN
            assign(F, FileName);
            rewrite(F);
            P := 0;
            L := LogFilePageSize;
           END
        END;  (*LOGINIT*)

      PROCEDURE LogTerm(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGTERM*)
         WITH LogFile DO
           BEGIN
            close(F);
           END
        END;  (*LOGTERM*)

      FUNCTION LogFF(VAR LogFile: LogFileType
                    ;    Delta: LineNoType
                    ): boolean;

         CONST
            LogFFDelta = 5;

        BEGIN (*LOGFF*)
         WITH LogFile DO
            IF L >= LogFilePageSize - Delta THEN
              BEGIN
               LogFF := true;
               P := P + 1;
               L := LogFFDelta;
               page(F);
               writeln(F);
               writeln(F);
               writeln(F, ' ':LogMargin, 'LINKER '
                        , VersionNo, ' '
                        , ConfigurationNo
                        , ' ':30
                        , 'SIDE # ', P:2);
               writeln(F);
               writeln(F);
              END
            ELSE
               LogFF := false;
        END;  (*LOGFF*)

      PROCEDURE LogCmd(VAR LogFile: LogFileType
                      ;    CommandLine: CommandLineType
                      );

         CONST Delta = 5;

        BEGIN (*LOGCMD*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, Delta) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               writeln(F);
               writeln(F, ' ':LogMargin, 'AKTIVERINGSKOMMANDO: ');
               writeln(F);
               writeln(F, ' ':LogMargin, CommandLine);
               writeln(F);
              END
           END
        END;  (*LOGCMD*)

      PROCEDURE LogHSsgd(VAR LogFile: LogFileType
                        );

        BEGIN (*LOGHSSGD*)
         IF OptionTable.LogFileKind <> none THEN
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, 'SGM'
                        , ' ':2,         'ADRESSE':9
                        , ' ':2,         'STØRRELSE'
                        , ' ':2,         'MODUL'
                      );
               writeln(F);
              END
        END;  (*LOGHSSGD*)

      PROCEDURE LogHsgd(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHSGD*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 6) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 3;
               writeln(F);
               writeln(F, ' ':LogMargin, 'LOKALISERINGSPLAN:');
               writeln(F);
              END;
            LogHSsgd(LogFile);
           END;
        END;  (*LOGHSGD*)

      PROCEDURE LogSGD(VAR LogFile: LogFileType
                      ;    SegmentNo: RelocationIndicatorType
                      ;    StartAddress: FileAddressType
                      ;    Size: FileAddressType
                      ;    ModuleName: SymbolNameType
                      );

        BEGIN (*LOGSGD*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 1) THEN
               LogHSsgd(LogFile);
            WITH LogFile DO
              BEGIN
               L := L + 1;
               write(F, ' ':LogMargin, SegmentNo:3
                      , ' ':2,         StartAddress:9
                      , ' ':2,         Size:9
                      , ' ':2
                    );
               WriteSymbolName(F, ModuleName, 20);
               writeln(F);
              END;
           END
        END;  (*LOGSGD*)

      PROCEDURE LogHSxp(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHSXP*)
         IF OptionTable.LogFileKind <> none THEN
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, 'SGM'
                        , ' ':2,         'VÆRDI':9
                        , ' ':2,         'SYMBOL', ' ':14
                        , ' ':2,         'MODUL'
                      );
               writeln(F);
              END
        END;  (*LOGHSXP*)

      PROCEDURE LogHxpN(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHXPN*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 6) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 3;
               writeln(F);
               writeln(F, ' ':LogMargin, 'EXPORTEREDE SYMBOLER (NAVNEORDEN):');
               writeln(F);
              END;
            LogHSxp(LogFile);
           END
        END;  (*LOGHXPN*)

      PROCEDURE LogHxpV(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHXPV*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 6) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 3;
               writeln(F);
               writeln(F, ' ':LogMargin, 'EXPORTEREDE SYMBOLER (VÆRDIORDEN):');
               writeln(F);
              END;
            LogHSxp(LogFile);
           END
        END;  (*LOGHXPV*)

      PROCEDURE LogXP(VAR LogFile: LogFileType
                     ;    SegmentNo: RelocationIndicatorType
                     ;    Value: i32
                     ;    SymbolName: SymbolNameType
                     ;    ModuleName: ModuleNameType
                     );

        BEGIN (*LOGXP*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile,1) THEN
               LogHSxp(LogFile);
            WITH LogFile DO
              BEGIN
               L := L + 1;
               write(F, ' ':LogMargin, SegmentNo:3
                      , ' ':2,         Value:9
                      , ' ':2
                    );
               WriteSymbolName(F, SymbolName, 20);
               write(F, ' ':2);
               WriteSymbolName(F, ModuleName, 20);
               writeln(F);
              END
           END
        END;  (*LOGXP*)

      PROCEDURE LogHSurs(VAR LogFile: LogFileType
                        );

        BEGIN (*LOGHSURS*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin
                        , ' ':16,        'SYMBOL', ' ':14
                        , ' ':2,         'MODUL');
               writeln(F);
              END
           END
        END;  (*LOGHSURS*)

      PROCEDURE LogHurs(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHURS*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 6)THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 3;
               writeln(F);
               writeln(F, ' ':LogMargin, 'UTILFREDSSTILLEDE REFERENCER:');
               writeln(F);
              END;
            LogHSurs(LogFile);
           END
        END;  (*LOGHURS*)

      PROCEDURE LogURS(VAR LogFile: LogFileType
                      ;    ModuleName: ModuleNameType
                      ;    SymbolName: SymbolNameType
                      );

        BEGIN (*LOGURS*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 1) THEN
              LogHSurs(LogFile);
            WITH LogFile DO
              BEGIN
               L := L + 1;
               write(F, ' ':LogMargin
                      , ' ':16
                    );
               WriteSymbolName(F, SymbolName, 20);
               write(F, ' ':2);
               WriteSymbolName(F, ModuleName, 20);
               writeln(F);
              END
           END
        END;  (*LOGURS*)

      PROCEDURE LogHSdds(VAR LogFile: LogFileType
                        );

        BEGIN (*LOGHSDDS*)
         IF OptionTable.LogFileKind <> none THEN
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, 'SGM'
                        , ' ':2,         'VÆRDI':9
                        , ' ':2,         'SYMBOL', ' ':14
                        , ' ':2,         'MODUL'
                      );
               writeln(F);
              END;
        END;  (*LOGHSDDS*)

      PROCEDURE LogHdds(VAR LogFile: LogFileType
                       );

        BEGIN (*LOGHDDS*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 6) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F);
               writeln(F, ' ':LogMargin, 'DOBBELTDEFINEREDE SYMBOLER:');
               writeln(F);
              END;
             LogHSdds(LogFile);
            END
        END;  (*LOGHDDS*)

      PROCEDURE LogDDS(VAR LogFile: LogFileType
                      ;    RelocationIndicator: RelocationIndicatorType
                      ;    Value: i32
                      ;    SymbolName: SymbolNameType
                      ;    ModuleName: ModuleNameType
                      );

        BEGIN (*LOGDDS*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 1) THEN
               LogHSdds(LogFile);
            WITH LogFile DO
              BEGIN
               L := L + 1;
               write(F, ' ':LogMargin, ord(RelocationIndicator):3
                      , ' ':2,         Value:9
                      , ' ':2
                    );
               WriteSymbolName(F, SymbolName, 20);
               write(F, ' ':2);
               WriteSymbolName(F, ModuleName, 20);
               writeln(F);
              END
           END
        END;  (*LOGDDS*)

      PROCEDURE LogOFFerror(VAR LogFile: LogFileType
                           ;    FileNo: FileNameTableIndexType
                           );

        BEGIN (*LOGOFFERROR*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 2) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, '*** FILFORMATFEJL *** FIL # ', FileNo:1
                                , ' ***'
                      );
              END;
           END
        END;  (*LOGOFFERROR*)


      PROCEDURE LogOMFerror(VAR LogFile: LogFileType
                           ;    FileNo: FileNameTableIndexType
                           ;    Position: FileAddressType
                           );

        BEGIN (*LOGOMFERROR*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 2) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, '*** MODULFORMATFEJL *** FIL # ', FileNo:1
                               , ' *** POSITION # ', Position:1
                               , ' ***'
                      );
              END;
           END
        END;  (*LOGOMFERROR*)

      PROCEDURE LogEOFerror(VAR LogFile: LogFileType
                           ;    FileNo: FileNameTableIndexType
                           ;    Position: FileAddressType
                           );

        BEGIN (*LOGEOFERROR*)
         IF OptionTable.LogFileKind <> none THEN
           BEGIN
            IF LogFF(LogFile, 2) THEN BEGIN END;
            WITH LogFile DO
              BEGIN
               L := L + 2;
               writeln(F, ' ':LogMargin, '*** FILLÆNGDEFEJL *** FIL # ', FileNo:1
                                       , ' *** POSITION # ', Position:1
                                       , ' ***'
                      );
              END;
           END
        END;  (*LOGEOFERROR*)

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

«eof»