home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Pascal / MAXONPASCAL3.DMS / in.adf / DEMOS-OS1.3 / Mon.p < prev    next >
Encoding:
Text File  |  1994-07-23  |  39.9 KB  |  1,277 lines
  1. { MaxonPascal3-Anpassung / Test:   Falk Zühlsdorff (PackMAN)  1994 } 
  2.  
  3. { Himpelsoft & Maxon präsentieren: }
  4.  
  5. PROGRAM SystemMonitor;
  6.  
  7. { benötigt mindestens 150 KByte Workspace }
  8.  
  9. USES GRAPHICS,INTUITION;
  10.  
  11. CONST
  12.   MaxStruct = 100;  { maximale Anzahl von Einträgen in Strukturen }
  13.   MaxRem =20 ;      { Anzahl der gemerkten (und mit "B" zurück-
  14.                       verfolgbaren) "Jump"'s    }
  15.   ChH = 8;          { CharHeight: Höhe eines Zeichens }
  16.  
  17.   EscKey = chr($1b);
  18.  
  19.   CrsrUKey = chr($81);   { Die PROCEDURE "ReadFromKeyboard" }
  20.   CrsrDKey = chr($82);   { wandelt die Escapsequenzen der   }
  21.   CrsrLKey = chr($83);   { Cursortasten in diese Codes.     }
  22.   CrsrRKey = chr($84);
  23.  
  24. TYPE
  25.   Modes =                  { Modi: }
  26.     (ByteDump,WordDump,LongDump,Asciidump,  { verschiedene Dump-Arten }
  27.      Structure,            { Struktur-Modus, z. B. "ExecBase" }
  28.      Nix                   { Text, z. B. "Help" oder "About" }
  29.     );
  30.   Typus =       { EintragsTYPEn von Strukturen: }
  31.     (t_S,       { Short }
  32.      t_I,       { integer }
  33.      t_L,       { Long }
  34.      t_W,       { Word }
  35.      t_B,       { Byte }
  36.      t_str,     { Zeiger auf String }
  37.      t_sub      { Unterstruktur }
  38.     );
  39.   Bild32 = Array[1..16] of Long;        { Typ für Images }
  40.   IntArrMod = Array[ByteDump..Asciidump] Of integer;
  41.   Feld = Record            { Typ für Struktur-eintrag: }
  42.           name: str;       { Feldbezeichner }
  43.           Offset: Long;    { Adressdistanz zur Basis }
  44.           typ: Typus;      { Eintragstyp, s. o. }
  45.           SubNum: integer  { Typnummer einer Unterstruktur }
  46.         END;
  47.   Remem = Record           { "Remember"-Struktur für "B"-Sprünge }
  48.             Adr: Long;                    { alle relevanten Daten }
  49.             Zeile,Spalte,StrNum: integer; { werden in einem solchen }
  50.             Mode: Modes                   { Record aufbewahrt. }
  51.           END;
  52.  
  53. VAR
  54.   Breite,Hoehe: integer;      { Screengröße }
  55.   MyScreen: ^Screen;          { Screenhandle }
  56.   MyWindow: ^Window;          { Windowhandle }
  57.   Con: Ptr;                   { Zeiger auf Console-Device }
  58.   Sig: Long;                  { Signalmaske }
  59.   MyRast,MyUPt: Ptr;          {    "    "  RastPort und Userport }
  60.   Mess: ^IntuiMessage;        { empfangene Message }
  61.   Klasse: Long;               { "Class" der Message }
  62.   Mode: Modes;                { aktueller Modus, s. o. }
  63.   Struct: Array[1..maxstruct] of Feld;  { Speicher für Einträge der aktuellen Struktur }
  64.   Remembers: Array[1..maxrem] of Remem; { Remember-Buffer }
  65.   Adr,CursorAdr: Long;        { Startadresse des Dumps/der Struktur und Adresse der Cursorposition }
  66.   ENDe: Boolean;              { Flag für Programmende }
  67.   ch: Char;                   { zuletzt von Tastatur gelesenes Zeichen }
  68.   Zeile,Spalte: integer;      { Cursorposition im Dump bzw. in Struktur }
  69.   Zeile0: integer;            { erste dargestellte Zeile einer Struct }
  70.   FeldAnz: integer;           { Anzahl der Felder einer Struktur }
  71.   StrNum: integer;            { Nummer der Struktur (z.B. 1=ExecBase, 2=Node...}
  72.   RemAnz: integer;            { ENDe des belegten Teils des Remember-Buffers }
  73.   TextPage: integer;          { Nummer der Textseite (0=About, 1=Help) }
  74.   LineSize,Fieldsize: IntArrMod;    { Umfang einer Zeile/eines Feldes im entsprechENDen Dumpmodus }
  75.  
  76.  { Intuition-Strukturen für Menüs: }
  77.   Menu0,Menu1,Menu2: Menu;
  78.  
  79.   Men00,Men01,Men02,Men10,Men11,Men12,Men13,
  80.   Men14,Men140,Men141,Men142,Men143,Men144,Men145,Men146,
  81.   Men15,Men150,Men151,Men152,
  82.   Men20,Men21,Men22: MenuItem;
  83.  
  84.   Men00t,Men01t,Men02t,Men10t,Men11t,Men12t,Men13t,
  85.   Men14t,Men140t,Men141t,Men142t,Men143t,Men144t,Men145t,Men146t,
  86.   Men15t,Men150t,Men151t,Men152t,
  87.   Men20t,Men21t,Men22t: IntuiText;
  88.   Setit:boolean;
  89.  
  90.  { Strukturen für Gadgets und zugehörige Images: }
  91.   Knopf1,Knopf2,Knopf3,Knopf4,Knopf5,Knopf6: Gadget;
  92.   Image1,Image2,Image3,Image4,Image5,Image6: Image;
  93.   Bild1,Bild2,Bild3,Bild4,Bild5,Bild6: ^Bild32;
  94.   AddG:word;
  95.  
  96. { PEEK dürfte jeder Ex-BASIC-Programmierer wohl kennen...}
  97.  
  98. FUNCTION PeekB(a:Long):Byte;
  99.   { Byte aus Speicher lesen }
  100.   VAR p:^Byte;
  101.   BEGIN
  102.     p:=ptr(a);
  103.     PeekB:=p^
  104.   END;
  105.  
  106.  
  107. FUNCTION PeekW(a:Long):integer;
  108.   VAR p:^integer;
  109.   BEGIN
  110.     p:=ptr(a);
  111.     PeekW:=p^
  112.   END;
  113.  
  114.  
  115. FUNCTION PeekL(a:Long):Long;
  116.   VAR p:^Long;
  117.   BEGIN
  118.     p:=ptr(a);
  119.     PeekL:=p^
  120.   END;
  121.  
  122.  
  123. PROCEDURE Clear;
  124.  { Bildschirm löschen }
  125.  BEGIN
  126.    SetAPen(MyRast,0);
  127.    RectFill(MyRast,0,0,Breite,17*8)
  128.  END;
  129.  
  130.  
  131. PROCEDURE CreateStruct(s:integer);
  132.   { Jeder dem Monitor bekannten Amiga-Struktur ist eine Nummer zugeordnet
  133.     (z.B. ExecBase=1, Node=2, ... ). Diese Prozedur initialisiert das
  134.     Feld "Struct" mit den Einträgen der Struktur Nr. "s". }
  135.  
  136.   PROCEDURE a(Off:Long; Nam:str; T:typus; Sub:integer);
  137.     { "FeldAnz um 1 erhöhen und das entsprechENDe Felg von "Struct" mit
  138.       den Parametern initialisieren }
  139.     BEGIN
  140.       Feldanz:=Feldanz+1;
  141.       With Struct[Feldanz] Do
  142.         BEGIN
  143.           Offset:=Off;
  144.           Name:=Nam;
  145.           Typ:=T;
  146.           SubNum:=Sub
  147.         END;
  148.       IF CursorAdr>=Adr+Off THEN Zeile:=FeldAnz
  149.     END;
  150.  
  151.   BEGIN        { Createstruct }
  152.     FeldAnz:=0;
  153.     Zeile:=1;
  154.     StrNum:=s;
  155.     Case s Of  { Achtung, sehr langes "Case"! }
  156. 1: BEGIN       { 1: ExecBase }
  157.     a( 0,'LibNode',     t_sub,3);
  158.     a(34,'SoftVer',     t_W,0);
  159.     a(36,'LowMemChkSum',t_I,0);
  160.     a(38,'ChkBase',     t_L,0);
  161.     a(42,'ColdCapture', t_L,0);
  162.     a(46,'CoolCapture', t_L,0);
  163.     a(50,'WarmCapture', t_L,0);
  164.     a(54,'SysStkUpper', t_L,0);
  165.     a(58,'SysStkLower', t_L,0);
  166.     a(62,'MaxLocMem',   t_L,0);
  167.     a(66,'DebugEntry',  t_L,0);
  168.     a(70,'DebugData',   t_L,0);
  169.     a(74,'AlertData',   t_L,0);
  170.     a(78,'MaxExtMem',   t_L,0);
  171.     a(82,'ChkSum',      t_W,0);
  172.     a(84,'IntVects[0]', t_sub,7);
  173.     a(96,'IntVects[1]', t_sub,7);
  174.     a(108,'IntVects[2]', t_sub,7);
  175.     a(120,'IntVects[3]', t_sub,7);
  176.     a(132,'IntVects[4]', t_sub,7);
  177.     a(144,'IntVects[5]', t_sub,7);
  178.     a(156,'IntVects[6]', t_sub,7);
  179.     a(168,'IntVects[7]', t_sub,7);
  180.     a(180,'IntVects[8]', t_sub,7);
  181.     a(192,'IntVects[9]', t_sub,7);
  182.     a(204,'IntVects[10]',t_sub,7);
  183.     a(216,'IntVects[11]',t_sub,7);
  184.     a(228,'IntVects[12]',t_sub,7);
  185.     a(240,'IntVects[13]',t_sub,7);
  186.     a(252,'IntVects[14]',t_sub,7);
  187.     a(264,'IntVects[15]',t_sub,7);
  188.     a(276,'ThisTask',   t_L,5);
  189.     a(280,'IdleCount',  t_L,0);
  190.     a(284,'DispCount',  t_L,0);
  191.     a(288,'Quantum',    t_W,0);
  192.     a(290,'Elapsed',    t_W,0);
  193.     a(292,'SysFlags',   t_W,0);
  194.     a(294,'IDNestCnt',  t_S,0);
  195.     a(295,'TDNestCnt',  t_S,0);
  196.     a(296,'AttnFlags',  t_W,0);
  197.     a(298,'AttnResched',t_W,0);
  198.     a(300,'ResModules', t_L,0);
  199.     a(304,'TaskTrapCode',t_L,0);
  200.     a(308,'TaskExceptCode',t_L,0);
  201.     a(312,'TaskExitCode',t_L,0);
  202.     a(316,'TaskSigAlloc',t_L,0);
  203.     a(320,'TaskTrapAlloc',t_W,0);
  204.     a(322,'MemList',    t_Sub,4);
  205.     a(336,'ResourceList',t_Sub,4);
  206.     a(350,'DeviceList', t_Sub,4);
  207.     a(364,'IntrList',   t_Sub,4);
  208.     a(378,'LibList',    t_Sub,4);
  209.     a(392,'PortList',   t_Sub,4);
  210.     a(406,'TaskReady',  t_Sub,4);
  211.     a(420,'TaskWait',   t_Sub,4);
  212.     a(434,'SoftInts',   t_Sub,0);
  213.     a(514,'LastAlert[0]',t_L,0);
  214.     a(518,'LastAlert[1]',t_L,0);
  215.     a(522,'LastAlert[2]',t_L,0);
  216.     a(526,'LastAlert[3]',t_L,0);
  217.     a(530,'VBlankFrequency',t_B,0);
  218.     a(531,'PowerSupplyFrequency',t_B,0);
  219.     a(532,'SemaphoreList',t_Sub,4);
  220.     a(546,'KickMemPtr', t_L,0);
  221.     a(550,'KickTagPtr', t_L,0);
  222.     a(554,'KickCheckSum',t_L,0);
  223.     a(558,'ExecBaseReserved',t_Sub,0);
  224.     a(568,'ExecBaseNewReserved',t_Sub,0)
  225.    END;
  226. 2: BEGIN    { 2: Node }
  227.     a( 0,'Succ',        t_L,2);
  228.     a( 4,'Pred',        t_L,2);
  229.     a( 8,'TYPE',        t_B,0);
  230.     a( 9,'Pri',         t_S,0);
  231.     a(10,'Name',        t_str,0)
  232.    END;
  233. 3: BEGIN     { 3: Library }
  234.     a( 0,'-Next',       t_L,3);
  235.     a( 0,'Node',        t_Sub,2);
  236.     a(14,'Flags',       t_B,0);
  237.     a(15,'pad',         t_B,0);
  238.     a(16,'NegSize',     t_W,0);
  239.     a(18,'PosSize',     t_W,0);
  240.     a(20,'Version',     t_W,0);
  241.     a(22,'Revision',    t_W,0);
  242.     a(24,'IdString',    t_Str,0);
  243.     a(28,'Sum',         t_L,0);
  244.     a(32,'OpenCnt',     t_W,0)
  245.    END
  246. 4: BEGIN      { 4: List }
  247.      a( 0,'Head',       t_L,2);
  248.      a( 4,'Tail',       t_L,2);
  249.      a( 8,'TailPred',   t_L,2);
  250.      a(12,'TYPE',       t_B,0);
  251.      a(13,'pad',        t_B,0)
  252.    END;
  253. 5: BEGIN    { 5: Task }
  254.      a( 0,'-Next',      t_L,5);
  255.      a( 0,'Node',       t_Sub,2);
  256.      a(14,'Flags',      t_B,0);
  257.      a(15,"State",      t_B,0);
  258.      a(16,"IDNestCnt",  t_S,0);
  259.      a(17,"TDNestCnt",  t_S,0);
  260.      a(18,"SigAlloc",   t_L,0);
  261.      a(22,"SigWait",    t_L,0);
  262.      a(26,"SigRecvd",   t_L,0);
  263.      a(30,"SigExcept",  t_L,0);
  264.      a(34,"TrapAlloc",  t_W,0);
  265.      a(36,"TrapAble",   t_W,0);
  266.      a(38,"ExceptData", t_L,0);
  267.      a(42,"ExceptCode", t_L,0);
  268.      a(46,"TrapData",   t_L,0);
  269.      a(50,"TrapCode",   t_L,0);
  270.      a(54,"SPReg",      t_L,0);
  271.      a(58,"SPLower",    t_L,0);
  272.      a(62,"SPUpper",    t_L,0);
  273.      a(66,"Switch",     t_L,0);
  274.      a(70,"Launch",     t_L,0);
  275.      a(74,"MemEntry",   t_Sub,4);
  276.      a(88,"UserData",   t_L,0)
  277.    END;
  278.  
  279. 7: BEGIN { 7: IntVector }
  280.      a( 0,'iv_Data',    t_L,0);
  281.      a( 4,'iv_Code',    t_L,0);
  282.      a( 8,'iv_Node',    t_L,2)
  283.    END;
  284.  
  285. 100:BEGIN { 100: IntuitionBase }
  286.     a( 0,'Libnode',     t_S,3);
  287.     a(34,'ViewLord',    t_S,0);
  288.     a(52,'ActiveWindow',t_L,101);
  289.     a(56,'ActiveScreen',t_L,102);
  290.     a(60,'FirstScreen', t_L,102);
  291.     a(64,'Flags',       t_L,0);
  292.     a(68,'MouseY',      t_I,0);
  293.     a(70,'MouseX',      t_I,0);
  294.     a(72,'Seconds',     t_L,0);
  295.     a(76,'Micros',      t_L,0)
  296.     END;
  297. 101:BEGIN { 101: Window }
  298.     a( 0,'NextWindow',  t_L,101);
  299.     a( 4,'LeftEdge',    t_I,0);
  300.     a( 6,'TopEdge',     t_I,0);
  301.     a( 8,'Width',       t_W,0);
  302.     a(10,'Height',      t_W,0);
  303.     a(12,'MouseX',      t_I,0);
  304.     a(14,'MouseY',      t_I,0);
  305.     a(16,"MinWidth",    t_W,0);
  306.     a(18,"MinHeight",   t_W,0);
  307.     a(20,"MaxWidth",    t_W,0);
  308.     a(22,"MaxHeight",   t_W,0);
  309.     a(24,"Flags",       t_L,0);
  310.     a(28,"MenuStrip",   t_L,0);
  311.     a(32,"Title",       t_str,0);
  312.     a(36,"FirstRequest",t_L,0);
  313.     a(40,"DMRequest",   t_L,0);
  314.     a(44,"ReqCount",    t_I,0);
  315.     a(46,"WScreen",     t_L,102);
  316.     a(50,"RPort",       t_L,0);
  317.     a(54,"BorderLeft",  t_S,0);
  318.     a(55,"BorderTop",   t_S,0);
  319.     a(56,"BorderRight", t_S,0);
  320.     a(57,"BorderBottom",t_S,0);
  321.     a(58,"BorderRPort", t_L,0);
  322.     a(62,"FirstGadget", t_L,0);
  323.     a(66,"Parent",      t_L,0);
  324.     a(70,"DescENDent",  t_L,0);
  325.     a(74,"Pointer",     t_L,0);
  326.     a(78,"PtrHeight",   t_B,0);
  327.     a(79,"PtrWidth",    t_B,0);
  328.     a(80,"XOffset",     t_B,0);
  329.     a(81,"YOffset",     t_B,0);
  330.     a(82,"IDCMPFlags",  t_L,0);
  331.     a(86,"UserPort",    t_L,0);
  332.     a(90,"WindowPort",  t_L,0);
  333.     a(94,"MessageKey",  t_L,0);
  334.     a(98,"DetailPen",   t_B,0);
  335.     a(99,"BlockPen",    t_B,0);
  336.     a(100,"CheckMark",  t_L,0);
  337.     a(104,"ScreenTitle",t_str,0);
  338.     a(108,"GZZMouseX",  t_I,0);
  339.     a(110,"GZZMouseY",  t_I,0);
  340.     a(112,"GZZWidth",   t_I,0);
  341.     a(114,"GZZHeight",  t_I,0);
  342.     a(116,"ExtData",    t_L,0);
  343.     a(120,"UserData",   t_L,0);
  344.     a(124,"WLayer",     t_L,0);
  345.     a(128,"IFont",      t_L,0)
  346.     END;
  347. 102:BEGIN  { 102: Screen }
  348.     a( 0,"NextScreen",  t_L,102);
  349.     a( 4,"FirstWindow", t_L,101);
  350.     a( 8,"LeftEdge",    t_I,0);
  351.     a(10,"TopEdge",     t_I,0);
  352.     a(12,"Width",       t_W,0);
  353.     a(14,"Height",      t_W,0);
  354.     a(16,"MouseY",      t_I,0);
  355.     a(18,"MouseX",      t_I,0);
  356.     a(20,"Flags",       t_W,0);
  357.     a(22,"Title",       t_str,0);
  358.     a(26,"DefaultTitle",t_str,0);
  359.     a(30,"BarHeight",   t_B,0);
  360.     a(31,"BarVBorder",  t_B,0);
  361.     a(32,"BarHBorder",  t_B,0);
  362.     a(33,"MenuVBorder", t_B,0);
  363.     a(34,"MenuHBorder", t_B,0);
  364.     a(35,"WBorTop",     t_B,0);
  365.     a(36,"WBorLeft",    t_B,0);
  366.     a(37,"WBorRight",   t_B,0);
  367.     a(38,"WBorBottom",  t_B,0);
  368.     a(39,"KludgeFill00",t_B,0);
  369.     a(40,"Font",        t_L,0);
  370.     a(44,"ViewPort",    t_S,0);
  371.     a(84,"RastPort",    t_S,0);
  372.     a(184,"BitMap",     t_S,0);
  373.     a(224,"LayerInfo",  t_S,0);
  374.     a(326,"FirstGadget",t_L,0);
  375.     a(330,"DetailPen",  t_B,0);
  376.     a(331,"BlockPen",   t_B,0);
  377.     a(332,"SaveColor0", t_W,0);
  378.     a(334,"BarLayer",   t_L,0);
  379.     a(338,"ExtData",    t_L,0);
  380.     a(342,"UserData",   t_L,0)
  381.     END;
  382.   Otherwise   { of CASE }
  383.     a(0,'Ungültig',     t_B,0)  { Default für den Notfall }
  384.   END
  385.  END;    { PROCEDURE CreateStruct }
  386.  
  387. FUNCTION FindWBScreen:Ptr;
  388.   { liefert Zeiger auf den Workbench-Screen }
  389.   VAR scr: ^Screen;
  390.   BEGIN
  391.     scr:=Ptr(PeekL(Long(IntuitionBase)+60));
  392.     { Das ist der Melmac-Trick: Auf diese Weise bekommt man den Zeiger
  393.       "FirstScreen" der IntuitionBase-Struktur, ohne dazu das include-
  394.       File "intuition/intuitionbase.h" laden zu müssen- spart immerhin
  395.       17 KByte Includes und ca. 1.5 Sekunden Compilezeit. }
  396.     While (scr^.Title<>'Workbench Screen')and(scr^.NextScreen<>Nil) Do
  397.       scr:=scr^.NextScreen;  { WB-Screen aus Liste suchen }
  398.     FindWBScreen:=scr
  399.   END;
  400.  
  401. PROCEDURE Initialise;
  402.  { Window öffen und so weiter }
  403.  VAR WBscr: ^Screen;
  404.  BEGIN
  405.   { Am Anfang "ExecBase" }
  406.   Adr:=Long(SysBase); CursorAdr:=Adr;
  407.   LineSize:=IntArrMod(16,16,16,64);
  408.   Fieldsize:=IntArrMod(1,2,4,1);
  409.   Zeile:=0; Spalte:=0; RemAnz:=0;
  410.   Mode:=Structure; CreateStruct(1);
  411.   WBscr:=FindWBscreen;
  412.   { Speicher (CHIP-MEM!) für Images anfordern }
  413.   Bild1:=ptr(Alloc_mem(sizeof(Bild32),2));
  414.   Bild2:=ptr(Alloc_mem(sizeof(Bild32),2));
  415.   Bild3:=ptr(Alloc_mem(sizeof(Bild32),2));
  416.   Bild4:=ptr(Alloc_mem(sizeof(Bild32),2));
  417.   Bild5:=ptr(Alloc_mem(sizeof(Bild32),2));
  418.   Bild6:=ptr(Alloc_mem(sizeof(Bild32),2));
  419.   { Dimensionen vom "ActiveScreen" (im allg. der Workbench-Screen) übernehmen }
  420.   Breite:= WBscr^.Width;
  421.   Hoehe := WBscr^.Height;
  422.   { Screen und Window öffnen, Initialisierungen }
  423.   MyScreen:=Open_Screen(0,0,Breite,Hoehe,2,0,1,HIRES or GENLOCK_VIDEO,'Himpelmon');
  424.   MyWindow:=Open_Window(0,10,Breite,Hoehe-10,1,MOUSEBUTTONS or GADGETDOWN or
  425.     GADGETUP or MENUPICK, ACTIVATE or BORDERLESS,Nil,MyScreen,100,100,640,200);
  426.   MyRast:=MyWindow^.RPort;
  427.   MyUPt:=MyWindow^.UserPort;
  428.   Con:=OpenConsole(MyWindow);
  429.   WriteCon(Con,''\e'0 p');    { Cursor unsichtbar }
  430.   { Menüs initialisieren und setzen }
  431.   Menu0:=Menu(^Menu1,10,0,63,10,1,'Project',^Men00,0,0,0,0);
  432.    Men00:=MenuItem(^Men01,0, 0,80,12,ITEMTEXT or HIGHCOMP or ITEMENABLED,0,^Men00t,Nil,' ',Nil,0);
  433.    Men01:=MenuItem(^Men02,0,12,80,12,ITEMTEXT or HIGHCOMP or ITEMENABLED,0,^Men01t,Nil,' ',Nil,0);
  434.    Men02:=MenuItem( Nil,  0,24,80,12,ITEMTEXT or HIGHCOMP or ITEMENABLED,0,^Men02t,Nil,' ',Nil,0);
  435.    Men00t:=IntuiText(0,1,1,5,3,Nil,'About',Nil);
  436.    Men01t:=IntuiText(0,1,1,5,3,Nil,'Help',Nil);
  437.    Men02t:=IntuiText(0,1,1,5,3,Nil,'Quit',Nil);
  438.   Menu1:=Menu(^Menu2,100,0,39,10,1,'Mode',^Men10,0,0,0,0);
  439.    Men10:=MenuItem(^Men11,0, 0,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED+COMMSEQ,0,^Men10t,Nil,'B',Nil,0);
  440.    Men11:=MenuItem(^Men12,0,12,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED+COMMSEQ,0,^Men11t,Nil,'W',Nil,0);
  441.    Men12:=MenuItem(^Men13,0,24,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED+COMMSEQ,0,^Men12t,Nil,'L',Nil,0);
  442.    Men13:=MenuItem(^Men14,0,36,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED+COMMSEQ,0,^Men13t,Nil,'A',Nil,0);
  443.    Men14:=MenuItem(^Men15,0,48,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED        ,0,^Men14t,Nil,' ',^Men140,0);
  444.    Men140:=MenuItem(^Men141,100, 0,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men140t,Nil,' ',Nil,0);
  445.    Men141:=MenuItem(^Men142,100,10,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men141t,Nil,' ',Nil,0);
  446.    Men142:=MenuItem(^Men143,100,20,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men142t,Nil,' ',Nil,0);
  447.    Men143:=MenuItem(^Men144,100,30,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men143t,Nil,' ',Nil,0);
  448.    Men144:=MenuItem(^Men145,100,40,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men144t,Nil,' ',Nil,0);
  449.    Men145:=MenuItem(^Men146,100,50,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men145t,Nil,' ',Nil,0);
  450.    Men146:=MenuItem( Nil   ,100,60,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men146t,Nil,' ',Nil,0);
  451.    Men15:=MenuItem( Nil,  0,60,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED        ,0,^Men15t,Nil,' ',^Men150,0);
  452.    Men150:=MenuItem(^Men151,100, 0,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men150t,Nil,' ',Nil,0);
  453.    Men151:=MenuItem(^Men152,100,10,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men151t,Nil,' ',Nil,0);
  454.    Men152:=MenuItem( Nil   ,100,20,120,10,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men152t,Nil,' ',Nil,0);
  455.    Men10t:=IntuiText(0,1,1,4,2,Nil,'Bytes',Nil);
  456.    Men11t:=IntuiText(0,1,1,4,2,Nil,'Words',Nil);
  457.    Men12t:=IntuiText(0,1,1,4,2,Nil,'Longwords',Nil);
  458.    Men13t:=IntuiText(0,1,1,4,2,Nil,'Ascii',Nil);
  459.    Men14t:=IntuiText(0,1,1,4,2,Nil,'Exec',Nil);
  460.    Men140t:=IntuiText(0,1,1,4,1,Nil,'ExecBase',Nil);
  461.    Men141t:=IntuiText(0,1,1,4,1,Nil,'Node',Nil);
  462.    Men142t:=IntuiText(0,1,1,4,1,Nil,'Library',Nil);
  463.    Men143t:=IntuiText(0,1,1,4,1,Nil,'List',Nil);
  464.    Men144t:=IntuiText(0,1,1,4,1,Nil,'Task',Nil)
  465.    Men145t:=Intuitext(0,1,1,4,1,Nil,'?',Nil);
  466.    Men146t:=Intuitext(0,1,1,4,1,Nil,'IntVector',Nil);
  467.    Men15t:=IntuiText(0,1,1,4,2,Nil,'Intuition',Nil);
  468.    Men150t:=IntuiText(0,1,1,4,1,Nil,'IntuitionBase',Nil);
  469.    Men151t:=IntuiText(0,1,1,4,1,Nil,'Window',Nil);
  470.    Men152t:=IntuiText(0,1,1,4,1,Nil,'Screen',Nil);
  471.   Menu2:=Menu(Nil,200,0,63,10,1,'Address',^Men20,0,0,0,0);
  472.    Men20:=MenuItem(^Men21,0, 0,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men20t,Nil,' ',Nil,0);
  473.    Men21:=MenuItem(^Men22,0,12,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men21t,Nil,' ',Nil,0);
  474.    Men22:=MenuItem( Nil,  0,24,120,12,ITEMTEXT+HIGHCOMP+ITEMENABLED,0,^Men22t,Nil,' ',Nil,0);
  475.    Men20t:=IntuiText(0,1,1,4,2,Nil,'MemBase',Nil);
  476.    Men21t:=IntuiText(0,1,1,4,2,Nil,'SysBase',Nil);
  477.    Men22t:=IntuiText(0,1,1,4,2,Nil,'IntuitionBase',Nil);
  478.    SetIt:=SetMenuStrip(MyWindow,^Menu0);
  479.   { Gadgets und deren Images initialisieren }
  480.   Bild1^:=Bild32(
  481.    %00011111111111111111111111111000,
  482.    %01110000000000000000000000001110,
  483.    %11100000000000111100000000000111,
  484.    %11000000000001111110000000000011,
  485.    %11000000000011100111000000000011,
  486.    %11000000000111000011100000000011,
  487.    %11000000001110000001110000000011,
  488.    %11000000011100000000111000000011,
  489.    %11000000111000000000011100000011,
  490.    %11000001110000000000001110000011,
  491.    %11000011100000000000000111000011,
  492.    %11000011100000000000000111000011,
  493.    %11000001111111111111111110000011,
  494.    %11100000000000000000000000000111,
  495.    %01110000000000000000000000001110,
  496.    %00011111111111111111111111111000);
  497.   Bild2^:=Bild32(
  498.    %00011111111111111111111111111000,
  499.    %01110000000000000000000000001110,
  500.    %11100000000000000000000000000111,
  501.    %11000001111111111111111110000011,
  502.    %11000011100000000000000111000011,
  503.    %11000011100000000000000111000011,
  504.    %11000001110000000000001110000011,
  505.    %11000000111000000000011100000011,
  506.    %11000000011100000000111000000011,
  507.    %11000000001110000001110000000011,
  508.    %11000000000111000011100000000011,
  509.    %11000000000011100111000000000011,
  510.    %11000000000001111110000000000011,
  511.    %11100000000000111100000000000111,
  512.    %01110000000000000000000000001110,
  513.    %00011111111111111111111111111000);
  514.   Bild3^:=Bild32(
  515.    %00011111111111111111111111111000,
  516.    %01110000000000000000000000001110,
  517.    %11100000000001111110000000000111,
  518.    %11000000000111100111100000000011,
  519.    %11000000011110000001111000000011,
  520.    %11000001111000000000011110000011,
  521.    %11000011111111111111111111000011,
  522.    %11000000000000000000000000000011,
  523.    %11000000000001111110000000000011,
  524.    %11000000000111100111100000000011,
  525.    %11000000011110000001111000000011,
  526.    %11000001111000000000011110000011,
  527.    %11000011111111111111111111000011,
  528.    %11100000000000000000000000000111,
  529.    %01110000000000000000000000001110,
  530.    %00011111111111111111111111111000);
  531.   Bild4^:=Bild32(
  532.    %00011111111111111111111111111000,
  533.    %01110000000000000000000000001110,
  534.    %11100000000000000000000000000111,
  535.    %11000011111111111111111111000011,
  536.    %11000001111000000000011110000011,
  537.    %11000000011110000001111000000011,
  538.    %11000000000111100111100000000011,
  539.    %11000000000001111110000000000011,
  540.    %11000000000000000000000000000011,
  541.    %11000011111111111111111111000011,
  542.    %11000001111000000000011110000011,
  543.    %11000000011110000001111000000011,
  544.    %11000000000111100111100000000011,
  545.    %11100000000001111110000000000111,
  546.    %01110000000000000000000000001110,
  547.    %00011111111111111111111111111000);
  548.   Bild5^:=Bild32(
  549.    %00011111111111111111111111111000,
  550.    %01110000000000000000000000001110,
  551.    %11100000000000000000111100000111,
  552.    %11000000000000000111111110000011,
  553.    %11000000000000111110000110000011,
  554.    %11000000000111110000000110000011,
  555.    %11000000111110000000000110000011,
  556.    %11000111110000000000000110000011,
  557.    %11000111110000000000000110000011,
  558.    %11000000111110000000000110000011,
  559.    %11000000000111110000000110000011,
  560.    %11000000000000111110000110000011,
  561.    %11000000000000000111111110000011,
  562.    %11100000000000000000111100000111,
  563.    %01110000000000000000000000001110,
  564.    %00011111111111111111111111111000);
  565.   Bild6^:=Bild32(
  566.    %00011111111111111111111111111000,
  567.    %01110000000000000000000000001110,
  568.    %11100000111100000000000000000111,
  569.    %11000001111111100000000000000011,
  570.    %11000001100001111100000000000011,
  571.    %11000001100000001111100000000011,
  572.    %11000001100000000001111100000011,
  573.    %11000001100000000000001111100011,
  574.    %11000001100000000000001111100011,
  575.    %11000001100000000001111100000011,
  576.    %11000001100000001111100000000011,
  577.    %11000001100001111100000000000011,
  578.    %11000001111111100000000000000011,
  579.    %11100000111100000000000000000111,
  580.    %01110000000000000000000000001110,
  581.    %00011111111111111111111111111000);
  582.   Image1:=Image(0,0,32,16,1,Bild1,1,0,Nil);
  583.   Image2:=Image(0,0,32,16,1,Bild2,1,0,Nil);
  584.   Image3:=Image(0,0,32,16,1,Bild3,1,0,Nil);
  585.   Image4:=Image(0,0,32,16,1,Bild4,1,0,Nil);
  586.   Image5:=Image(0,0,32,16,1,Bild5,1,0,Nil);
  587.   Image6:=Image(0,0,32,16,1,Bild6,1,0,Nil);
  588.   Knopf1:=Gadget(Nil, 40,140,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image1,Nil,Nil,0,Nil,1,NIL);
  589.   Knopf2:=Gadget(Nil, 40,160,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image2,Nil,Nil,0,Nil,2,NIL);
  590.   Knopf3:=Gadget(Nil, 80,140,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image3,Nil,Nil,0,Nil,3,NIL);
  591.   Knopf4:=Gadget(Nil, 80,160,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image4,Nil,Nil,0,Nil,4,NIL);
  592.   Knopf5:=Gadget(Nil,  0,150,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image5,Nil,Nil,0,Nil,5,NIL);
  593.   Knopf6:=Gadget(Nil,120,150,32,12,GADGHNONE+GADGIMAGE,GADGIMMEDIATE,BOOLGADGET,^Image6,Nil,Nil,0,Nil,6,NIL);
  594.   AddG:=AddGadget(MyWindow,^Knopf1,0);
  595.   AddG:=AddGadget(MyWindow,^Knopf2,1);
  596.   AddG:=AddGadget(MyWindow,^Knopf3,2);
  597.   AddG:=AddGadget(MyWindow,^Knopf4,3);
  598.   AddG:=AddGadget(MyWindow,^Knopf5,4);
  599.   AddG:=AddGadget(MyWindow,^Knopf6,5);
  600.   RefreshGadgets(MyWindow^.FirstGadget,MyWindow,Nil);
  601.  END;
  602.  
  603. PROCEDURE CloseEverything;
  604. { alles schließen }
  605.  BEGIN
  606.   CloseConsole(Con);
  607.   Close_Window(MyWindow);
  608.   Close_Screen(MyScreen);
  609.   CloseLib(intuitionbase);
  610.   CloseLib(gfxbase)
  611.  END;
  612.  
  613. PROCEDURE Erinnere;
  614.   { Daten in Remember-buffer übernehmen }
  615.   VAR i:Integer;
  616.   BEGIN
  617.     IF RemAnz=MaxRem THEN    { Array ist voll, also "scrollen" }
  618.       BEGIN
  619.         For i:=1 to MaxRem-1 Do
  620.           Remembers[i]:=Remembers[i+1]
  621.       END
  622.     ELSE
  623.       RemAnz:=RemAnz+1;      { noch nicht voll, also ein Element hinzufügen }
  624.     Remembers[RemAnz]:=Remem(Adr,Zeile,Spalte,StrNum,Mode);
  625.   END;
  626.  
  627. PROCEDURE CalcZ0;
  628.  { "Zeile0" berechnen }
  629.  BEGIN
  630.    IF Zeile<=8 THEN Zeile0:=1 Else
  631.    IF Zeile>=FeldAnz-8 THEN
  632.     BEGIN
  633.      IF FeldAnz>=16 THEN Zeile0:=Feldanz-15
  634.      Else Zeile0:=1
  635.     END
  636.    Else Zeile0:=Zeile-7;
  637.  END;
  638.  
  639. PROCEDURE SetCursor;
  640.   VAR Cursort: Intuitext;
  641.   BEGIN
  642.     Case Mode of
  643.       ByteDump:BEGIN
  644.          Cursort:=Intuitext(2,0,6,0,0,Nil,'  ',Nil);
  645.          PrintIText(MyRast,^Cursort,8*(8+3*Spalte),2+8*Zeile) END;
  646.       WordDump:BEGIN
  647.          Cursort:=IntuiText(2,0,6,0,0,Nil,'    ',Nil);
  648.          PrintIText(MyRast,^Cursort,8*(8+5*(Spalte div 2)),2+8*Zeile) END;
  649.       LongDump:BEGIN
  650.          Cursort:=IntuiText(2,0,6,0,0,Nil,'        ',Nil);
  651.          PrintIText(MyRast,^Cursort,8*(8+9*(Spalte div 4)),2+8*Zeile) END;
  652.       AsciiDump:BEGIN
  653.          Cursort:=IntuiText(2,0,6,0,0,Nil,' ',Nil);
  654.          PrintIText(MyRast,^Cursort,8*(8+Spalte),2+8*Zeile) END;
  655.       Structure:BEGIN
  656.          CalcZ0;
  657.          Cursort:=IntuiText(2,0,6,0,0,Nil,' ',Nil);
  658.          PrintIText(MyRast,^Cursort,8*31,2+8*(Zeile-Zeile0))
  659.          END;
  660.     Else; END
  661.   END;
  662.  
  663.  
  664. PROCEDURE DecodeHex(p:ptr; Zahl:Long; Len:integer);
  665.   { "Zahl" als hex in String p ablegen, Länge "Len" }
  666.   VAR i,z:integer;
  667.       pp:^Array[0..7] of char;
  668.   BEGIN
  669.     pp:=p;
  670.     For i:=Len-1 Downto 0 Do
  671.       BEGIN
  672.         z:=Zahl and 15;
  673.         IF Zahl>=0 THEN Zahl:= Zahl div 16
  674.                    Else Zahl:=(Zahl and $7fffffff) div 16 + $8000000;
  675.         IF z<10 THEN pp^[i]:=chr(ord('0')+z)
  676.                 Else pp^[i]:=chr(ord('A')+z-10)
  677.       END
  678.   END;
  679.  
  680.  
  681. PROCEDURE StructZeileAus(i,z: integer);
  682.   { Zeile i einer Struktur in NBildschirmzeile z ausgeben }
  683.   VAR j: integer;
  684.       nam: ^String[80];
  685.       a: Long;
  686.       Buffer: string[80];
  687.       Outputt: Intuitext;
  688.   BEGIN
  689.    Outputt:=Intuitext(1,0,1,0,0,Nil,^Buffer,Nil);
  690.     For j:=1 to 76 do Buffer[j]:=' ';
  691.     Buffer[77]:=chr(0)
  692.     IF i<=FeldAnz THEN
  693.       BEGIN
  694.         a:=Adr+Struct[i].Offset;
  695.         DecodeHex(^Buffer[1],a,6);
  696.         Buffer[7]:=' ';
  697.         j:=1;
  698.         nam:=Struct[i].Name;
  699.         While (j<20)and(nam^[j]<>chr(0)) Do
  700.           BEGIN
  701.             Buffer[10+j]:=nam^[j]; j:=j+1
  702.           END;
  703.         Case Struct[i].typ Of
  704.           t_L:BEGIN
  705.                 Buffer[9]:='L';
  706.                 DecodeHex(^Buffer[32],PeekL(a),8)
  707.               END;
  708.           t_W:BEGIN
  709.                 Buffer[9]:='W';
  710.                 DecodeHex(^Buffer[32],PeekW(a),4)
  711.               END;
  712.           t_I:BEGIN
  713.                 Buffer[9]:='I';
  714.                 IF PeekW(a)>=0 THEN
  715.                   DecodeHex(^Buffer[32],PeekW(a),4)
  716.                 Else
  717.                   BEGIN
  718.                     Buffer[32]:='-';
  719.                     DecodeHex(^Buffer[33],-PeekW(a),4)
  720.                   END;
  721.               END;
  722.           t_S:BEGIN
  723.                 Buffer[9]:='S';
  724.                 IF Short(PeekB(a))>=0 THEN
  725.                   DecodeHex(^Buffer[32],PeekB(a),2)
  726.                 Else
  727.                   BEGIN
  728.                     Buffer[32]:='-';
  729.                     DecodeHex(^Buffer[33],-Short(PeekB(a)),2)
  730.                   END
  731.               END;
  732.           t_B:BEGIN
  733.                 Buffer[9]:='B';
  734.                 DecodeHex(^Buffer[32],PeekB(a),2)
  735.               END;
  736.           t_str:BEGIN
  737.                   Buffer[9]:='"';
  738.                   DecodeHex(^Buffer[32],a,6);
  739.                   j:=1;
  740.                   nam:=ptr(PeekL(a));
  741.                   While (j<25)and(nam^[j]<>chr(0)) Do
  742.                   BEGIN
  743.                     Buffer[40+j]:=nam^[j]; j:=j+1
  744.                   END
  745.                 END;
  746.            t_Sub:BEGIN
  747.                  IF Struct[i].SubNum=0 THEN Buffer[9]:='?'
  748.                                        Else Buffer[9]:='*';
  749.                  Buffer[32]:='.'
  750.                END;
  751.           Otherwise END;
  752.       END;
  753.     PrintIText(MyRast,^Outputt,0,2+8*z);
  754.   END;
  755.  
  756.  
  757. PROCEDURE Ausgabe(m:Modes);
  758.  VAR
  759.   Buffer: string[80];
  760.   Outputt: Intuitext;
  761.  
  762.  PROCEDURE HexdumpAus(m:modes);
  763.   VAR
  764.     a:Long;
  765.     bpuf:^array[0..15]of Byte;
  766.     wpuf:^array[0..7] of Word;
  767.     lpuf:^array[0..3] of Long;
  768.     i,j,k,step:integer;
  769.   BEGIN
  770.     IF m=Bytedump THEN a:=Adr Else a:=Adr and $fffffe;
  771.     Case m of
  772.       Bytedump: step:=1;
  773.       WordDump: step:=2;
  774.       LongDump: step:=4
  775.     END;
  776.     For i:=0 to 15 do    { 16 Zeilen }
  777.      BEGIN
  778.       DecodeHex(^Buffer[1],a,6);
  779.       Buffer[7]:=':'; Buffer[8]:=' ';
  780.       bpuf:=ptr(a); wpuf:=ptr(a); lpuf:=ptr(a);
  781.       j:=0;
  782.       k:=9;
  783.       While j<16 do
  784.         BEGIN
  785.           Case m of
  786.             ByteDump:DecodeHex(^Buffer[k],bpuf^[j],2);
  787.             Worddump:DecodeHex(^Buffer[k],wpuf^[j div 2],4);
  788.             LongDump:DecodeHex(^Buffer[k],lpuf^[j div 4],8)
  789.           END;
  790.           k:=k+2*step+1;
  791.           Buffer[k-1]:=' ';
  792.           j:=j+step;
  793.         END;
  794.       For j:=0 to 15 Do
  795.         IF (bpuf^[j]>=ord(' ')) and (bpuf^[j]<128) THEN
  796.           Buffer[k+j]:=chr(bpuf^[j])
  797.         Else
  798.           Buffer[k+j]:='.';
  799.       Buffer[k+16]:=chr(0);
  800.       PrintIText(MyRast,^Outputt,0,2+8*i);
  801.       IF i=Zeile THEN SetCursor;
  802.      a:=a+16
  803.      END;
  804.   END;
  805.  
  806.  PROCEDURE AscDumpAus;
  807.   VAR
  808.     a:Long;
  809.     cpuf:^Char;
  810.     i,j:integer;
  811.   BEGIN
  812.     a:=Adr;
  813.     For i:=0 to 15 do    { 16 Zeilen }
  814.      BEGIN
  815.        DecodeHex(^Buffer[1],a,6);
  816.        Buffer[7]:=':'; Buffer[8]:=' ';
  817.        For j:=0 to 63 do
  818.          BEGIN
  819.            cpuf:=ptr(a+j);
  820.            IF (cpuf^>=' ') and (cpuf^<chr(128)) or (cpuf^>chr($a0)) THEN
  821.              Buffer[9+j]:=Cpuf^
  822.            Else
  823.              Buffer[9+j]:='.'
  824.          END;
  825.        Buffer[73]:=chr(0);
  826.        PrintIText(MyRast,^Outputt,0,2+8*i);
  827.        IF i=Zeile THEN SetCursor;
  828.        a:=a+64
  829.      END;
  830.   END;
  831.  
  832.  PROCEDURE InfoAus;
  833.   PROCEDURE ia(s:str; x,y,pen,md:integer);
  834.    VAR it:IntuiText;
  835.    BEGIN
  836.     it:=IntuiText(pen,0,md,0,0,Nil,s,Nil);
  837.     PrintIText(MyRast,^it,x,y)
  838.    END;
  839.   BEGIN
  840.     IF TextPage=0 THEN
  841.      BEGIN
  842.       ia('H I M P E L M O N',252,10,3,1);
  843.       ia('Der System-Analytiker',236,20,1,1);
  844.       ia('Geschreiben von:',50,50,1,1);
  845.       ia('Jens "Himpelsoft" Gelhar',50,70,3,1);
  846.       ia('Alderichstraße 19',50,80,3,1);
  847.       ia('4790 Paderborn',50,90,3,1)
  848.      END
  849.     Else
  850.      BEGIN
  851.        ia('Hilfe',20,10,3,1);
  852.        ia('FolgENDe Tasten sind in der vorliegENDen Version belegt:',20,30,1,1);
  853.        ia('J   ("Jump")',20,50,1,1);
  854.        ia('B   ("Back")',20,60,1,1);
  855.        ia('Esc (ENDe)',20,70,1,1);
  856.        ia('Cursortasten',20,80,1,1)
  857.      END
  858.   END;
  859.  
  860.  PROCEDURE StructAus;
  861.    VAR i:integer;
  862.    BEGIN
  863.      CalcZ0;
  864.      For i:=Zeile0 to Zeile0+15 Do
  865.        BEGIN
  866.          StructZeileAus(i,i-Zeile0);
  867.          IF i=Zeile THEN SetCursor;
  868.        END
  869.    END;
  870.  
  871.  BEGIN { Ausgabe }
  872.    Outputt:=Intuitext(1,0,1,0,0,Nil,^Buffer,Nil);
  873.    Case M of
  874.      ByteDump,WordDump,LongDump: HexdumpAus(M);
  875.      AsciiDump: AscDumpAus;
  876.      Structure: StructAus;
  877.      Nix: InfoAus;
  878.    END
  879.  END;
  880.  
  881.  
  882. PROCEDURE Scroll1Up;
  883.   BEGIN
  884.     IF Mode<=AsciiDump THEN BEGIN
  885.       IF Mode=Asciidump THEN Adr:=Adr-64
  886.                          Else Adr:=Adr-16;
  887.       Scrollraster(MyRast,0,-ChH,0,0,Breite,16*ChH);
  888.       Ausgabe(Mode)
  889.     END
  890.     Else
  891.     IF Mode=Structure THEN
  892.       BEGIN
  893.         Scrollraster(MyRast,0,-ChH,0,0,Breite,16*ChH);
  894.         CalcZ0;
  895.         StructZeileAus(Zeile0,0)
  896.       END
  897.   END;
  898.  
  899.  
  900. PROCEDURE Scroll1Down;
  901.   BEGIN
  902.     IF Mode<=AsciiDump THEN BEGIN
  903.       IF Mode=Asciidump THEN Adr:=Adr+64
  904.                         Else Adr:=Adr+16;
  905.       Scrollraster(MyRast,0,ChH,0,2,Breite,17*ChH);
  906.       Ausgabe(Mode)
  907.     END
  908.     Else
  909.     IF Mode=Structure THEN
  910.       BEGIN
  911.         Scrollraster(MyRast,0,ChH,0,2,Breite,17*ChH);
  912.         CalcZ0;
  913.         StructZeileAus(Zeile0+15,15);
  914.       END
  915.   END;
  916.  
  917.  
  918. PROCEDURE Scroll16Up;
  919.   BEGIN
  920.     IF Mode<=AsciiDump THEN BEGIN
  921.       IF Mode=Asciidump THEN Adr:=Adr-16*64
  922.       Else Adr:=Adr-256;
  923.       Ausgabe(Mode) END
  924.   END;
  925.  
  926.  
  927. PROCEDURE Scroll16Down;
  928.   BEGIN
  929.     IF Mode<=AsciiDump THEN BEGIN
  930.       IF Mode=Asciidump THEN Adr:=Adr+16*64
  931.       Else Adr:=Adr+256;
  932.       Ausgabe(Mode) END
  933.   END;
  934.  
  935.  
  936.  
  937. PROCEDURE CursorUp;
  938.   VAR zz: integer;
  939.   BEGIN
  940.     IF Mode=Structure THEN
  941.       BEGIN
  942.         SetCursor;
  943.         zz:=Zeile0;
  944.         Zeile:=Zeile-1;
  945.         CalcZ0;
  946.         CursorAdr:=Adr+Struct[Zeile].Offset;
  947.         IF zz<>Zeile0 THEN Scroll1Up;
  948.         StructZeileAus(Zeile,Zeile-Zeile0);
  949.         SetCursor
  950.       END
  951.     Else
  952.     IF Zeile>0 THEN BEGIN SetCursor; Zeile:=Zeile-1; SetCursor END
  953.     Else
  954.       BEGIN
  955.         Case Mode Of
  956.           Asciidump: Adr:=Adr-64;
  957.           ByteDump,WordDump,LongDump: Adr:=Adr-16
  958.         Else END;
  959.         Scroll1Up
  960.       END
  961.   END;
  962.  
  963. PROCEDURE CursorDown;
  964.   VAR zz: integer;
  965.   BEGIN
  966.     IF Mode=Structure THEN
  967.       BEGIN
  968.         SetCursor;
  969.         zz:=Zeile0;
  970.         Zeile:=Zeile+1;
  971.         CalcZ0;
  972.         CursorAdr:=Adr+Struct[Zeile].Offset;
  973.         IF Zeile0<>zz THEN Scroll1Down;
  974.         StructZeileAus(Zeile,Zeile-Zeile0);
  975.         SetCursor
  976.       END
  977.     Else
  978.     IF Zeile<15 THEN BEGIN SetCursor; Zeile:=Zeile+1; SetCursor END
  979.     Else
  980.       BEGIN
  981.         Case Mode Of
  982.           Asciidump: Adr:=Adr+64;
  983.           ByteDump,WordDump,LongDump: Adr:=Adr+16
  984.         Else END;
  985.         Scroll1Down
  986.       END
  987.   END;
  988.  
  989. PROCEDURE CursorLeft;
  990.   BEGIN
  991.     IF Mode<=AsciiDump THEN
  992.       IF Spalte>=FieldSize[Mode] THEN
  993.         BEGIN SetCursor;
  994.           Spalte:=(Spalte and (64-Fieldsize[Mode]))-Fieldsize[Mode];
  995.           SetCursor
  996.         END
  997.       Else
  998.         BEGIN CursorUp; SetCursor;
  999.           Spalte:=LineSize[Mode]-Fieldsize[Mode]; SetCursor
  1000.         END;
  1001.   END;
  1002.  
  1003. PROCEDURE CursorRight;
  1004.   BEGIN
  1005.     IF Mode<=AsciiDump THEN
  1006.       IF Spalte < LineSize[Mode]-Fieldsize[Mode] THEN
  1007.         BEGIN SetCursor;
  1008.           Spalte:=(Spalte and (64-Fieldsize[Mode]))+Fieldsize[Mode];
  1009.           SetCursor
  1010.         END
  1011.       Else
  1012.         BEGIN CursorDown; SetCursor; Spalte:=0; SetCursor END
  1013.   END;
  1014.  
  1015. PROCEDURE CalcCursorAdr;
  1016.   { CursorAdr stezen }
  1017.   BEGIN
  1018.     IF mode<=Asciidump THEN
  1019.       Cursoradr:=Adr+Zeile*Linesize[mode]+Spalte
  1020.     Else
  1021.     IF mode=Structure THEN
  1022.       CursorAdr:=Adr+struct[Zeile].Offset
  1023.     Else CursorAdr:=Adr
  1024.   END;
  1025.  
  1026.  
  1027. PROCEDURE Jump;
  1028.   BEGIN
  1029.     Erinnere;
  1030.     IF Mode<AsciiDump THEN
  1031.       BEGIN
  1032.         CalcCursorAdr;
  1033.         Adr:=PeekL(CursorAdr and $fffffe);
  1034.         Zeile:=0;
  1035.         Spalte:=0;
  1036.         Ausgabe(Mode)
  1037.       END
  1038.     Else IF Mode=Structure THEN
  1039.       BEGIN
  1040.         Case struct[Zeile].typ Of
  1041.           t_str:BEGIN
  1042.                   CalcCursorAdr;
  1043.                   Adr:=CursorAdr;
  1044.                   Zeile:=0; Spalte:=0;
  1045.                   Mode:=AsciiDump;
  1046.                   Ausgabe(Mode)
  1047.                 END;
  1048.           t_L:BEGIN
  1049.                 Adr:=PeekL((Adr+struct[Zeile].Offset)and $fffffe);
  1050.                 CursorAdr:=Adr;
  1051.                 IF struct[Zeile].SubNum=0 THEN
  1052.                   BEGIN
  1053.                     mode:=ByteDump; Zeile:=0; Spalte:=0
  1054.                   END
  1055.                 Else
  1056.                   BEGIN mode:=structure;
  1057.                     Adr:=Adr and $fffffe; CursorAdr:=Adr;
  1058.                     CreateStruct(struct[Zeile].SubNum)
  1059.                   END;
  1060.                 Ausgabe(Mode)
  1061.               END;
  1062.           t_Sub:BEGIN
  1063.                 Adr:=Adr+struct[Zeile].Offset;
  1064.                 CursorAdr:=Adr;
  1065.                 IF struct[Zeile].SubNum=0 THEN
  1066.                   BEGIN
  1067.                     mode:=ByteDump; Zeile:=0; Spalte:=0
  1068.                   END
  1069.                 Else
  1070.                   BEGIN mode:=structure;
  1071.                     Adr:=Adr and $fffffe; CursorAdr:=Adr;
  1072.                     CreateStruct(struct[Zeile].SubNum)
  1073.                   END;
  1074.                 Ausgabe(Mode)
  1075.               END;
  1076.         Else END;
  1077.       END;
  1078.   END; { PROCEDURE Jump }
  1079.  
  1080.  
  1081. PROCEDURE JumpBack;
  1082.   BEGIN
  1083.     IF RemAnz>0 THEN
  1084.     BEGIN
  1085.       Adr:=   Remembers[RemAnz].Adr;
  1086.       Zeile:= Remembers[RemAnz].Zeile;
  1087.       Spalte:=Remembers[RemAnz].Spalte;
  1088.       StrNum:=Remembers[RemAnz].StrNum;
  1089.       Mode:=  Remembers[RemAnz].Mode
  1090.       RemAnz:=RemAnz-1
  1091.       CalcCursorAdr;
  1092.       Clear;
  1093.       IF Mode=Structure THEN CreateStruct(StrNum);
  1094.       Ausgabe(Mode)
  1095.     END
  1096.     Else DisplayBeep(MyScreen)   { Remember-Buffer ist leer }
  1097.   END;
  1098.  
  1099.  
  1100. PROCEDURE ReadFromKeyboard;
  1101.   VAR c1: Char;
  1102.   BEGIN
  1103.     ch:=ReadCon(Con);            { Zeichen von Tastatur? }
  1104.     IF ch=chr($9b) THEN
  1105.       BEGIN
  1106.         c1:=ReadCon(Con);    { erstes Zeichen der Escape-Sequenz }
  1107.         Case c1 Of
  1108.         'A': ch:=CrsrUKey;
  1109.         'B': ch:=CrsrDKey;
  1110.         'C': ch:=CrsrRKey;
  1111.         'D': ch:=CrsrLKey;
  1112.         Else ch:=chr(0) END;     { unbekannte Sequenz }
  1113.       END
  1114.   END;
  1115.  
  1116.  
  1117. PROCEDURE MenuHandling(item:Cardinal);
  1118.   { Menu-Handhabung }
  1119.   VAR menue,menitem,subitem:integer;
  1120.   BEGIN
  1121.     IF item<>$ffff THEN
  1122.       BEGIN
  1123.         { in "item" sind Menü-, Menüpunkt- unt Untermenü-nummer enthalten. }
  1124.         menue:=item and $1f;
  1125.         menitem:=(item and $7e0) div 32;
  1126.         subitem:=(item and $f800) div 2048;
  1127.         Case menue of
  1128.           0:Case menitem of  { Menu "Project" }
  1129.              0: BEGIN Mode:=Nix; TextPage:=0; Clear; Ausgabe(Mode) END;
  1130.              1: BEGIN Mode:=Nix; TextPage:=1; Clear; Ausgabe(Mode) END;
  1131.              2: ENDe:=true
  1132.             END;
  1133.           1:IF menitem<4 THEN { Menu "Mode" }
  1134.               BEGIN
  1135.                IF menitem<>ord(Mode) THEN
  1136.                  BEGIN
  1137.                    IF Mode<=AsciiDump THEN
  1138.                      CursorAdr:=Adr+Linesize[Mode]*Zeile+Spalte;
  1139.                    Mode:=Modes(menitem);
  1140.                    IF Mode<=AsciiDump THEN
  1141.                      BEGIN
  1142.                        Zeile :=(CursorAdr-Adr)div LineSize[Mode];
  1143.                        Spalte:=(CursorAdr-Adr)mod LineSize[Mode];
  1144.                        Adr:=Adr+16*LineSize[Mode]*(Zeile div 16);
  1145.                        Zeile:=Zeile mod 16
  1146.                      END;
  1147.                    Clear;
  1148.                    Ausgabe(Mode)
  1149.                  END
  1150.              END
  1151.            Else
  1152.              IF menitem=4 THEN
  1153.                BEGIN
  1154.                  Adr:=Adr and $fffffe;
  1155.                  IF Mode<=AsciiDump THEN
  1156.                    CursorAdr:=Adr+Linesize[Mode]*Zeile+Spalte;
  1157.                  CreateStruct(subitem+1);
  1158.                  Mode:=Structure;
  1159.                  Clear;
  1160.                  Ausgabe(Mode)
  1161.                END
  1162.            Else
  1163.              IF Menitem=5 THEN
  1164.                BEGIN
  1165.                  Adr:=Adr and $fffffe;
  1166.                  IF Mode<=AsciiDump THEN
  1167.                    CursorAdr:=Adr+Linesize[Mode]*Zeile+Spalte;
  1168.                  CreateStruct(subitem+100);
  1169.                  Mode:=Structure;
  1170.                  Clear;
  1171.                  Ausgabe(Mode)
  1172.                END;
  1173.         2:BEGIN { Menu "Adress" }
  1174.             Case Menitem Of
  1175.               0: BEGIN
  1176.                   Erinnere;
  1177.                   Mode:=LongDump;
  1178.                   Adr:=0; CursorAdr:=0;
  1179.                   Zeile:=0; Spalte:=0;
  1180.                   Clear;
  1181.                   Ausgabe(Mode)
  1182.                  END;
  1183.               1: BEGIN
  1184.                   Erinnere;
  1185.                   Mode:=Structure;
  1186.                   Adr:=Long(SysBase); CursorAdr:=Adr;
  1187.                   CreateStruct(1);
  1188.                   Clear;
  1189.                   Ausgabe(Mode)
  1190.                  END;
  1191.               2: BEGIN
  1192.                   Erinnere;
  1193.                   Mode:=Structure;
  1194.                   Adr:=Long(IntuitionBase); CursorAdr:=Adr;
  1195.                   CreateStruct(100);
  1196.                   Clear;
  1197.                   Ausgabe(Mode)
  1198.                  END;
  1199.             Otherwise END;
  1200.           END
  1201.         END;
  1202.       END
  1203.   END;
  1204.  
  1205.  
  1206. PROCEDURE GadgetHandling(g:p_Gadget);
  1207.   VAR i:integer;
  1208.   BEGIN
  1209.     IF g<>Nil THEN
  1210.       Case g^.GadgetID of
  1211.         1:Scroll1Up;
  1212.         2:Scroll1Down;
  1213.         3:Scroll16Up;
  1214.         4:Scroll16Down;
  1215.         5:IF Mode<=Asciidump THEN
  1216.            BEGIN
  1217.              Case Mode Of
  1218.                ByteDump,Asciidump: Adr:=Adr+1;
  1219.                WordDump: Adr:=(Adr and $fffffe)+2;
  1220.                LongDump: Adr:=(Adr and $fffffe)+4;
  1221.              END;
  1222.              Ausgabe(Mode)
  1223.            END;
  1224.         6:IF Mode<=Asciidump THEN
  1225.            BEGIN
  1226.              Case Mode Of
  1227.                ByteDump,Asciidump: Adr:=Adr-1;
  1228.                WordDump: Adr:=(Adr and $fffffe)-2;
  1229.                LongDump: Adr:=(Adr and $fffffe)-4;
  1230.              END;
  1231.              Ausgabe(Mode)
  1232.            END;
  1233.       Otherwise; END;
  1234.   END;
  1235.  
  1236.  
  1237. BEGIN       {***** Hauptprogramm *****}
  1238.   Initialise;
  1239.   ENDe:=false;
  1240.   Ausgabe(Mode);
  1241.   { HauptschleIFe (Achtung: lang!) }
  1242.   Repeat
  1243.     { Message-Management }
  1244.     Mess:=Get_Msg(MyUPt);        { Nachricht am Userport? }
  1245.     While Mess<>Nil Do
  1246.       BEGIN
  1247.         Klasse:=Mess^.Class;     { ja, Typ ermitteln }
  1248.         IF Klasse and MENUPICK<>0 THEN Menuhandling(Mess^.Code);
  1249.         IF Klasse and GADGETDOWN<>0 THEN Gadgethandling(Mess^.IAddress);;
  1250.         Reply_Msg(Mess);
  1251.         Mess:=Get_Msg(MyUPt);
  1252.       END;
  1253.     ReadFromKeyboard;
  1254.     Case ch Of
  1255.       EscKey:  ENDe:=true;      { Esc-Taste }
  1256.       CrsrUKey:IF (mode<=AsciiDump) or ((mode=Structure) and (Zeile>1)) THEN
  1257.                  CursorUp;
  1258.       CrsrDKey:IF (mode<=AsciiDump) or ((mode=structure) and (Zeile<FeldAnz)) THEN
  1259.                  CursorDown;
  1260.       CrsrRKey:CursorRight;
  1261.       CrsrLKey:CursorLeft;
  1262.       'j','J': Jump;
  1263.       'b','B': JumpBack;
  1264.     Otherwise END ;    { ENDe von Case }
  1265.     Repeat
  1266.       ch:=ReadCon(Con)
  1267.     Until ch=chr(0);  { Tastenpuffer ganz leeren, um Nachlaufen zu vermeiden }
  1268.     IF not ENDe THEN
  1269.       { Auf dem Amiga zählen Warteschleifen zu den 7 Todsünden (bzw. zu  }
  1270.       { "den 7 tödlichen Zwergen" (Alf)). Deshalb ist folgENDermaßen auf }
  1271.       { das nächste Ereignis zu warten: }
  1272.       Sig:=Wait(-1);
  1273.   Until ENDe;      { ENDe der HauptschleIFe }
  1274.   CloseEverything  { ProgrammENDe }
  1275. END.
  1276.  
  1277.