Array in Assembler programmieren

[Tobias Mehrl (Gast)]

Hi Leute!

Ich hab ein Problem mit dieser Aufgabe:

In MACROS.ASM sind folgende Makros definiert, die Sie verwenden können:
ClrScr Löscht den User-Bildschirm
Set_Cursor Zeile, Spalte Setzt den Cursor an bestimmte Position Zeile 
und Spalte sind Bytes!
Read_KBD_and_Echo liest ein Zeichen (Byte) in Al ein und zeigt es am
Bildschirm an
Display_Char gibt ein Zeichen (aus DL) auf den Bildschirm aus
Einwickeln Sie nun ein Programm, mit dem Sie ein bestimmtes Element (M[i 
, j])
einer n x m – Matirx , einlesen können.
Die Eingabe von i und j soll über die Tastatur erfolgen – m und n können 
Sie fest vorgeben!
Es sollen nur Zahlen eingegeben werden können – ohne Vorzeichen!
Die Elemente der Matrix sollen jeweils 16-Bit groß sein!
Die Elemente der Matrix sollen mit 0FFFFh vorbelegt werden!
Nach der Eingabe des Elementes M(i,j) soll die Matrix auf den Bildschirm 
ausgegeben werden!

Hier nun mein bisheriger Lösungsansatz:

; --------------------------------------- Dateiname: a52.ASM ----------------------------------------------
; Array in Assembler
;
;
;------------------------------------------------------------------------------------------------------------------------------

%noctls                          ; Listing-Steueranweisungen werden nicht im Listing augegeben
%noincl                          ; Incude-Dateien werden nicht im Listing ausgegeben

INCLUDE MACROS.ASM                     ; Datei Macros.asm einbinden
ASSUME CS:CODE, DS:DATA                 ; Segmentnamen bekannt geben
                            ; „CODE“ wird Codesegment, „DATA“ wird Datensegment

;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
DATA    SEGMENT                    ; Beginn des Segmentes „DATA“

array    DW  0AH    DUP(0FFFFh)
      DW  0AH    DUP(0FFFFh)
      DW  0AH    DUP(0FFFFh)
      
    i  DW  0h
    j  DW  0h
  zahl  DW  0h

DATA    ENDS                    ; Ende des Segmentes „DATA“
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

;-------------------------------------------------------------------------------------------------------------------------------
CODE     SEGMENT                    ; Beginn des Segmentes „CODE“

Anfang:    
; Zahll nach i einlesen:
      Read_KBD_and_Echo              ; Zeichen für i (Zeile) entgegennehmen
      SUB AX,30h                  ; Zahl berechnen
      XOR AH,AH                  ; Funktionsaufruf löschen
      MOV i,AX                  ; Zahl nach BX kopieren
      
; Zahl nach j einlesen:    
      Read_KBD_and_Echo              ; Zeichen für j (Spalte) entgegennehmen
      SUB AX,30h                  ; Zahl berechnen
      XOR AH,AH                  ; Funktionsaufruf löschen
      MOV j,AX                  ; Zahl nach DI kopieren
      
; Zahl nach DI einlesen:      
      Read_KBD_and_Echo              ; Zeichen für Element entgegennehmen
      SUB AX,30h                  ; Zahl berechnen
      XOR AH,AH                  ; Funktionsaufruf löschen
      MOV zahl,AX                  ; Zahl nach DI kopieren
      
; "zahl" in Abhängigkeit von "i" und "j" an die richtige Stelle schreiben
      
      MOV BX,i
      MOV DI,j
      
      MOV SI,[array[BX][DI]]
      MOV WORD PTR[SI],zahl
      
      MOV DL,array[BX][DI]
      ADD DL,30
      Display_Char
      
      
      Terminate_Program              ; Makro Terminate_Program aufrufen

CODE    ENDS                    ; Ende des Segmentes „CODE“
;-------------------------------------------------------------------------------------------------------------------------------

END Anfang                        ; Ende des Programms
                            ; Programm wird bei Anfang gestartet

