mem aus TurboPascal

[JamesTKirk]

Hi Leutz!

Ich bin vor kurzem im Internet auf eine Facharbeit zum Thema computergenerierte Hologramme gestoßen, bei welcher auch der dazugehörige Pascalcode dabei ist.
Da ich auch mal in TurboPascal programmiert hab, dachte ich mir, ich portiere das Ganze auf Delphi.
Doch dann bin ich leider an dem Array "mem" hängen geblieben, von dem ich nicht weiß, wie ich das am klügsten in Delphi schreibe.

MfG, Sven

[Zacherl]

Fragst du wie man das Array deklarieren soll?
Wie ist das Array denn im Pascal Code deklariert?

Ist das ein dynamisches Array?

Delphi-Quellcode:

var
  mem: array of string;

oder ein statisches?

Delphi-Quellcode:

var
  mem: array[0..100] of string;

Florian

[JamesTKirk]

Das Array ist eines, das von Pascal zur Verfügung gestellt wird. Ich schau mal schnell, ob ich irgendwo noch Pascal rumkurven hab... (wegen der Hilfe)

Im übrigen gibt's dynamische Arrays erst ab Delphi 4...

[Zacherl]

Im übrigen gibt's dynamische Arrays erst ab Delphi 4... Vergesse ich manchmal, da ich nie richtig mit einer Delphi Version unter 7.0 gearbeitet habe.

Welche Werte stehen denn in dem Array?

[JamesTKirk]

Hab mal schnell die Pascal Hilfe ausgebuddelt:

Zitat von Pascal Hilfe:

Turbo Pascal stellt drei vordefinierte Arrays zur Verfügung, die direkte Zugriffe auf einzelne Speicheraddressen ermöglichen: Mem, MemW und MemL.

Jedes Element von Mem ist ein Byte.
Jedes Element von MemW ist ein Word.
Jedes Element von MemL ist ein LongInt.

Alle drei verwenden eine spezielle Notation für ihre Indizes: Zwei Ausdrücke des Typs Word, die durch einen Doppelpunkt voneinander getrennt sind. Diese Ausdrücke geben die Segment- und Offset-Addresse der jeweiligen Speicherzelle an.

Mehr steht nicht in der Hilfe und mehr weiß ich auch nicht....

[Zacherl]

Schein eine Zugriff auf den Speicher des Programms darzustellen. Da kenne ich mich leider nicht aus. Ich denke aber mit einem MemoryStream dürfte man das ähnlich handhaben können.

Florian

[JamesTKirk]

Werd ich dann mal austesten... Danke soweit mal...

[Hansa]

Mem dient zum direkten setzen und lesen des Speichers. Z.B. : mem [$1000:$1009] := 5; oder MyVar := mem [$1000:$1009] Ist also wohl kaum zu empfehlen.

[Flocke]

Zitat von Hansa:

Mem dient zum direkten setzen und lesen des Speichers. Z.B. : mem [$1000:$1009] := 5; oder MyVar := mem [$1000:$1009]

Stimmt genau.

Mem wurde dazu benutzt, an bestimmten Speicheradressen Werte zu lesen und schreiben, häufig in den Videospeicher oder den Tastaturpuffer o.ä. Zeige mal die betreffenden Stellen im Quelltext, dann können wir dir ggf. sagen, was damit bezweckt wird und wie man es unter Windows abbilden kann.

[JamesTKirk]

Aber gerne zeige ich die Stelle...

Delphi-Quellcode:

(* 
   Legende:
    //...: Meine Kommentare
    {...}: Kommentare des Autors
*)

// globale Vars / Consts / Types
const
    entf=40; {z-Koordinate des Objekts Std: 40}
    Staffelung=0; {z-Koordinatendifferenz von einem Buchstaben zum nächsten Std: 0}
    Wort='Laser';
    wortx=0.08; worty=-0.17; {Koord. des Wortbeginns Std: 0.08, -0.17}
    breite=0.16; hoehe=0.17; {Größe eines 8*8 Bit Punkterasters Std: 0.16, 0.17}
    Abstand=0.17; {Buchstabenabstand Std: 0.17}

type 
    punkttyp=array[1..3] of real;

vars
  p: array[0..200] of punkttyp; {Array zum Speichern d. Punktkoordinaten}
  punkte: integer; {Anzahl der Punkte für das Wort}

// Das Objekt der Begierde ist diese Funktion....
function objekt: integer; {Wandelt die Zeichenkette in Punkteraster um}
 const
  segcg: word=$F000; ofscg: word=$FA6E; {Segment und Offsetadresse wo
              man das Rasterpunktmuster herauslesen kann}
 var
  i, j, bnr, r, sp: integer; {bnr: Buchstabennr; r: Reihe; sp: Spalte}
  asc, zbyte, zpot: byte; {asc: ascii-Code d. Zeiches; zbyte: Zeile d. binären Punkterasters; 
                     zpot: zur Kontrolle ob Bit gesetzt oder nicht}
  hstr: string; {Aktuelles Zeichen}
begin
 punkte:=0;
 for bnr:=0 to length(wort)-1 do begin {Für jeden Buchstaben die Schleife durchlaufen}
  hstr:=copy(wort,bnr+1,1); {hstr: Aktueller Buchstabe}
  asc:=ord(hstr[1]); {asc: Ascii-Wert d. Buchstaben}
  for r:=0 to 7 do begin {jeder Buchstabe hat 8 Zeilen, wobei jede
   Zeile der Reihe nach ausgelesen wird}
   
   //Hier ist das Mem Zeugs
   
   if asc<128 then begin {diese Zeile auslesen}
    ofscg:=$FA6E;
    segcg:=$F000;
    zbyte:=mem[segcg:ofscg+8*asc+r];
   end else begin
    ofscg:=mem[0:4*$1F]+256*mem[0:4*$1F+1]+8*(asc-128)+r;
    segcg:=mem[0:4*$1F+2]+256*mem[0:4*$1F+3];
    zbyte:=mem[segcg:ofscg];
   end;
   zpot:=128; {=10000000b}
   for sp:=0 to 7 do begin {Jedes Bit durchlaufen}
    if (zbyte and zpot)=zpot then begin {Falls Bit gesetzt dann Punkt speichern}
     inc(punkte); {Punktanzahl um eins erhöhen}
     p[punkte,1]:=wortx+abstand*bnr+sp*breite/8; {=Objektbeginn+ Zeichenabstand*
     Zeichen + Punktnummer*Zeichenbreite/8
     (8 Punkte pro Zeichenzeile)}
     p[punkte,2]:=worty+r*hoehe/8; {Objektbeginn + Pixelreihe* Höhe/8}
     p[punkte,3]:=entf+staffelung*bnr; {Abstand in z-Richtung + Staffelung}
    end;
    zpot:=zpot div 2; {Einser in Binärzahl rückt um 1 Stelle nach rechts}
   end;
  end;
 end;
 objekt:=punkte;
end;

Ich hoff ich hab alle Consts, Vars und Types erwischt... und ich hoffe, dass ihr schlauer draus werdet, als ich.... die Daten die hier jetzt berechnet wurden sind zur Berechnung des Interferenz Bildes notwendig... doch das ist ne andere Geschichte... äh... Prozedur (musste sein)