Newsgroup: it.comp.lang.c
Titolo: [FORSE OT] 32 bit.......argh....

Ciao a tutti!
Ho il seguente problema: sono passato al Visual C++ 5.0 (prima usavo il
Turbo C++ 3.0) per poter lavorare a 32 bit, senza lasciare l'ambiente MS-DOS
(windows console application). Sotto il TC++ avevo scritto una mia piccola
ma funzionale libreria grafica, che sfruttava sia il c che l'asm. Dopo
alcuni "ritocchini" (aggiornato le funzioni e cambiato la keyword asm con
_asm ...) ho compilato tutto e senza errori.
Il mio primo programma era giusto di prova, e doveva semplicemente sbattere
sullo schermo 64000 puntini colorati....
#include "Graph.h"
int main()
{
 register x,y;
 unsigned char color;
 initgraph();
 for(x=0;x<320;x++);
  for(y=0,color=0;y<200;y++,color++)
  {
   if(color==256)color=0;
   put_pixel(x,y,color,video_buffer);
  }
closegraph()
return 0;
}
ora...si pianta tutto!!!!
ecco le funzioni utilizzate qui:
void initgraph()
/* function per entrare nel modo grafico */
{
__asm{
 xor ax,ax
 mov ax,13h
 int 10h
   }
}
/*------------------------------------------------------------------------*/
void closegraph()
/* function per entrare in modalita testo */
{
__asm{
 xor ax,ax
 mov ax,3h
 int 10h
 }
}
/*------------------------------------------------------------------------*/
void put_pixel(int x,int y,int  color, unsigned char  *where)
/* Function per stampare un pixel a video : Full Assembly */
{
where[x+(y<<8)+(y<<6)]=color;
}
video_buffer è una variabile esterna:
unsigned char  *video_buffer = (char *)0xA0000000L;
perche si pianta?
Grazie in anticipo....
Tdx

Una applicazione win32 console non è la stessa cosa di una applicazione
ms-dos, così il buon vecchio windows non ti consente di chiamare l'interrupt
10h o accedere alla memoria video. Dovresti compilare la tua applicazione
con un compilatore dos a 32 bit, come il djgpp, che è free

 sullo schermo 64000 puntini colorati....
E a cosa ti servivano i puntatori cross-segment per fare un programma del
genere?
ciao

genere?
Veramente il programma in questione era solo di prova, serviva per vedere se
fungeva la modalita grafica, E NON FUNGE, e ora ho capito il perche grazie a
voi. A questo punto ho scaricato il DJGPP 2.02 (o giu di li..^_^) e ho messo
a posto 1 paio di cosuccie  nella mia libreria grafica. Pero cosi è
peggio...i famosi 32 bit non si vedono neanche lontanamente, tanto che
fatico ad allocare una immagine di pochi kb...... c'è una funzione per
attivare la modalità 32bit o no? Magari centrano sys/nearptr.h e go32.h che
li vedo dappertutto?!
Chi mi spiega come far fungere la 32 bit? Ho visto altri sorgenti ma...non
mettono nulla di piu di me, eppure i programmi in questione si ciucciano
tutta la memoria che vogliono....
dove sbaglio?

 dove sbaglio?
Probabilmente (è da un pezzo che non programmo con DJGPP) per accedere
alla vga direttamente stai usando la modalità reale. Io mi ricordo che
facevo
tutto in modalità protetta e poi copiavo il double buffer nell'area di
memoria
reale 0A000h:00000h con le funzioni del DPMI che adesso però non ricordo
ciao

 wrote in message sGIb5.11288
| Chi mi spiega come far fungere la 32 bit? Ho visto altri sorgenti
ma...non
| mettono nulla di piu di me, eppure i programmi in questione si ciucciano
| tutta la memoria che vogliono....
| dove sbaglio?
C'e' da qualche parte una FAQ sulla prog. grafica col djgpp (oltre al NG
dedicato, che gia' ho segnalto)
per una minima lib mooolto antica:
#include <pc.h>
#include <dpmi.h>
#include <go32.h>
#include <sys/nearptr.h>
#define byte unsigned char;  /* DA VERIFICARE A SECONDA DEL SISTEMA */
short _sel;        /* selettore globale mem. DOS */
byte* buf_screen;  /* screen buffer x double buffering */
byte* video_ptr = (byte*) 0x0a0000;
void wait_retrace() {    /* evita flickering */
    while (inportb(0x3da && 0x8)){};
    while (inportb(0x3da && 0x8)){};
}
void set_mode (short n){
    _go32_dpmi_registers regs;
 
regs.x.ax
 = n;
    __dpmi_int(0x10, &regs);    /* chiama int30h in PM */
    _sel = _dos_ds;             /* assegna il sel. dos di ritorno */
}
void set_text_mode(){
    set_mode(0x03);
}
void set_VGA_mode(){
    set_mode(0x13);
}
/* solo per mode 13h */
void put_pixel_13h( int x, int y, byte color) {
    __asm__ __volatile__("
    movl %1, %%ebx
    movl %0, %%ecx
    movl %%ebx, %%edx
    movl $0x0a00, %%edi
    shl  $6, %%ebx
    shl  $8, %%edx
    addl %%ecx, %%ebx
    movw %2, %%es
    addl %%edx, %%ebx
    movb %3, %%al
    addl %%ebx, %%edi
    stosb
    "
    :
    : "g" (x), "g" (y), "g" (_sel), "g" (color)
    : "ax ", "bx", "cx", "dx", "di", "memory"
    );
}