clrscr, gotoxy und textcolor in echtem(!) DOS



  • Wie's in der Win32-Konsole geht, weiß ich schon. Aber wie bringe ich folgenden Code in richtigem 16-Bit-DOS zum Laufen, wenn ich keinen Borland-Compiler (z.B. Turbo C++) benutze, sondern Visual C++ 1.52c?

    #include <conio.h>
    
    int main()
    {
        clrscr();
    
        for (int i = 0; i < 16; i++)
        {
            gotoxy(i * 3 + 1, 1);
            textcolor(i);
            cprintf("%i", i);
        }
    
        getch();
    
        return 0;
    }
    


  • Gar nicht - damals hatte jeder Compilerhersteller seinen eigenen Dialekt auf dem Gebiet.

    Gar nicht, ist vielleicht ein wenig übertrieben - kannst ja den ganzen Quelltext für Microsoft umstricken oder versuchen eine entsprechende Übersetzungsbibliothek zu bauen. Aber letzteres sollte sich nur in wenigen Fällen lohnen.

    PS: Was hindert dich daran den "free bcc 5.5" herunterzuladen?
    http://edn.embarcadero.com/article/20633

    Der sollte deinen Quelltext für Win-Konsole übersetzen können.

    Oder muss es 16Bit sein? Dann ein wenig älter:
    http://edn.embarcadero.com/article/20841

    Kann sein das ich noch ein original Borland 4.0 irgend wo liegen hab. Bei Bedarf könnte ich ja suchen.

    MfG f.-th.



  • oder.. wenns mit ansi und config.sys klappt, dann wrappe dir die gotoxy, die textcolor und clearscreen mit ansi sequenzen. immer wieder beliebt 😉



  • f.-th. schrieb:

    PS: Was hindert dich daran den "free bcc 5.5" herunterzuladen?
    ...
    Oder muss es 16Bit sein? Dann ein wenig älter:
    http://edn.embarcadero.com/article/20841

    Seufz! Wo fange ich an? Gucken wir mal:

    Aber wie bringe ich folgenden Code in richtigem 16-Bit-DOS zum Laufen, wenn ich keinen Borland-Compiler (z.B. Turbo C++) benutze, sondern Visual C++ 1.52c?

    elise schrieb:

    oder.. wenns mit ansi und config.sys klappt, dann wrappe dir die gotoxy, die textcolor und clearscreen mit ansi sequenzen. immer wieder beliebt 😉

    Ja, nein, das ist nicht gut. Dann muss der Benutzer erst in seiner Config.sys rumbasteln.

    Ich hab jetzt übrigens das hier gefunden:

    void gotoxy (int x, int y)
    {
       union REGS regs;             /* Registers of intel CPU  */
    
       regs.h.ah = 0x02;            /* AH= 02 Fkt. Set Cursor  */
       regs.h.bh = 0;               /* BH= Page 0              */
       regs.h.dh = (char) y-1;      /* DH= line   (BIOS from 0)*/
       regs.h.dl = (char) x-1;      /* DL= column (BIOS from 0)*/
       int86 (0x10, &regs, &regs);  /* Execute funktion        */
    }
    

    ftp://ssv-embedded.de/ssv/products/trm916-rev-b/sample/1520/dos/c-code/lcd/lcdtest.c



  • Okay, erst der 2. Link war 16bit DOS 😃

    Hab da noch was Altes gefunden, sollte für nicht Borland-DOS-C-Compiler einige Funktionen nachbilden:

    coltool.h

    /* header-datei fr universelle farbige textausgabe fr alle (?) c-compiler */
    
    #ifndef __COLTOOL_H
    #define __COLTOOL_H	1	/* prevent multiple #include's		*/
    
    #if __cplusplus
    extern "C" {
    #endif
    
    struct text_position_und_farbe {
      unsigned char seite,
    		spalte,
    		zeile,
    		attr,
                    cc;      /* korrekturkonstante fuer bildschirmbeginn 1,1 */
    }static tpc =
    {
      0, 1, 1, 0x07, 162
    };
    struct cursor_position{
      unsigned char seite,
                    spalte,
                    zeile;
    }cp;
    
    void clrscr();
    void colprintf(char * string,...);
    void gotoxy(int x, int y);
    void setcursor(int p, int x, int y);
    void getcursor(int p);
    int wherex();
    int wherey();
    void newline();
    void setbackgroundcolor(int sbc);
    int getbackgroundcolor();
    void settextcolor(int stc);
    int gettextcolor();
    void setattribut(int sat);
    int getattribut();
    
    #ifndef __TURBOC__
    #if	!defined(__col)
    #define __col
    
    enum col {
    	BLACK,			/* dark colors */
    	BLUE,
    	GREEN,
    	CYAN,
    	RED,
    	MAGENTA,
    	BROWN,
    	LIGHTGRAY,
    	DARKGRAY,		/* light colors */
    	LIGHTBLUE,
    	LIGHTGREEN,
    	LIGHTCYAN,
    	LIGHTRED,
    	LIGHTMAGENTA,
    	YELLOW,
    	WHITE
    };
    #endif
    #endif
    
    #define BLINK		128	/* blink bit */
    
    #if __cplusplus
    }
    #endif
    
    #endif /*COLTOOL*/
    
    

    coltool.c

    /* def-datei fr universelle farbige textausgabe fr alle (?) c-compiler */
    
    #include <stdarg.h>
    #include "coltool.h"
    
    #ifndef MK_FP
      #define MK_FP(seg,ofs) ((void far *)\
    			 (((unsigned long)(seg) << 16) | (ofs)))
    #endif
    
    typedef unsigned char BYTE;
    typedef BYTE BOOL;
    
    BYTE far *bptr;                           /* Zeiger in den RAM (0x40) */
    
    void clrscr()
    {
     BYTE far *vptr;                           /* Zeiger in den Video-RAM */
     int  count = 2000;               /* Anzahl der zu l”schenden Zeichen */
    
     vptr = (BYTE far *) MK_FP( 0xB800, 0 ); /*Zeiger auf Video-RAM setzen*/
    
     for ( ; count--; )                      /* den Video-RAM durchlaufen */
      {
       *vptr++ = ' ';                   /* Zeichen in Video-Ram schreiben */
       *vptr++ = tpc.attr;             /* Attribut in Video-Ram schreiben */
      }
    }
    
    void colprintf(char * string,...)
    {
     va_list parameter;              /* Parameter-Liste fr VA_... Macros */
     char ausgabe[255],                 /* Puffer fr formatierten String */
          *ausptr;
     BYTE far *vptr;                           /* Zeiger in den Video-RAM */
    
     va_start( parameter, string );                /* Parameter umwandeln */
     vsprintf( ausgabe, string, parameter );               /* formatieren */
    
     vptr = (BYTE far *) MK_FP( 0xB800, tpc.spalte*2+tpc.zeile*160 - tpc.cc );
    
     for ( ausptr = ausgabe; *ausptr ; )            /* String durchlaufen */
      {
       *vptr++ = *ausptr++;           /* Zeichen in Video-Ram schreiben */
       *vptr++ = tpc.attr;             /* Attribut in Video-Ram schreiben */
       tpc.spalte++;
      }
    }
    
    void gotoxy(int x, int y)
    {
      tpc.spalte = x;
      tpc.zeile = y;
    }
    
    void setcursor(int p, int x, int y)
    {
      cp.seite = p;
      cp.spalte = x;
      cp.zeile = y;
      bptr = (BYTE far *) MK_FP( 0x0040, 0x50+p );
      *bptr++ = cp.spalte - 1;             /* Cursor.Spalte in Ram schreiben */
      *bptr++ = cp.zeile - 1;              /* Cursor.Zeile in Ram schreiben */
    }
    
    void getcursor(int p)
    {
      bptr = (BYTE far *) MK_FP( 0x0040, 0x50+p );
      cp.spalte = *bptr++ + 1;             /* Cursor.Spalte in Ram lesen */
      cp.zeile = *bptr++ + 1;              /* Cursor.Zeile in Ram lesen */
      cp.seite = p;
    }
    
    int wherex()
    {
      return(tpc.spalte);
    }
    
    int wherey()
    {
      return(tpc.zeile);
    }
    
    void newline()
    {
      tpc.zeile++;
      tpc.spalte = 1;
    }
    
    void setbackgroundcolor(int sbc)
    {
      tpc.attr = ((tpc.attr&0x0F) + (sbc << 4));
    }
    
    int getbackgroundcolor()
    {
      return(tpc.attr >> 4);
    }
    
    void settextcolor(int stc)
    {
      tpc.attr = ((tpc.attr&0xF0) + stc);
    }
    
    int gettextcolor()
    {
      return(tpc.attr&0x0F);
    }
    
    void setattribut(int sat)
    {
      tpc.attr = sat;
    }
    
    int getattribut()
    {
      return(tpc.attr);
    }
    

    Viel Spass damit.
    f.-th.



  • My Name is Earl schrieb:

    void gotoxy (int x, int y)
    {
       union REGS regs;             /* Registers of intel CPU  */
    
       regs.h.ah = 0x02;            /* AH= 02 Fkt. Set Cursor  */
       regs.h.bh = 0;               /* BH= Page 0              */
       regs.h.dh = (char) y-1;      /* DH= line   (BIOS from 0)*/
       regs.h.dl = (char) x-1;      /* DL= column (BIOS from 0)*/
       int86 (0x10, &regs, &regs);  /* Execute funktion        */
    }
    

    ftp://ssv-embedded.de/ssv/products/trm916-rev-b/sample/1520/dos/c-code/lcd/lcdtest.c

    Die alten int86 BIOS-Aufrufe gehen mit jedem Compiler der 16-bit Code
    erzeugen kann. Das wäre mein Favorit. Leider kommen da aktuelle Compiler
    nicht in Frage.

    Ich würde es evtl. direkt mit Assembler implementieren 🙂

    asm { 
      mov  ah, 02h; 
      ... 
      int 10h
    }
    

Log in to reply