Wie rechne ich ich bitte in TC3 diese 2 Werte um in Seg und Offs Adre.

[Peter B. (funkheld)]

Hallo , guten Tag.

Ich habe hier 2 Malloc-Adressen.

Wie rechne ich die jetzt bitte in Segm und Offs um.
Ich habe mit Large kompiliert.

Ich weiß das sie sich ändern, wollte nur bitte das Rechenschema.

Das haut nicht hin:
seg1=*p/16;
offs1=*p-seg1;

Danke.

[Was ist ein Pointer? (Gast)]

Peter B. schrieb:
> seg1=*p/16;

Du willst höchstwahrscheinlich nicht (*p)/16 sondern p/16 rechnen.

[foobar (Gast)]

Ich bin mir nicht sicher, ob ich die Frage richtig verstanden habe, der 
Screenshot ist nicht wirklich aussagekräftig.  Könntest du nicht ein 
Video machen, wo das Problem genauer erklärt wird?

[cppbert (Gast)]

foobar schrieb:
> Ich bin mir nicht sicher, ob ich die Frage richtig verstanden
> habe, der
> Screenshot ist nicht wirklich aussagekräftig.  Könntest du nicht ein
> Video machen, wo das Problem genauer erklärt

Ich werde alt...

[cppbert (Gast)]

#include dos.h

MK_SEG und MK_OFS

Macros

seg = MK_SEG(ptr);

[Mario M. (thelonging)]

Unabhängig vom Rechenweg, sind die Adressen viel zu groß, um verlustfrei 
in Segment und Offset aufgeteilt zu werden.

[cppbert (Gast)]

Und wie immer: nicht ohne Beispiel?

Es ist nicht klar ob du vielleicht deinen ptr falsch castest oder sowas 
und deswegen komische Ergebnisse kommen...

MK_FP erzeugt einen far pointer

Also sollte etwas in der Form funktionieren

int far* cptr = ... malloc oder sonstiger far pointer
assert(MK_FP(cptr),MK_OFS(cptr))==cptr);

[cppbert (Gast)]

cppbert schrieb:
> Und wie immer: nicht ohne Beispiel?
>
> Es ist nicht klar ob du vielleicht deinen ptr falsch castest oder sowas
> und deswegen komische Ergebnisse kommen...
>
> MK_FP erzeugt einen far pointer
>
> Also sollte etwas in der Form funktionieren
> int far* cptr = ... malloc oder sonstiger far pointer
> assert(MK_FP(cptr),MK_OFS(cptr))==cptr);

Auf dem Tablet tippen ist muell...

assert(MK_FP(MK_SEG(cptr),MK_OFS(cptr))==cptr);

[Programmierer (Gast)]

Was ist eine Malloc-Adresse? Die Adresse der Funktion malloc im 
Speicher? Meinst du nicht vielleicht einfach einen Pointer?

[Dirk B. (dirkb2)]

Wenn das ein far-pointer ist, sind das zwei 16 Bit Werte für Segment und 
Offset, die Zusammen in einem 32 Bit Wert gehalten werden. Highword ist 
Segment, Lowword ist Offset.

Als Hexwert ist das besser zu erkennen.

[Peter B. (funkheld)]

Hallo,guten Tag.


Ich möchte mit "movedata" den bestimmten Bereich aus malloc jeweils in 
den VGA-Bereich kopieren.
movedata(segment,offset,0xa000,0,64000);

-----------------------------------------------
Meinst du nicht vielleicht einfach einen Pointer?.......
----------------------------------------------
Wenn der Wert dann so  genannt wird : ja.


> Es ist nicht klar ob du vielleicht deinen ptr falsch castest oder sowas

Das mit dem Poken funktioniert ja:
---------------------------------------------
void mal_vga1(unsigned char* p)
{
  unsigned short y;

  for (y = 0; y <=63999; y++)
  {
     pokeb (VIDEO_SEGMENT, y,*(p+y));
  }
}

