4. clrscr, gotoxy und textcolor in echtem(!) DOS

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;
}
    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.

    0

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

    0
  • ?

    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

    0
  • ?

    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.

    0
  • M

    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
}
    0
Anmelden zum Antworten