1718 lines
36 KiB
C
1718 lines
36 KiB
C
/*******************************************************************************/
|
|
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
|
/* */
|
|
#include "asm.h"
|
|
#include "math.h"
|
|
#include "video.h"
|
|
#include "stdarg.h"
|
|
#include "string.h"
|
|
#include "VGA/8x8fnt.c"
|
|
#include "VGA/8x16fnt.c"
|
|
|
|
/******************************************************************************/
|
|
/* VARIABLES */
|
|
|
|
static drivers registred[MAXDRIVERS];
|
|
|
|
static font fonts[MAXFONTS];
|
|
|
|
static videoinfos *vinfo;
|
|
|
|
static width, height;
|
|
|
|
static font *currentfont;
|
|
|
|
static console vc[8] = {
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true},
|
|
{0x07, 0, 0, 0, 0, 0, 0, 0, true}
|
|
};
|
|
|
|
static u8 usedvc = 0;
|
|
|
|
/******************************************************************************/
|
|
/* FONCTIONS CONSOLE */
|
|
|
|
/*******************************************************************************/
|
|
/* Fixe l'attribut courant */
|
|
|
|
void setattrib(u8 att)
|
|
{
|
|
static const u8 ansitovga[] = {
|
|
0, 4, 2, 6, 1, 5, 3, 7
|
|
};
|
|
u8 tempattr;
|
|
|
|
tempattr = vc[usedvc].attrib;
|
|
if (att == 0)
|
|
tempattr = 0x07; /* Couleur Grise sur fond noir */
|
|
else if (att == 5)
|
|
tempattr |= 0x80;
|
|
else if (att == 7)
|
|
tempattr =
|
|
((tempattr & 0x0F) << 4) +
|
|
((tempattr & 0xF0) >> 4);
|
|
else if (att == 8)
|
|
tempattr = 0;
|
|
else if (att == 1)
|
|
tempattr |= 0x08; /* Forte intensité */
|
|
else if (att >= 30 && att <= 37)
|
|
{
|
|
att = ansitovga[att - 30];
|
|
tempattr = (tempattr & ~0x07) | att; /* couleur de premier plan */
|
|
}
|
|
else if (att >= 40 && att <= 47)
|
|
{
|
|
att = ansitovga[att - 40] << 4;
|
|
tempattr = (tempattr & ~0x70) | att; /* couleur de fond */
|
|
}
|
|
vc[usedvc].attrib = tempattr;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* gere l'ansi */
|
|
|
|
bool makeansi(u8 c)
|
|
{
|
|
/* state machine to handle the escape sequences */
|
|
switch (vc[usedvc].ansi)
|
|
{
|
|
case 0:
|
|
/* ESC -- next state */
|
|
if (c == 0x1B)
|
|
{
|
|
vc[usedvc].ansi++;
|
|
return 1; /* "I handled it" */
|
|
}
|
|
break;
|
|
/* ESC */
|
|
case 1:
|
|
if (c == '[')
|
|
{
|
|
vc[usedvc].ansi++;
|
|
vc[usedvc].param1 = 0;
|
|
return 1;
|
|
}
|
|
break;
|
|
/* ESC[ */
|
|
case 2:
|
|
if (isdigit(c))
|
|
{
|
|
vc[usedvc].param1 =
|
|
vc[usedvc].param1 * 10 + c - '0';
|
|
return 1;
|
|
}
|
|
else if (c == ';')
|
|
{
|
|
vc[usedvc].ansi++;
|
|
vc[usedvc].param2 = 0;
|
|
return 1;
|
|
}
|
|
/* ESC[2J -- efface l'ecran */
|
|
else if (c == 'J')
|
|
{
|
|
if (vc[usedvc].param1 == 2)
|
|
{
|
|
fill(vc[usedvc].attrib);
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY = 0;
|
|
cursor_set(0, 0);
|
|
vc[usedvc].ansi = 0;
|
|
return 1;
|
|
}
|
|
}
|
|
/* ESC[num1m -- met l'attribut num1 */
|
|
else if (c == 'm')
|
|
{
|
|
setattrib(vc[usedvc].param1);
|
|
vc[usedvc].ansi = 0;
|
|
return 1;
|
|
}
|
|
/* ESC[num1A -- bouge le curseur de num1 vers le haut */
|
|
else if (c == 'A')
|
|
{
|
|
vc[usedvc].cursY -= vc[usedvc].param1;
|
|
if (vc[usedvc].cursY < 0)
|
|
vc[usedvc].cursY = 0;
|
|
vc[usedvc].ansi = 0;
|
|
cursor_set(vc[usedvc].cursX,
|
|
vc[usedvc].cursY);
|
|
return 1;
|
|
}
|
|
/* ESC[num1B -- bouge le curseur de num1 vers le bas */
|
|
else if (c == 'B')
|
|
{
|
|
vc[usedvc].cursY += vc[usedvc].param1;
|
|
if (vc[usedvc].cursY >= getheight() - 1)
|
|
vc[usedvc].cursY = getheight();
|
|
vc[usedvc].ansi = 0;
|
|
cursor_set(vc[usedvc].cursX,
|
|
vc[usedvc].cursY);
|
|
return 1;
|
|
}
|
|
/* ESC[num1D -- bouge le curseur de num1 vers la gauche */
|
|
else if (c == 'D')
|
|
{
|
|
vc[usedvc].cursX -= vc[usedvc].param1;
|
|
if (vc[usedvc].cursX < 0)
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].ansi = 0;
|
|
cursor_set(vc[usedvc].cursX,
|
|
vc[usedvc].cursY);
|
|
return 1;
|
|
}
|
|
/* ESC[num1C -- bouge le curseur de num1 vers la droite */
|
|
else if (c == 'C')
|
|
{
|
|
vc[usedvc].cursX += vc[usedvc].param1;
|
|
if (vc[usedvc].cursX >= getwidth() - 1)
|
|
vc[usedvc].cursX = getwidth();
|
|
vc[usedvc].ansi = 0;
|
|
cursor_set(vc[usedvc].cursX,
|
|
vc[usedvc].cursY);
|
|
return 1;
|
|
}
|
|
break;
|
|
/* ESC[num1; */
|
|
case 3:
|
|
if (isdigit(c))
|
|
{
|
|
vc[usedvc].param2 =
|
|
vc[usedvc].param2 * 10 + c - '0';
|
|
return 1;
|
|
}
|
|
else if (c == ';')
|
|
{
|
|
vc[usedvc].ansi++;
|
|
vc[usedvc].param3 = 0;
|
|
return 1;
|
|
}
|
|
/* ESC[num1;num2H ou ESC[num1;num2f-- bouge le curseur en num1,num2 */
|
|
else if ((c == 'H') || (c == 'f'))
|
|
{
|
|
/* Remet la position du curseur matériel a num1,num2 */
|
|
cursor_set(vc[usedvc].param2,
|
|
vc[usedvc].param1);
|
|
/* Remet la position du curseur logiciel a num1,num2 */
|
|
vc[usedvc].cursX = vc[usedvc].param2;
|
|
vc[usedvc].cursY = vc[usedvc].param1;
|
|
vc[usedvc].ansi = 0;
|
|
return 1;
|
|
}
|
|
/* ESC[num1;num2m -- met les attributs num1,num2 */
|
|
else if (c == 'm')
|
|
{
|
|
setattrib(vc[usedvc].param1);
|
|
setattrib(vc[usedvc].param2);
|
|
vc[usedvc].ansi = 0;
|
|
return 1;
|
|
}
|
|
break;
|
|
/* ESC[num1;num2;num3 */
|
|
case 4:
|
|
if (isdigit(c))
|
|
{
|
|
vc[usedvc].param3 =
|
|
vc[usedvc].param3 * 10 + c - '0';
|
|
return 1;
|
|
}
|
|
/* ESC[num1;num2;num3m -- met les attributs num1,num2,num3 */
|
|
else if (c == 'm')
|
|
{
|
|
setattrib(vc[usedvc].param1);
|
|
setattrib(vc[usedvc].param2);
|
|
setattrib(vc[usedvc].param3);
|
|
vc[usedvc].ansi = 0;
|
|
return 1;
|
|
}
|
|
break;
|
|
/* Mauvais etat >> reset */
|
|
default:
|
|
vc[usedvc].ansi = 0;
|
|
break;
|
|
}
|
|
vc[usedvc].ansi = 0;
|
|
return 0; /* Ansi fini ;) */
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* affiche un caractère a l'écran */
|
|
|
|
void putchar(u8 thechar)
|
|
{
|
|
page_show(usedvc);
|
|
page_set(usedvc);
|
|
if (makeansi(thechar))
|
|
return;
|
|
switch (thechar)
|
|
{
|
|
case 0x11:
|
|
if (vc[usedvc].cursY > 0)
|
|
vc[usedvc].cursY--;
|
|
break;
|
|
case 0x12:
|
|
if (vc[usedvc].cursY < getheight() - 1)
|
|
vc[usedvc].cursY++;
|
|
break;
|
|
case 0x13:
|
|
if (vc[usedvc].cursX > 0)
|
|
vc[usedvc].cursX--;
|
|
break;
|
|
case 0x14:
|
|
if (vc[usedvc].cursX < getwidth() - 1)
|
|
vc[usedvc].cursX++;
|
|
break;
|
|
case 0x2:
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY = 0;
|
|
break;
|
|
case 0x3:
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY = getheight() - 1;
|
|
break;
|
|
case 0x19:
|
|
vc[usedvc].cursX = getwidth() - 1;
|
|
break;
|
|
case '\b':
|
|
if (vc[usedvc].cursX == 0)
|
|
{
|
|
if (vc[usedvc].cursY > 0)
|
|
{
|
|
vc[usedvc].cursX = getwidth() - 1;
|
|
vc[usedvc].cursY--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vc[usedvc].cursX--;
|
|
}
|
|
showchar(vc[usedvc].cursX, vc[usedvc].cursY, ' ',
|
|
vc[usedvc].attrib);
|
|
break;
|
|
case '\t':
|
|
vc[usedvc].cursX =
|
|
(vc[usedvc].cursX + 8) & ~(8 - 1);
|
|
break;
|
|
case '\n':
|
|
vc[usedvc].cursX = 0;
|
|
break;
|
|
case '\r':
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY++;
|
|
break;
|
|
default:
|
|
if (thechar >= ' ')
|
|
{
|
|
showchar(vc[usedvc].cursX,
|
|
vc[usedvc].cursY, thechar,
|
|
vc[usedvc].attrib);
|
|
vc[usedvc].cursX++;
|
|
}
|
|
break;
|
|
}
|
|
if (vc[usedvc].cursX >= getwidth())
|
|
{
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY++;
|
|
}
|
|
if (vc[usedvc].cursY >= getheight())
|
|
{
|
|
scroll(1, vc[usedvc].attrib);
|
|
vc[usedvc].cursY = getheight() - 1;
|
|
}
|
|
cursor_set(vc[usedvc].cursX, vc[usedvc].cursY);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Change la console en cours d'utilisation */
|
|
|
|
void changevc(u8 avc)
|
|
{
|
|
usedvc = avc;
|
|
page_show(usedvc);
|
|
page_set(usedvc);
|
|
cursor_set(vc[usedvc].cursX, vc[usedvc].cursY);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Renvoie la taille horizontale */
|
|
u16 getwidth(void)
|
|
{
|
|
return width;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Renvoie la taille verticale */
|
|
u16 getheight(void)
|
|
{
|
|
return height;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Efface la console en cours d'utilisation */
|
|
void clearscreen(void)
|
|
{
|
|
fill(vc[usedvc].attrib);
|
|
vc[usedvc].cursX = 0;
|
|
vc[usedvc].cursY = 0;
|
|
cursor_set(0, 0);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Active le scrolling */
|
|
|
|
void scroll_enable(void)
|
|
{
|
|
vc[usedvc].scroll = true;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Désactive le scrolling */
|
|
|
|
void scroll_disable(void)
|
|
{
|
|
vc[usedvc].scroll = false;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* FONCTIONS VIDEO BASIQUES */
|
|
|
|
/*******************************************************************************/
|
|
/* initialise le tableau des pilotes vidéo */
|
|
void initdriver()
|
|
{
|
|
for (u32 i = 0; i < MAXDRIVERS; i++)
|
|
registred[i].nom = NULL;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Enregistre un pilote dans le tableau des pilotes vidéo */
|
|
void registerdriver(videofonction * pointer)
|
|
{
|
|
u32 i;
|
|
for (i = 0; i < MAXDRIVERS; i++)
|
|
if (registred[i].pointer == pointer)
|
|
return;
|
|
i = 0;
|
|
while (registred[i].nom != NULL && i < MAXDRIVERS)
|
|
i++;
|
|
if (pointer->detect_hardware() != NULL)
|
|
{
|
|
registred[i].pointer = pointer;
|
|
registred[i].nom = pointer->getvideo_drivername();
|
|
}
|
|
}
|
|
/*******************************************************************************/
|
|
/* Choisi le meilleur driver en terme d'affichage */
|
|
void apply_bestdriver(void)
|
|
{
|
|
u32 i = 0, j;
|
|
u8 bestdepth = 0x0;
|
|
u32 bestresol = 0x0;
|
|
u8 bestmode = 0x0;
|
|
u8 *bestdriver = NULL;
|
|
capabilities *cap;
|
|
while (registred[i].nom != NULL && i < MAXDRIVERS)
|
|
{
|
|
cap = registred[i].pointer->getvideo_capabilities();
|
|
j = 0;
|
|
while (cap[j].modenumber != 0xFF)
|
|
{
|
|
if (cap[j].depth > bestdepth
|
|
&& (cap[j].width * cap[j].height) >= bestresol)
|
|
{
|
|
bestdepth = cap[j].depth;
|
|
bestresol = cap[j].width * cap[j].height;
|
|
bestmode = cap[j].modenumber;
|
|
bestdriver =
|
|
registred[i].
|
|
pointer->getvideo_drivername();
|
|
}
|
|
j++;
|
|
}
|
|
i++;
|
|
}
|
|
if (bestdriver != NULL)
|
|
apply_driver(bestdriver);
|
|
setvideo_mode(bestmode);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Choisi le meilleur driver spécifié par le nom */
|
|
void apply_driver(u8 * name)
|
|
{
|
|
u32 i = 0;
|
|
while (registred[i].nom != NULL && i < MAXDRIVERS)
|
|
{
|
|
if (strcmp(name, registred[i].nom) == 0)
|
|
{
|
|
remap_memory = registred[i].pointer->remap_memory;
|
|
detect_hardware =
|
|
registred[i].pointer->detect_hardware;
|
|
setvideo_mode =
|
|
registred[i].pointer->setvideo_mode;
|
|
getvideo_drivername =
|
|
registred[i].pointer->getvideo_drivername;
|
|
getvideo_capabilities =
|
|
registred[i].
|
|
pointer->getvideo_capabilities;
|
|
getvideo_info =
|
|
registred[i].pointer->getvideo_info;
|
|
mem_to_video = registred[i].pointer->mem_to_video;
|
|
video_to_mem = registred[i].pointer->video_to_mem;
|
|
video_to_video =
|
|
registred[i].pointer->video_to_video;
|
|
wait_vretrace =
|
|
registred[i].pointer->wait_vretrace;
|
|
wait_hretrace =
|
|
registred[i].pointer->wait_hretrace;
|
|
page_set = registred[i].pointer->page_set;
|
|
page_show = registred[i].pointer->page_show;
|
|
page_split = registred[i].pointer->page_split;
|
|
cursor_enable =
|
|
registred[i].pointer->cursor_enable;
|
|
cursor_disable =
|
|
registred[i].pointer->cursor_disable;
|
|
cursor_set = registred[i].pointer->cursor_set;
|
|
font_load = registred[i].pointer->font_load;
|
|
font1_set = registred[i].pointer->font1_set;
|
|
font2_set = registred[i].pointer->font2_set;
|
|
blink_enable = registred[i].pointer->blink_enable;
|
|
blink_disable =
|
|
registred[i].pointer->blink_disable;
|
|
changemode(0x0);
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
/*******************************************************************************/
|
|
/* Applique le driver suivant */
|
|
|
|
void apply_nextdriver(void)
|
|
{
|
|
u32 i = 0;
|
|
while (registred[i].nom != NULL && i < MAXDRIVERS)
|
|
if (strcmp(getvideo_drivername(), registred[i].nom) == 0)
|
|
{
|
|
i++;
|
|
if (registred[i].nom != NULL)
|
|
i = 0;
|
|
apply_driver(registred[i].nom);
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Applique le mode suivant (le driver suivant si dernier mode) */
|
|
|
|
void apply_nextvideomode(void)
|
|
{
|
|
capabilities *cap = getvideo_capabilities();
|
|
videoinfos *info = getvideo_info();
|
|
u32 mode = info->currentmode;
|
|
u8 index = 0;
|
|
while (cap[index].modenumber != 0xFF)
|
|
{
|
|
if (cap[index].modenumber == mode)
|
|
{
|
|
index++;
|
|
if (cap[index].modenumber == 0xFF)
|
|
apply_nextdriver();
|
|
else
|
|
changemode(cap[index].modenumber);
|
|
return;
|
|
}
|
|
index++;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Change de mode video */
|
|
|
|
void changemode(u8 mode)
|
|
{
|
|
setvideo_mode(mode);
|
|
vinfo = getvideo_info();
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
width = vinfo->currentwidth;
|
|
height = vinfo->currentheight;
|
|
}
|
|
else
|
|
{
|
|
width = (vinfo->currentwidth >> 3);
|
|
height = (vinfo->currentheight >> 3);
|
|
}
|
|
for (u32 i = 0; i < MAXFONTS; i++)
|
|
fonts[i].nom[0] = NULL;
|
|
loadfont("BIOS1", font8x8, 8, 8);
|
|
loadfont("BIOS0", font8x16, 8, 16);
|
|
setfont("BIOS1");
|
|
clearscreen();
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Rempli l'écran avec un attribut donné et des espaces vides */
|
|
|
|
static u8 space = ' ';
|
|
|
|
void fill(u8 attrib)
|
|
{
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
mem_to_video(space, 0, vinfo->pagesize >> 1, false);
|
|
mem_to_video(attrib, 1, vinfo->pagesize >> 1, false);
|
|
}
|
|
else
|
|
{
|
|
mem_to_video(0x0, 0, vinfo->pagesize >> 2, false);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Défile l'écran de N ligne si le scrolling est activé */
|
|
|
|
void scroll(u8 lines, u8 attrib)
|
|
{
|
|
if (vc[usedvc].scroll)
|
|
{
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
u32 gain = vinfo->currentpitch * lines;
|
|
video_to_video(gain, 0, vinfo->pagesize - gain);
|
|
mem_to_video(space, vinfo->pagesize - gain - 2,
|
|
gain, false);
|
|
mem_to_video(attrib, vinfo->pagesize - gain - 1,
|
|
gain, false);
|
|
}
|
|
else
|
|
{
|
|
u32 gain = vinfo->currentpitch * (lines << 3);
|
|
video_to_video(gain, 0, vinfo->pagesize - gain);
|
|
mem_to_video(0x0, vinfo->pagesize - gain - 2, gain,
|
|
false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
clearscreen();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Retourne une couleur RGB 32 bits depuis une couleur EGA/VGA */
|
|
|
|
static convertega[] =
|
|
{ 0, 1, 2, 3, 4, 5, 20, 7, 56, 57, 58, 59, 60, 61, 62, 63 };
|
|
|
|
u8 egatovga(u8 ega)
|
|
{
|
|
return convertega[ega & 0xF];
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Retourne une couleur RGB 32 bits depuis une couleur EGA/VGA */
|
|
|
|
static convertrgb[] =
|
|
{ 0x000000, 0x0000AA, 0x00AA00, 0x00AAAA, 0xAA0000, 0xAA00AA,
|
|
0xAA5500, 0xAAAAAA, 0x555555, 0x5555FF, 0x55FF55, 0x55FFFF,
|
|
0xFF5555,
|
|
0xFF55FF, 0xFFFF55, 0xFFFFFF
|
|
};
|
|
|
|
u32 egatorgb(u8 vga)
|
|
{
|
|
return convertrgb[vga & 0xF];
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Retourne le caractère du mode texte aux coordonnées spécifiées */
|
|
|
|
u8 getchar(u16 coordx, u16 coordy)
|
|
{
|
|
u8 thechar = 0;
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
u32 addr =
|
|
(coordx << 1) + vinfo->currentpitch * coordy;
|
|
video_to_mem(addr, &thechar, 1);
|
|
}
|
|
return thechar;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Retourne l'attribut du mode texte aux coordonnées spécifiées */
|
|
|
|
u8 getattrib(u16 coordx, u16 coordy)
|
|
{
|
|
u8 attrib = 0;
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
u32 addr =
|
|
(coordx << 1) + vinfo->currentpitch * coordy;
|
|
video_to_mem(addr + 1, &attrib, 1);
|
|
}
|
|
return attrib;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Chargement d'une police de caractère */
|
|
|
|
void loadfont(u8 * name, font * pointer, u8 width, u8 height)
|
|
{
|
|
u32 i;
|
|
for (i = 0; i < MAXFONTS; i++)
|
|
if (fonts[i].nom[0] != NULL && fonts[i].pointer == pointer)
|
|
return;
|
|
i = 0;
|
|
while (fonts[i].nom[0] != NULL && i < MAXFONTS)
|
|
i++;
|
|
fonts[i].pointer = pointer;
|
|
strcpy(name, fonts[i].nom);
|
|
fonts[i].width = width;
|
|
fonts[i].height = height;
|
|
if (fonts[i].nom[0] == 'B' && fonts[i].nom[1] == 'I'
|
|
&& fonts[i].nom[2] == 'O' && fonts[i].nom[3] == 'S')
|
|
{
|
|
u8 number = (fonts[i].nom[4] - '0');
|
|
font_load(pointer, height, number);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Changement de la police */
|
|
|
|
void setfont(u8 * fontname)
|
|
{
|
|
u32 i = 0;
|
|
while (fonts[i].nom != NULL && i < MAXFONTS)
|
|
{
|
|
if (strcmp(fontname, fonts[i].nom) == 0)
|
|
{
|
|
currentfont = &fonts[i];
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* FONCTIONS VIDEO GRAPHIQUES */
|
|
|
|
/******************************************************************************/
|
|
/* Affiche un caractère */
|
|
|
|
void showchar(u16 coordx, u16 coordy, u8 thechar, u8 attrib)
|
|
{
|
|
u8 x, y, pattern, set;
|
|
u32 color;
|
|
if (!vinfo->isgraphic)
|
|
{
|
|
u32 addr =
|
|
(coordx << 1) + vinfo->currentpitch * coordy;
|
|
mem_to_video(thechar, addr, 1, false);
|
|
mem_to_video(attrib, addr + 1, 1, false);
|
|
}
|
|
else
|
|
{
|
|
for (y = 0; y < currentfont->height; y++)
|
|
{
|
|
pattern =
|
|
currentfont->pointer[currentfont->height *
|
|
thechar + y];
|
|
for (x = 0; x < currentfont->width; x++)
|
|
{
|
|
rol(pattern);
|
|
set = pattern & 0x1;
|
|
if (set == 0)
|
|
if (vinfo->currentdepth == 32)
|
|
color = egatorgb((attrib &
|
|
0xF0) >>
|
|
4);
|
|
else
|
|
color = egatovga((attrib &
|
|
0xF0) >>
|
|
4);
|
|
else if (vinfo->currentdepth == 32)
|
|
color = egatorgb(attrib & 0x0F);
|
|
else
|
|
color = egatovga(attrib & 0x0F);
|
|
|
|
|
|
|
|
writepxl(currentfont->width * coordx + x +
|
|
1,
|
|
currentfont->height * coordy + y,
|
|
color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Affiche une ligne horizontale entre les points spécifiés */
|
|
|
|
void hline(s16 x1, s16 x2, s16 y, u32 color)
|
|
{
|
|
if (vinfo->isgraphic)
|
|
{
|
|
if (x1 < 0)
|
|
{
|
|
if (x2 < 0)
|
|
return;
|
|
x1 = 0;
|
|
}
|
|
else if (x1 > vinfo->currentwidth)
|
|
x1 = vinfo->currentwidth - 1;
|
|
if (x2 < 0)
|
|
x2 = 0;
|
|
else if (x2 > vinfo->currentwidth)
|
|
{
|
|
if (x1 > vinfo->currentwidth)
|
|
return;
|
|
x2 = vinfo->currentwidth - 1;
|
|
}
|
|
if (x1 > vinfo->currentwidth)
|
|
x1 = vinfo->currentwidth - 1;
|
|
if (x2 > x1)
|
|
mem_to_video(color,
|
|
(vinfo->currentdepth >> 3) * x1 +
|
|
vinfo->currentpitch * y, x2 - x1,
|
|
false);
|
|
else
|
|
mem_to_video(color,
|
|
(vinfo->currentdepth >> 3) * x2 +
|
|
vinfo->currentpitch * y, x1 - x2,
|
|
false);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/* Affiche un pixel à l'écran */
|
|
|
|
void v_writepxl(vertex2d * A, u32 color)
|
|
{
|
|
writepxl(A->x, A->y, color);
|
|
}
|
|
|
|
void writepxl(s16 x, s16 y, u32 color)
|
|
{
|
|
if (vinfo->isgraphic)
|
|
{
|
|
if (x > 0 && y > 0 && x < vinfo->currentwidth
|
|
&& y < vinfo->currentheight)
|
|
{
|
|
u32 addr =
|
|
(vinfo->currentdepth >> 3) * x +
|
|
vinfo->currentpitch * y;
|
|
mem_to_video(color, addr, 1, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Affiche une ligne entre les points spécifiés */
|
|
|
|
void v_line(vertex2d * A, vertex2d * B, u32 color)
|
|
{
|
|
line(A->x, A->y, B->x, B->y, color);
|
|
}
|
|
|
|
void line(s16 x1, s16 y1, s16 x2, s16 y2, u32 color)
|
|
{
|
|
s16 dx, dy, sdx, sdy;
|
|
float a, b;
|
|
s16 i, dxabs, dyabs, x, y, px, py;
|
|
|
|
dx = x2 - x1; /* distance horizontale de la line */
|
|
dy = y2 - y1; /* distance verticale de la line */
|
|
|
|
if (x1 < 0)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y1 - a * x1;
|
|
x1 = 0;
|
|
y1 = b;
|
|
if (x2 < 0)
|
|
return;
|
|
}
|
|
else if (x2 < 0)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y2 - a * x2;
|
|
x2 = 0;
|
|
y2 = b;
|
|
}
|
|
if (y1 < 0)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y1 - a * x1;
|
|
y1 = 0;
|
|
x1 = -b / a;
|
|
if (y2 < 0)
|
|
return;
|
|
}
|
|
else if (y2 < 0)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y2 - a * x2;
|
|
y2 = 0;
|
|
x2 = -b / a;
|
|
}
|
|
if (x1 > vinfo->currentwidth)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y1 - a * x1;
|
|
x1 = vinfo->currentwidth - 1;
|
|
y1 = a * x1 + b;
|
|
if (x2 > vinfo->currentwidth)
|
|
return;
|
|
}
|
|
else if (x2 > vinfo->currentwidth)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y2 - a * x2;
|
|
x2 = vinfo->currentwidth - 1;
|
|
y2 = a * x2 + b;
|
|
}
|
|
if (y1 > vinfo->currentheight)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y1 - a * x1;
|
|
y1 = vinfo->currentheight - 1;
|
|
x1 = (y1 - b) / a;
|
|
if (y2 > vinfo->currentheight)
|
|
return;
|
|
}
|
|
else if (y2 > vinfo->currentheight)
|
|
{
|
|
a = 1.0f * dy / dx;
|
|
b = y2 - a * x2;
|
|
y2 = vinfo->currentheight - 1;
|
|
x2 = (y2 - b) / a;
|
|
}
|
|
dxabs = abs(dx);
|
|
dyabs = abs(dy);
|
|
sdx = sgn(dx);
|
|
sdy = sgn(dy);
|
|
x = dyabs >> 1;
|
|
y = dxabs >> 1;
|
|
px = x1;
|
|
py = y1;
|
|
|
|
writepxl(px, py, color);
|
|
|
|
if (dxabs >= dyabs)
|
|
{ /* la ligne est plus horizontale que verticale */
|
|
for (i = 0; i < dxabs; i++)
|
|
{
|
|
y += dyabs;
|
|
if (y >= dxabs)
|
|
{
|
|
y -= dxabs;
|
|
py += sdy;
|
|
}
|
|
px += sdx;
|
|
writepxl(px, py, color);
|
|
}
|
|
}
|
|
else
|
|
{ /* la ligne est plus verticale que horizontale */
|
|
|
|
for (i = 0; i < dyabs; i++)
|
|
{
|
|
x += dxabs;
|
|
if (x >= dyabs)
|
|
{
|
|
x -= dyabs;
|
|
px += sdx;
|
|
}
|
|
py += sdy;
|
|
writepxl(px, py, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Affiche un triangle rempli entre les points spécifiés */
|
|
|
|
void trianglefilled(vertex2d * AA, vertex2d * BB, vertex2d * CC, u32 color)
|
|
{
|
|
vertex2d *A, *B, *C, *TEMP;
|
|
u32 a, b, y, last;
|
|
int dx1, dx2, dx3, dy1, dy2, dy3, sa, sb;
|
|
A = AA;
|
|
B = BB;
|
|
C = CC;
|
|
while (A->y > B->y || B->y > C->y || A->y == C->y)
|
|
{
|
|
if (A->y > B->y)
|
|
swapvertex(A, B);
|
|
if (B->y > C->y)
|
|
swapvertex(B, C);
|
|
if (A->y > C->y)
|
|
swapvertex(A, C);
|
|
}
|
|
if (A->y == C->y)
|
|
{ //meme ligne
|
|
a = b = A->x;
|
|
if (B->x < a)
|
|
a = B->x;
|
|
else if (B->x > b)
|
|
b = B->x;
|
|
if (C->x < a)
|
|
a = C->x;
|
|
else if (C->x > b)
|
|
b = C->x;
|
|
hline(a, b, A->y, color);
|
|
return;
|
|
}
|
|
dx1 = B->x - A->x;
|
|
dy1 = B->y - A->y;
|
|
dx2 = C->x - A->x;
|
|
dy2 = C->y - A->y;
|
|
dx3 = C->x - B->x;
|
|
dy3 = C->y - B->y;
|
|
sa = 0;
|
|
sb = 0;
|
|
|
|
if (B->y == C->y)
|
|
last = B->y;
|
|
else
|
|
last = B->y - 1;
|
|
|
|
for (y = A->y; y <= last; y++)
|
|
{
|
|
a = A->x + sa / dy1;
|
|
b = A->x + sb / dy2;
|
|
sa += dx1;
|
|
sb += dx2;
|
|
hline(a, b, y, color);
|
|
}
|
|
|
|
sa = dx3 * (y - B->y);
|
|
sb = dx2 * (y - A->y);
|
|
for (; y <= C->y; y++)
|
|
{
|
|
a = B->x + sa / dy3;
|
|
b = A->x + sb / dy2;
|
|
sa += dx3;
|
|
sb += dx2;
|
|
hline(a, b, y, color);
|
|
}
|
|
}
|
|
|
|
void swapvertex(vertex2d * A, vertex2d * B)
|
|
{
|
|
vertex2d temp = *A;
|
|
*A = *B;
|
|
*B = temp;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Affiche un triangle entre les points spécifiés */
|
|
|
|
void triangle(vertex2d * AA, vertex2d * BB, vertex2d * CC, u32 color)
|
|
{
|
|
v_line(AA, BB, color);
|
|
v_line(BB, CC, color);
|
|
v_line(CC, AA, color);
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/* FONCTIONS VIDEO TEXTE AFFICHAGE */
|
|
|
|
/*******************************************************************************/
|
|
/* affiche une chaine de caractère a l'écran */
|
|
/* SYSCALL
|
|
{
|
|
"ID":2,
|
|
"LIBRARY":"libvideo",
|
|
"NAME":"print",
|
|
"INTERNALNAME":"print",
|
|
"DESCRIPTION":"Show a string on the screen",
|
|
"ARGS": [
|
|
{"TYPE":"u8*","NAME":"string","DESCRIPTION":"string to show in ascii format"}
|
|
],
|
|
"RETURN":"u32"
|
|
}
|
|
END */
|
|
|
|
u32 print(u8 * string)
|
|
{
|
|
u8 *source;
|
|
u32 i = 0;
|
|
source = string;
|
|
while (*source != 0)
|
|
{
|
|
putchar(*source++);
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Fonction d'affichage (pour printf) */
|
|
|
|
u32 printstr(u8 * src, u8 ** dest, u32 len)
|
|
{
|
|
if (*(src) == '\000')
|
|
return;
|
|
for (u32 i = 0; i < len; i++)
|
|
putchar(*(src++));
|
|
return len;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* Fonction d'enregistrement dans une variable (pour sprintf) */
|
|
|
|
u32 storestr(u8 * src, u8 ** dest, u32 len)
|
|
{
|
|
memcpy(src, *dest, len, 1);
|
|
*dest = *dest + len;
|
|
return len;
|
|
}
|
|
|
|
#define maxbuffersize 4096
|
|
|
|
/*******************************************************************************/
|
|
/* affiche une chaine de caractère formaté a l'ecran */
|
|
|
|
u32 printf(const u8 * string, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, string);
|
|
vprintf(string, args);
|
|
va_end(args);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* met une chaine de caractère formaté dans une variable */
|
|
|
|
u32 sprintf(u8 * variable, const u8 * string, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, string);
|
|
vsprintf(variable, string, args);
|
|
va_end(args);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* met une chaine de caractère formaté dans une variable de taille fixée */
|
|
|
|
u32 snprintf(u8 * variable, u32 maxsize, const u8 * string, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, string);
|
|
vsnprintf(variable, maxsize, string, args);
|
|
va_end(args);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* affiche une chaine de caractère formaté a l'ecran depuis vararg */
|
|
|
|
u32 vprintf(const u8 * string, va_list args)
|
|
{
|
|
format(string, args, maxbuffersize, &printstr, NULL);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* met une chaine de caractère formaté dans une variable depuis vararg */
|
|
|
|
u32 vsprintf(u8 * variable, const u8 * string, va_list args)
|
|
{
|
|
format(string, args, maxbuffersize, &storestr, variable);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* met une chaine de caractère formaté dans une variable de taille fixée depuis vararg */
|
|
|
|
u32 vsnprintf(u8 * variable, u32 maxsize, const u8 * string, va_list args)
|
|
{
|
|
format(string, args, maxsize, &storestr, variable);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* affiche une chaine de caractère formaté a l'ecran */
|
|
|
|
u32 format(const u8 * string, va_list args, u32 maxsize,
|
|
u32(*fonction) (u8 * src, u8 ** dest, u32 len), u8 * dest)
|
|
{
|
|
u64 sizes[] = { 0xFF, 0xFFFF, 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF };
|
|
u8 units[][4] =
|
|
{ "o\000\000", "kio", "mio", "gio", "tio", "pio" };
|
|
u8 strbase2[] = "0xb\000";
|
|
u8 strbase8[] = "0xo\000";
|
|
u8 strbase16[] = "0x\000";
|
|
u8 hexadecimal[] = "*0x\000";
|
|
u8 achar, temp;
|
|
u8 asize, charadd, unit, precisioni, precisionf;
|
|
u8 buffer[maxbuffersize];
|
|
u8 *bufferend;
|
|
u32 buffersize;
|
|
u8 *str = string;
|
|
u8 *strtemp;
|
|
u32 i = 0, counter = 0;
|
|
u64 num;
|
|
bool flag = false, intok = false, decok = false;
|
|
|
|
for (achar = *str; achar != '\000'; i++, achar = *(str + i))
|
|
{
|
|
if (achar != '%' && !flag)
|
|
{
|
|
fonction((str + i), &dest, 1);
|
|
counter++;
|
|
asize = 2;
|
|
precisioni = 0;
|
|
precisionf = 0;
|
|
intok = false;
|
|
decok = false;
|
|
charadd = 0xFF;
|
|
}
|
|
else if (achar == '%' || flag)
|
|
{
|
|
if (!flag)
|
|
++i;
|
|
achar = *(str + i);
|
|
switch (achar)
|
|
{
|
|
case 'z':
|
|
charadd = achar;
|
|
flag = true;
|
|
break;
|
|
case ' ':
|
|
charadd = achar;
|
|
flag = true;
|
|
break;
|
|
case 'h':
|
|
asize--;
|
|
if (asize < 0)
|
|
asize = 0;
|
|
flag = true;
|
|
break;
|
|
case 'l':
|
|
asize++;
|
|
if (asize > 3)
|
|
asize = 3;
|
|
flag = true;
|
|
break;
|
|
case '.':
|
|
intok = true;
|
|
decok = false;
|
|
flag = true;
|
|
break;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
if (!intok)
|
|
{
|
|
if (!decok)
|
|
{
|
|
precisioni =
|
|
achar -
|
|
'0';
|
|
decok = true;
|
|
}
|
|
else
|
|
{
|
|
precisioni *= 10;
|
|
precisioni +=
|
|
achar -
|
|
'0';
|
|
decok = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!decok)
|
|
{
|
|
precisionf =
|
|
achar -
|
|
'0';
|
|
decok = true;
|
|
}
|
|
else
|
|
{
|
|
precisionf *= 10;
|
|
precisionf +=
|
|
achar -
|
|
'0';
|
|
decok = false;
|
|
}
|
|
}
|
|
flag = true;
|
|
break;
|
|
case 'f':
|
|
case 'e':
|
|
if (achar == 'e')
|
|
{
|
|
precisioni = 1;
|
|
precisionf = 8;
|
|
}
|
|
if (asize == 0)
|
|
{
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
break;
|
|
}
|
|
else if (asize == 1)
|
|
{
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
break;
|
|
}
|
|
else if (asize == 2)
|
|
bufferend =
|
|
rtoasingle((float)
|
|
va_arg
|
|
(args,
|
|
double),
|
|
&buffer,
|
|
precisioni,
|
|
precisionf);
|
|
else
|
|
bufferend =
|
|
rtoadouble((double)
|
|
va_arg
|
|
(args,
|
|
double),
|
|
&buffer,
|
|
precisioni,
|
|
precisionf);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case 'u':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = '0';
|
|
bufferend =
|
|
itoa(num, &buffer, 10,
|
|
sizes[asize],
|
|
charadd);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case 'o':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = '0';
|
|
counter +=
|
|
fonction(&strbase8, &dest,
|
|
1);
|
|
bufferend =
|
|
itoa(num, &buffer, 8,
|
|
sizes[asize],
|
|
charadd);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case '%':
|
|
fonction(&achar, string, 1);
|
|
counter++;
|
|
flag = false;
|
|
break;
|
|
case 'c':
|
|
temp = (u8) va_arg(args, u8);
|
|
fonction(&temp, string, 1);
|
|
counter++;
|
|
flag = false;
|
|
break;
|
|
case 'H':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = ' ';
|
|
unit = 0;
|
|
while (num > 1024 * 10)
|
|
{
|
|
num = num >> 10;
|
|
unit++;
|
|
}
|
|
bufferend =
|
|
sitoa(num, &buffer,
|
|
sizes[asize]);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
counter +=
|
|
fonction(&units[unit],
|
|
&dest, 3);
|
|
flag = false;
|
|
break;
|
|
case 'd':
|
|
case 'i':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = ' ';
|
|
bufferend =
|
|
sitoa(num, &buffer,
|
|
sizes[asize]);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case 's':
|
|
strtemp =
|
|
(u8 *) va_arg(args, u8 *);
|
|
counter +=
|
|
fonction(strtemp, &dest,
|
|
strlen(strtemp));
|
|
flag = false;
|
|
break;
|
|
case 'p':
|
|
num = (u32) va_arg(args, int);
|
|
if (charadd == 0xFF)
|
|
charadd = '0';
|
|
counter +=
|
|
fonction(&hexadecimal,
|
|
&dest, 3);
|
|
bufferend =
|
|
itoa(num, &buffer, 16,
|
|
sizes[asize], '0');
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case 'x':
|
|
case 'X':
|
|
case 'y':
|
|
case 'Y':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = '0';
|
|
if (achar == 'X')
|
|
counter +=
|
|
fonction
|
|
(&strbase16, &dest,
|
|
2);
|
|
bufferend =
|
|
itoa(num, &buffer, 16,
|
|
sizes[asize],
|
|
charadd);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
if (achar == 'X' || achar == 'Y')
|
|
strtoupper(&buffer);
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
case 'b':
|
|
if (asize == 0)
|
|
num = (u64) va_arg(args,
|
|
u8);
|
|
else if (asize == 1)
|
|
num = (u64) va_arg(args,
|
|
u16);
|
|
else if (asize == 2)
|
|
num = (u64) va_arg(args,
|
|
u32);
|
|
else
|
|
num = (u64) va_arg(args,
|
|
u64);
|
|
if (charadd == 0xFF)
|
|
charadd = '0';
|
|
counter +=
|
|
fonction(&strbase2, &dest,
|
|
2);
|
|
bufferend =
|
|
itoa(num, &buffer, 2,
|
|
sizes[asize],
|
|
charadd);
|
|
buffersize =
|
|
bufferend - &buffer[0];
|
|
counter +=
|
|
fonction(&buffer, &dest,
|
|
buffersize);
|
|
flag = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
buffer[0] = '\000';
|
|
fonction(&buffer, &dest, 1);
|
|
return counter;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* converti un réel signé en chaine de caractère */
|
|
|
|
u8 *rtoadouble(double num, u8 * str, u8 precisioni, u8 precisionf)
|
|
{
|
|
s8 power10;
|
|
u8 *pointer = str;
|
|
u8 i, j, integerpart, fracpart;
|
|
if (precisioni == 0)
|
|
precisioni = 12;
|
|
if (precisionf == 0)
|
|
precisionf = 8;
|
|
double round = 0.5;
|
|
for (i = 0; i < precisionf; i++)
|
|
round /= 10;
|
|
num += round;
|
|
bool intok = false;
|
|
if (num < 0)
|
|
{
|
|
num = -num;
|
|
*(pointer++) = '-';
|
|
}
|
|
power10 = 0;
|
|
{
|
|
while (num >= 10.0)
|
|
{
|
|
num /= 10;
|
|
power10++;
|
|
}
|
|
}
|
|
if (power10 < precisioni)
|
|
{
|
|
fracpart = power10;
|
|
power10 = 0;
|
|
}
|
|
else
|
|
{
|
|
fracpart = precisioni;
|
|
power10 = power10 - precisioni + 1;
|
|
}
|
|
if (power10 == 0)
|
|
{
|
|
if (num != 0.0)
|
|
{
|
|
while (num < 1.0)
|
|
{
|
|
num *= 10;
|
|
power10--;
|
|
}
|
|
}
|
|
}
|
|
|
|
i = j = 0;
|
|
while (num > 0)
|
|
{
|
|
if (!intok & (i > fracpart || i >= precisioni))
|
|
{
|
|
*(pointer++) = '.';
|
|
intok = true;
|
|
}
|
|
if (intok && j >= precisionf)
|
|
break;
|
|
num -= (integerpart = num);
|
|
*(pointer++) = integerpart + '0';
|
|
num *= 10.0;
|
|
if (!intok)
|
|
i++;
|
|
else
|
|
j++;
|
|
}
|
|
while ((*(pointer - 1)) == '0' && pointer > str + 1)
|
|
pointer--;
|
|
if ((*(pointer - 1)) == '.')
|
|
pointer--;
|
|
if (abs(power10) > 0)
|
|
{
|
|
*(pointer++) = 'e';
|
|
if (power10 < 0)
|
|
{
|
|
power10 = -power10;
|
|
*(pointer++) = '-';
|
|
}
|
|
*(pointer++) = (power10 / 10 + '0');
|
|
*(pointer++) = (power10 % 10 + '0');
|
|
}
|
|
*(pointer++) = 0;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* converti un réel signé en chaine de caractère */
|
|
|
|
u8 *rtoasingle(float num, u8 * str, u8 precisioni, u8 precisionf)
|
|
{
|
|
return rtoadouble((double) num, str, precisioni, precisionf);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* converti un entier non signé en chaine de caractère */
|
|
|
|
u8 *itoa(u64 orignum, u8 * str, u8 base, u64 dim, u8 achar)
|
|
{
|
|
u8 *pointer = str, i, size = 0;
|
|
u64 num = orignum;
|
|
if (dim >= 0xFF)
|
|
{
|
|
num &= dim;
|
|
if ((num == 0) && (achar == 0))
|
|
{
|
|
*(pointer++) = '0';
|
|
*pointer = '\000';
|
|
return pointer;
|
|
}
|
|
switch (base)
|
|
{
|
|
case 2:
|
|
size = log2(dim);
|
|
break;
|
|
case 8:
|
|
size = log2(dim) / 2;
|
|
break;
|
|
case 10:
|
|
size = log10(dim);
|
|
break;
|
|
case 16:
|
|
size = log2(dim) / 4;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
size = dim;
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
if (num == 0)
|
|
{
|
|
if (i == 0)
|
|
*(pointer++) = '0';
|
|
else
|
|
*(pointer++) = achar;
|
|
if (achar == 0)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
u64 result = num % (u32) base;
|
|
*(pointer++) =
|
|
(result >
|
|
9) ? (result - 10) + 'a' : result + '0';
|
|
num = num / (u32) base;
|
|
}
|
|
}
|
|
*pointer = '\000';
|
|
strinvert(str);
|
|
return pointer;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/* converti un entier en chaine de caractère */
|
|
|
|
u8 *sitoa(u64 num, u8 * str, u64 dim)
|
|
{
|
|
u8 *pointer = str;
|
|
bool isNegative = false;
|
|
num &= dim;
|
|
if (num == 0)
|
|
{
|
|
*(pointer++) = '0';
|
|
*pointer = '\000';
|
|
return pointer;
|
|
}
|
|
if ((((dim + 1) >> 1) & num) > 0)
|
|
{
|
|
isNegative = true;
|
|
num = (~num & dim) + 1;
|
|
}
|
|
while (num != 0)
|
|
{
|
|
u64 result = num % 10;
|
|
*(pointer++) =
|
|
(result > 9) ? (result - 10) + 'a' : result + '0';
|
|
num = num / 10;
|
|
}
|
|
if (isNegative)
|
|
*(pointer++) = '-';
|
|
*pointer = '\000';
|
|
strinvert(str);
|
|
return pointer;
|
|
}
|