void mal_vga2(unsigned char* pp)
{
  unsigned short y;

  for (y = 0; y <=63999; y++)
  {
    pokeb (VIDEO_SEGMENT, y,*(pp+y));
  }
}
---------------------------------------------



Das ist mein Programm welches nicht funktioniert:

--------------------------------------------
#include <dos.h>
#include <conio.h>
#include <io.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <mem.h>

#define VIDEO_SEGMENT  0xA000
#define SCREEN_WIDTH   320

unsigned   char *p;
unsigned   char *pp;

void SetTextMode ()
{
    _AH = 0;
    _AL = 0x03;
    geninterrupt (0x10);
}

void SetMode13h ()
{
    _AH = 0;
    _AL = 0x13;
    geninterrupt (0x10);
}

void vga_cls ()
{
  long y;

  for (y = 0; y <= 64000; y++)
  {
    pokeb (VIDEO_SEGMENT, y, 0);
  }
}

void voll(unsigned char* p, unsigned char* pp)
{
  unsigned short y;

  for (y = 0; y <=63999; y++)
  {
    *(p+y)=117;
    *(pp+y)=45;
  }
}

int main ()
{
char cmd;

p = malloc(64000 * sizeof(char));
pp = malloc(64000 * sizeof(char));

SetMode13h ();

do
{
 cmd = toupper(getch());

 switch (cmd)
 {
   case 'Q':
     voll(p, pp);
   break;

   case 'W':
     movedata(segment,offset,0xa000,0,64000);
   break;

   case 'S':
     movedata(segment1,offset1,0xa000,0,64000);
    break;

   case 'C':
     vga_cls ();
   break;

  }

 } while (cmd != 'E');

   SetTextMode();
}
---------------------------------------

[Peter B. (funkheld)]

So sieht es nach meinen nicht korrekten Berechnungen aus wenn ich die 
erste Farbe aus dem 1. malloc-bereich nach VGA kopiere.

Die 2. Farbe reagiert dann nicht mehr.

Kann aber nach dem drücken von "E" zum Textmodus zurückschalten.
Programm ist nicht abgestürtz.

Gruss

[Dirk B. (dirkb2)]

Dafür sind die Makros FP_OFF und FP_SEG (aus dos.h) da.
(Ich habe hier ein Buch für Quick-C 2.0. Da steht, dass die Makros auch 
in Turbo-C 2 existieren.)

movedata(FP_SEG(pp),FP_OFF(pp),0xa000,0,64000);

Bedenke, dass du dafür far-Pointer brauchst.
Die kann man explizit definieren oder ein entsprechendes Speichermodell 
verwenden.

[Dirk B. (dirkb2)]

Peter B. schrieb:
> for (y = 0; y <= 64000; y++) // macht 64001 Durchläufe
> ....
> for (y = 0; y <=63999; y++)  // macht 64000 Durchläufe

Du solltest dir endlich mal den C-Style aneignen

for (y = 0; y < 64000; y++) // macht 64000 Durchläufe

Weil in der Bedingung die 64000 steht, sieht man sofort ohne 
Nachrechnen wieviele Durchläufe es sind.

Beachte auch, dass dort nur ein < steht (kein <=).

[Peter B. (funkheld)]

Danke für die Info und Hilfe.

Gruss

[Dirk B. (dirkb2)]

https://en.wikipedia.org/wiki/Far_pointer

Mit dem MK_FP Makro ist das aber besser.


Da ist auch noch ein Link zu 
https://en.wikipedia.org/wiki/Intel_Memory_Model

[Peter B. (funkheld)]

-------------------------
Mit dem MK_FP Makro ist das aber besser.
-------------------------

Wobei ist jetzt bitte der Vorteil bei meiner Grafikübertragung?

Gruss

[Dirk B. (dirkb2)]

Peter B. schrieb:
> -------------------------
> Mit dem MK_FP Makro ist das aber besser.
> -------------------------
>
> Wobei ist jetzt bitte der Vorteil bei meiner Grafikübertragung?
>
> Gruss

Hier nicht direkt.

Aber man könnte das Makro für eine andere Architektur ändern und der 
Code würde trotzdem funktionieren.