Assemblercode in Modula-2

Konvertierungsprogramm von Assemblercode zu Modula-2

Modula-2 besitzt gegenüber seinem Vorgänger Pascal einige Vorteile, von denen die Systemnähe nur einer ist.

Möchte man diese nun nutzen, also z. B. Maschinensprache direkt in die Programmierung einzubeziehen, so stößt man auf ein kleines Hindernis, welches das nachfolgende Programm auszuräumen vermag. Der Modula-2 Compiler von TDI vermag zwar Maschinencode mit dem CODE-Befehl aus dem SYSTEM-Modul in ein Programm einzubinden, diese können jedoch nicht im Assembler-Code vorliegen, da hierzu im Compiler zusätzlich ein Assembler eingebaut sein müßte. Ein externer Assembler ist also für ein normales Arbeiten nötig. Es stellt sich jedoch die Frage, wie man sein assembliertes Programm jetzt in Modula-2 hineinbekommt. Das nachfolgende Programm demonstriert die-s am Beispiel des GST-C Assemblers.

Bedienung des Programms:

Bei dem Assemblieren eines Programms wird vorher im Assemble-Menü die Option (Programmlisting?) angewählt und danach mit (Assemble...) der Assemblevorgang eingeleitet. Hierbei entsteht ein Zusatzfile Name.LST, in dem außer dem Maschinencode auch noch der Assemblercode enthalten ist. Das nachfolgende Programm wird nun aufgerufen und erstellt ein Name.MOD File, das vom Modula-2-Editor mit der Funktion (Read from...) an die gewünschte Stelle gebracht werden kann. Der Assemblercode taucht in Modula als Bemerkung hinter dem jeweiligen Maschinenbefehl auf.

Somit ist die Programmierung von Maschinensprache in Modula-2 kein Problem mehr.

MODULE AssTransfer;

FROM InOut IMPORT OpenInputFile, OpenOutputFile, CloseInput,
CloseOutput,WriteString,WriteLn,Read,Write,WriteCard,ReadString.Done; 
FROM String IMPORT Length.Concat;
FROM GEMDOS	IMPORT Delete,SetDrv;
FROftJ SYSTEM IMPORT CODE,ADDRESS.ADR;
FROM AESForms IMPORT FileSelectorInput;
FROM VDIEscapes IMPORT CursorAddress;
FROM AESGraphics IMPORT GrafHandle;

VAR	String,Name1,Name2 : ARRAY [0..80] OF CHAR; 
	a, b, i, j : CARDINAL;
	Ch : CHAR; 
	dummy : BOOLEAN; 
	handle,dum : INTEGER;
	Titel,Auswahl : ADDRESS; 
	dumm ; LONGCARD;

PROCEDURE HexDec;
BEGIN
	b := ORD (String [i]) - 48;
	IF b > 9 THEN DEC (b.7) END;
	INC (i);
END HexDec;

BEGIN
	handle GrafHandle (dum,dum,dum,dum);
	CursorAddress (handle,1,18);
	WriteString ("GST-C Assemblerlistfile zu Modula-2 Converter");
	String := "A:\*.LST";
	Titel := ADR (String);
	Auswahl := ADR (Name1);
	FileSelectorlnput (Tite1.Auswahl,dum) ;
	IF dum = 1 THEN
		i := ORD(String[0]) - 65;
		SetDrv (i.dumm); 
		dum := 1;
		REPEAT
			INC (dum);
			Name2 [dum] := Name1 [dum] ;
		UNTIL Name1 [dum] -OpenlnputFile (Name1);
		String "MOD";
		Concat (Name2,String,Name1); 
		dummy := Delete (Name1);
		OpenOutputFile (Name1);
		REPEAT
			REPEAT
				String [5] := "  ";
				ReadString (String); 
				ch := String [7];
			UNTIL ((String [5] - "0") AND (String [17] > 570) OR (ch = "m");
			IF ch <> "m" THEN
				WriteString (" CODE ("); 
				i := 17; j := i;
				REPEAT
					IF j <> i THEN Write (",") END;
					HexDec; a := 4096 * b;
					HexDec; INC (a,256 * b);
					HexDec; INC (a,16 * b);
					HexDec; INC (a,b);
					WriteCard (a,1);
				UNTIL String [i] < "0";
				WriteString (");	");
				WHILE i < 29 DO
					WriteString ("	");
					INC (i.4);
				END;
				REPEAT 
					INC (i);
				UNTIL String [i] < 47C;
				WriteString ("(*");
				FOR j	:=i TO Length (String) DO Write (String [j]) END;
				WriteString ("*)");
				WriteLn;
			END;
		UNTIL ch = "m";
		CloseInput;
		CloseOutput;
	END;
END AssTransfer.

Konvertierungsprogramm in Modula-2

CODE (12408,10554);	(* MOVEA.W	$293A,A0 *)
CODE	(12035);	(* MOVE.L	D3,-(SP) *)
CODE	(12034);	(* MOVE.L	D2,-(SP) *)
CODE	(12033) ;	(* MOVE.L	D1,,-(SP) *)
CODE	(12032);	(* MOVE.L	D0,-(SP) MOVE.L	D1*)
CODE	(12040);	(* MOVE.L	A0,-(SP) *)
CODE	( 8248,10520);	(* MOVE.L	$2918,D0 *)
CODE (	640,65535,32768);	(* AND.L #$FFFF8000,D0 *)
CODE ( 8256);	(* MOVEA.L D0,A0 *)

Beispiel eines konvertierten Assemblerprogrammes (Ausschnitt)