Das Problem an meinem Code ist nur, dass wenn ich ihn assembliere ich 
zwei fehler bekomme. Nämlich: Zweile 56 und 58. Ich hab allgemein das 
Problem jetzt, dass ich nicht recht weiß, wie ich dem Programm jetzt 
beibringen soll, dass er mir die "Zahl" an die Stelle in Abhängigkeit 
von i und j schreiben soll.

Könnt ihr mir bis zur Lösung meines Problems stückchenweise helfen?

Edit: Womit auch immer noch Probleme hab, ist dieser Befehl mov WORD 
PTR[]... Könnt ihr mir mal da genau erklären was Sache ist? Ich finde 
dazu auch nicht wirklich was in meiner Literatur und im Internet find 
ich auch nix!

Danke!

[Tobias Mehrl (Gast)]

Hi!

sorry, die Zeilen 56 und 58 sind die Zeilen: MOV WORD PTR[SI],zahl / 
MOV DL,array[BX][DI].

Programmieren tu ich nun 8086 mit dem TASM. Ich denke die 
Aufgabenstellung ist klar. Ich hab mir in i und j quasi die Koordinaten 
geschrieben an welcher Stelle ich das Element schreiben will und in zahl 
steht eben die Zahl die an die bestimmte Stelle im Array reinsoll. Mein 
Problem besteht jetzt nur noch darin die besagte zahl an die richtige 
Stelle in Abhängigkeit von i und j zu schreiben.

Ich weiß hier aber echt nicht weiter...

[Richards, Ben (Gast)]

>MOV SI,[array[BX][DI]]
Der Befehl ist nicht gültig. Entweder nur das Displacement aus BX+DI 
ohne Konstante (array) oder jeweils BX oder DI mit Konstante.

>MOV WORD PTR[SI],zahl
Schreibt eine 16bit-konstante in die Speicherzelle mit dem SI-Register 
als Index.

>MOV DL,array[BX][DI]
wie 1.

Schön das mein beim Studium lernt, wie man Eingabe-Routinen mit 
Assembler programmiert. Schade um die Zeit.

[compilator (Gast)]

Sieht für mich nach x86 real mode aus. Beschäftige dich mal mit 
Segment:Offset und zB dem LODS oder STOS Instruktion. Mit PTR weist du 
den Assembler darauf hin, dassdu indirekt adressieren willst. Die 
Indizes kannst du teilweise sogar mit Addition aufbohren. rtfm X86 
assembly, bei Intel halt mal runterladen und Kapitel zu real mode und 
MOV durcharbeiten.

[Tobias Mehrl (Gast)]

@ Richards Ben:

Wie hast du das gemeint? "Schön das mein beim Studium lernt, wie man 
Eingabe-Routinen mit Assembler programmiert. Schade um die Zeit."

Irgendeinen Grund wird mein Prof schon haben, oder?

[Andreas (Gast)]

Der hat kein bock neue Unterlagen zu erarbeiten ;-))

Gruß
Andreas

[Tobias Mehrl (Gast)]

Aber was ist denn an assembler eingabe-routinen so falsch?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Aber was ist denn an assembler eingabe-routinen so falsch?

Es ist eine sinnlose Aufgabe

Ausser Systemprogrammierern auf Treiberebene und eventuell noch ein paar 
Spieleprogrammierer in ihren innersten Kernfunktionen, programmiert kein 
Mensch mehr auf dem PC in Assembler. Bringt auch nix. Noch nicht einmal 
Geschwindigkeit. Dazu sind heutige CPU zu komplex mit ihren Pipelining 
Architekturen als das man als Neuling einen Compiler schlagen könnte.

Das ist ungefähr so, wie wenn du Altbabylonisch lernen würdest. Ausser 
ein paar Spezialisten braucht das kein Mensch mehr.

[Icke (Gast)]

Fegt aber den Kalk aus der Gedächtnishalle.

zum Thema.

Die WORD PTR etc. Konstrukte braucht der Assembler da er bei Befehlen in 
denen kein Register Ziel oder Quelle die Größe nicht weiß.