build: correction d'erreur diverses...

Merge avec master 2.2.0

API.md

@@ -0,0 +1,75 @@
+## API List 
+
+APIs given by COS2000 libraries
+
+
+###  LIBSYS
+
+All fonctions in the "libsys" library.
+
+------
+
+`u32 exit(u32 resultcode);`
+
+*Description:End a task for user or kernel domain*
+
+* syscall id : **5**
+* arguments : **1**
+* * argument 1 : **u32 resultcode** *Code result of the execution*
+* results : **u32**
+* dump of register cpu: **no**
+
+------
+
+`u32 getticks(void);`
+
+*Description:Return the internal value of the timer*
+
+* syscall id : **4**
+* arguments : **0**
+* results : **u32**
+* dump of register cpu: **no**
+
+------
+
+`u8 waitkey(void);`
+
+*Description:Wait for user to press a key and return the ascii code pressed*
+
+* syscall id : **1**
+* arguments : **0**
+* results : **u8**
+* dump of register cpu: **no**
+
+------
+
+`u32 testapi(u32 arg1, u32 arg2, u32 arg3);`
+
+*Description:Simple function to test if SYSCALL API is correctly running*
+
+* syscall id : **0**
+* arguments : **3**
+* * argument 1 : **u32 arg1** *first argument of your choice*
+* * argument 2 : **u32 arg2** *second argument of your choice*
+* * argument 3 : **u32 arg3** *third argument of your choice*
+* results : **u32**
+* dump of register cpu: **yes**
+
+
+###  LIBVIDEO
+
+All fonctions in the "libvideo" library.
+
+------
+
+`u32 print(u8* string);`
+
+*Description:Show a string on the screen*
+
+* syscall id : **2**
+* arguments : **1**
+* * argument 1 : **u8* string** *string to show in ascii format*
+* results : **u32**
+* dump of register cpu: **no**
+
+

BUGS.md

@@ -0,0 +1,24 @@
+## Liste de BUGS à corriger
+
+### VIDEO
+
+* Interpolation des droites lorsques les coordonnées sortent de l'écran : erreur les coefficient directeur sont faux.
+* Les modes VGA ne fonctionnent pas tous.
+* Ralentissement lors du défilemment de la console en VESA.
+
+### 3D
+
+La 3D utiliser sauvagement la mémoire sans malloc !!
+
+### 2D
+
+Le remplissage des triangles n'est pas parfais, 2 algo différents entre lignes et remplissage.
+
+### SHELL
+
+* La fonction regs est à reprendre...
+* La fonction IDT est à adapter à la taille de l'écran
+
+
+
+

INFORMATIONS.md

@@ -0,0 +1,13 @@
+![logo](https://github.com/dahut87/cos2000/raw/master/Graphisme/logo.png)
+
+## Organisation du noyau
+
+### Mémoire
+
+L'organisation de la mémoire de COS2000 répond au schéma suivant:
+
+![logo](https://github.com/dahut87/cos2000/raw/master/Graphisme/map.png)
+
+### API
+
+COS2000 utilise les fonctions SYSENTER/SYSEXIT

README.md

@@ -1,13 +1,15 @@
-![logo](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/logo.png)
+![logo](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/logo.png)
 
-## Présentation du projet
+## COS2000
 
-### Qu'est ce que COS2000 ?
+### Présentation du projet
 
-COS2000 est un système d'exploitation minimaliste qui vise essentiellement un objectif pédagogique.
+#### Qu'est ce que COS2000 ?
+
+COS2000 est un système d'exploitation minimaliste dont l'objectif est essentiellement pédagogique.
 Il s'agit avant tout du travail d'un passionné de programmation système.
 
-Le système est développé essentiellement en langage C mais il comporte aussi un peu d'assembleur X86.
+Le système est développé essentiellement en langage C mais il comporte aussi quelques lignes d'assembleur X86.
 
 #### Qu'est ce qu'un système d'exploitation ?
 
@@ -23,9 +25,7 @@ Sans système d'exploitation votre ordinateur est inopérant: c'est une boite vi
 
 #### Comment utiliser COS2000 ?
 
-COS2000 n'a pas pour but d'être utilisé en production. Il s'agit d'un système en cours de
-développement que vous pouvez néanmoins tester sur un ordinateur physique ou de préférence sur une machine virtuelle.
-Il est nécessaire de compiler le système avant de démarrer celui-ci à partir d'un périphérique amovible (clé usb).
+COS2000 n'a pas pour but d'être utilisé en production. Il s'agit d'un système en cours de développement que vous pouvez néanmoins tester sur un ordinateur physique ou de préférence sur une machine virtuelle. Il est nécessaire de compiler le système avant de démarrer celui-ci à partir d'un périphérique amovible (clé usb).
 
 #### Sur quel ordinateur fonctionne t'il ?
 
@@ -45,13 +45,191 @@ Les détails se trouvent dans le fichier `LICENSE.md`
 
 ![logo](https://www.gnu.org/graphics/lgplv3-with-text-154x68.png)
 
+### Compilation de COS2000
+
+#### Logiciels utilisés
+
+L'OS a été développé sous Linux afin de disposer d'un maximum d'outils dont GCC/GAS/Docker et l'ensemble des BINUTILS. Je vous conseille donc d'utiliser Linux afin de procéder à la compilation même si celle-ci peut fonctionner depuis Windows grace à Cygwin. Des distributions "Live" existent si vous ne souhaitez pas installer sur votre ordinateur (http://www.linuxmint.com/edition.php?id=259).
+
+Le système de conteneurisation Docker est exploité afin de d'assurer une reproductibilité totale de l'environnement de compilation quelque soit le système d'exploitation utilisé.
+
+#### Installation/compilation automatique
+
+Téléchargez et exécutez le script d'installation automatique et de compilation "menu.sh"
+
+`wget https://raw.githubusercontent.com/dahut87/cos2000v2/develop/menu.sh`
+
+Executez le script et les sources seront ainsi automatiquement téléchargées sur votre ordinateur par le biais de Git.
+
+`chmod 755 ./menu.sh && ./menu.sh`
+
+Un menu s'affiche ensuite qui vous propose de réaliser différentes tâches dont la compilation et/ou le test de COS2000.
+
+![Menu de compilation](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/compilation.png)
+
+#### Installation/compilation manuelle
+
+##### Téléchargement de COS2000
+
+Afin de faciliter la mise à jour et le suivi des version de COS2000, GIT est utilisé.
+
+Si vous n'avez pas GIT, installez le avec la commande suivante (sous paquet debian .deb):
+
+`sudo apt-get install git`
+
+Puis cloner le source chez vous avec la commande :
+
+`git clone https://github.com/dahut87/cos2000.git`
+
+##### Compilation en ligne de commande
+  
+Docker est utilisé afin de permettre le fonctionnement correcte de la compilation. Au premier lancement de make.sh, si vous utilisez une distribution basée sur le système de paquet Debian, l'installation sera réalisée automatiquement. Dans le cas contraire, installez Docker et relancez le script. Une image docker est produite afin de procéder ensuite à la compilation du système.
+
+Commande de compilation de base
+
+* `./make.sh all` compile tout le projet dans sa version disque dur et disque dur en UEFI
+
+Autres commandes de compilation de COS2000
+
+* `./make.sh harddisk` compile la version disque dur
+* `./make.sh harddiskuefi` compile la version disque dur UEFI
+* `./make.sh test` lance l'émulation QEMU en 32 bits sur disque dur
+* `./make.sh test64` lance l'émulation QEMU en 64 bits sur disque dur en UEFI
+* `./make.sh clean` supprime les fichers compilés
+* `./make.sh syscall` réactualise les librairies du domaine utilisateur
+* `./make.sh programs` compile les programmes du domaine utilisateur
+* `./make.sh config` change la configuration de la compilation
+
+### Utilisation
+
+#### Sur un ordinateur émulé
+
+Pour tester l'OS en émulation taper donc la commande `./make.sh test` qui compilera avant de lancer Qemu.
+
+#### Sur un ordinateur physique
+
+Lancer une compilation du système COS2000
+
+`./make.sh all` 
+
+Puis, il faut copier l'image sur une clé (Attention l'opération effacera le contenu de la clé) :
+
+`sudo dd if=./final/harddisk.img.final of=/dev/sdx bs=1M` (ou sdx est votre périphérique)
+
+Bootez sur votre clé en mode bios (legacy).
+
+Pour un boot en mode UEFI
+
+`sudo dd if=./final/harddiskuefi.img.final of=/dev/sdx bs=1M` (ou sdx est votre périphérique)
+
+Pour connaitre le numéro de votre périphérique (clé)
+
+`lsblk`
+
+#### Commandes de COS2000
+
+Pour l'instant quelques commandes seulement sont disponibles:
+
+* `REBOOT` redémarre le PC,
+* `CLEAR` efface l'écran,
+* `MODE` change le mode video,
+* `DETECTCPU` detecte et affiche les informations CPU,
+* `DETECTPCI` detecte et affiche les périphériques PCI,
+* `TEST2D` teste l'affichage graphique 2D,
+* `TEST3D` teste l'affichage graphique 2D,
+* `REGS` affiche les registres CPU,
+* `GDT` affiche la table des descripteurs,
+* `IDT` affiche la table des interruptions,
+* `MEM` affiche les statistiques d'occupation memoire,
+* `INFO` affiche des informations issues de GRUB,
+* `ERR` génère une exception (ARGUMENTS),
+* `VIEW` visionne la mémoire vive (ARGUMENTS),
+* `LOGO` affiche le logo,
+* `FONT` change la police d'affichage (ARGUMENTS),
+* `HELP` affiche les commandes disponibles,
+* `BPSET` met un point d'arrêt pour le débogueur (ARGUMENTS),
+* `BPCLR` efface un point d'arrêt (ARGUMENTS),
+* `DISASM` désassemble une portion de mémoire (ARGUMENTS),
+
+![COS2000 le 28-09-2018](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/28-09-2018.png)
+
+### Organisation du dépôt
+
+* `debug` - fichiers configuration débogueur
+* `docker` - fichiers pour la construction de containers
+* `final` - img raw utilisables avec un émulateur des 3 versions
+* * `harddisk.img.xz`
+* * `harddiskuefi.img.xz`
+* `Graphisme` - fichiers images
+* *  `screenshots` - screenshots de l'évolution du système
+* `include` - fichier d'entête C
+* `lib` - librairies pour le noyau
+* `makefile` - Makefile du projet
+* `make.sh` - Script de compilation utilisant Docker
+* `menu.sh` - Script du menu d'autocompilation
+* `templates` - Modèles utilisés pour générer des libraires du domaine utilisateur
+* `programs` - programmes pour le domaine utilisateur
+* *  `include` - fichier d'entête C
+* *  `lib` - librairies pour le domaine utilisateur
+* `README.md` - ce que vous lisez
+* `LICENSE.md` - la licence LGPLv3.0
+* `INFORMATIONS.md` - informations sur le développement de COS2000
+* `BUGS.md` - bugs rélevés dans le système
+* `API.md` - Liste des APIs fournies par le système COS2000
+* `system` - le noyau lui-même
+
 ### En savoir plus...
 
+#### Avancement du projet
+
+* démarrage tout support grâce à GRUB (disquette, disque dur/SSD, réseau...Etc),
+* pilotes souris et clavier,
+* pilotes VGA et VESA (framebuffer),
+* bibliothèque graphique 2D,
+* bibliothèque graphique 3D,
+* gestion des interruptions (IDT),
+* gestion de la segmentation (GDT),
+* gestion de la mémoire paginée,
+* débogueur et désassembleur intégré,
+* interpréteur de commande,
+* affichage de chaîne de caractères (prinfs,sprintf,vsprintf) avec type (bin,hexa,octal,float,double,string,char),
+* mode protégé limité à 4Go de mémoire vive (32 bits),
+* gestion avancée de la mémoire (vmalloc).
+* chargeur ELF32,
+* espace utilisateur et appels systèmes,
+* ordonnanceur de tâche (par TSS),
+
+#### En cours
+
+* correction de bogues - libération des ressources après destruction processus,
+* liste d'API automatiquement mise à jour avec intégration de librairies & header,
+* gestion du système de fichier CRAMFS,
+* lancement du noyau par kernel et non par multiboot afin de bénéficier de initrd, 
+
+#### A faire
+
+* pilote IDE/ATA (PIO mode),
+* fonctions affichage image PNG,
+* double buffering,
+* gestion multiprocessing,
+* virtualisation par VMX,
+* Gestion du système de fichier EXT2FS.
+
+![COS2000 le 29-11-2018](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/29-11-2018.png)
+
+#### Autres Licences (autres auteurs)
+
+Des fichiers sources utilisés par COS2000 sont sous d'autres licences, parmis ceux-ci figurent :
+
+* `include/queues.h` sous licence Berkeley Software Distribution License
+* `tools/*` sous licence GPL V2.0, fichiers issus du noyau Linux
+* `debug/gdbinit`, GDB dashboard - Modular visual interface for GDB in Python Copyright (c) 2015-2017 Andrea Cardaci <cyrus.and@gmail.com>.
+
 #### Historique du projet
 * Version 2.2fr - C en mode protégé Reprise du projet
 * Version 2.1fr - C en mode protégé Abandon du projet
 * Version 2.0   - C en mode protégé VGA text+pmode
-* Version 1.x   - Assembleur en mode réel
+* Version 1.x   - Assembleur en mode réel (v1.0 - 1.4.2fr)
 
 >  “La connaissance s'acquiert par l'expérience,
 >          tout le reste n'est que de l'information..

SCREENSHOTS.md

@@ -1,4 +1,6 @@
 ![logo](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/logo.png)
 
 ## Copies d'écran de COS2000
+![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/28-09-2018.png)
+![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/29-11-2018.png)
 ![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/ansi.png)

boot/boot12.asm

@@ -1,245 +0,0 @@
-[BITS 16]
-[ORG 0x7C00]
-
-section .text
-
-start:
-    jmp	near Boot
-			
-Disk_ID			    db	"COS2000A"	;Fabricant + n° de série Formatage
-Sectors_Size		dw	512		;Nombre d'octets/secteur
-Sectors_Per_Cluster	db	1		;Nombre de secteurs/cluster
-Reserved_Sectors	dw	1		;Nombre de secteurs réservé
-Fats_Number		    db	2		;Nombre de copies de la FAT
-Fits_Number		    dw	224		;Taille du répertoire racine
-Sectors_Per_Disk	dw	2880		;Nombre secteurs du volume si < 32 Mo
-Media_Descriptor	db	0xF0		;Descripteur de média
-Sectors_Per_Fat		dw	9		;Nombre secteurs/FAT
-Sectors_Per_Track	dw	18		;Nombre secteurs/piste
-Heads_Number		dw	2		;Nombre de tete de lecture/écriture
-Sectors_Hidden		dd	0		;Nombre de secteurs cachés
-Sectors_Per_Disk2	dd	0		;Nombre secteurs du volume si > 32 Mo
-Boot_Drive		    db	0		;Lecteur de démarrage
-Reserved		    db	0		;NA (pour NT seulement)
-Extended_Boot_ID	db	0x29		;Signature Boot étendu 29h
-Serial_Number		dd	0x01020304	;N° de série
-Disk_Name		    db	"COS2000    "	;Nom de volume
-Fat_Type		    db	"FAT12   "	;Type de système de fichiers
-
-Boot_Message		db "Cos2000",0
-Entre_Message       db "Fichier",0
-Loading_Message		db "Charger",0
-System_File		    db "Al",0,"o",0,"a",0,"d",0,"e",0,0x0F,0,0x38,"r",0,".",0,"s",0,"y",0,"s",0,0,0,0,0,0xFF,0xFF,0xFF,0xFF
-Is_Ok			    db " [  OK  ]",0x0A,0x0D,0
-Is_Failed		    db " [ERREUR]",0x0A,0x0D,0
-The_Dot			    db '.',0
-
-Boot_Error:
-    mov	    si,Is_Failed
-    call	ShowString
-    xor     ax,ax
-    int	    0x16
-    int	    0x19
-
-Boot_Ok:
-	mov	    si,Is_Ok
-	call	ShowString
-	ret
-
-Boot:
-    push	cs
-    push	cs
-    pop	es
-    pop	ds
-	mov	[Boot_Drive],dl
-    cli        
-    mov	ax,0x9000
-    mov	ss,ax
-    mov	sp,0xFFFF
-    sti
-    mov si,Boot_Message
-    call ShowString	
-    xor	ax,ax
-    int	0x13
-    jc	Boot_Error
-	mov	cx,[Reserved_Sectors]
-    add	cx,[Sectors_Hidden]
-    adc	cx,[Sectors_Hidden+2]
-    mov	bx,[Sectors_Per_Fat]
-    mov di,Fat_Buffer
-    push bx
-    push cx
-readfat:
-    call    ReadSector
-    jc  Boot_Error
-	inc cx
-	add di,[Sectors_Size]
-	dec bx
-	jnz readfat          
-    pop cx
-    pop bx
-    xor	ax,ax
-    mov	al,[Fats_Number]
-    mul	bx
-    add	cx,ax
-    mov	ax,32
-    mul	word [Fits_Number]
-    div	word [Sectors_Size]
-    add	ax,cx
-    sub	ax,2
-    mov	word [Serial_Number],ax
-    xor	dx,dx
-	call	Boot_Ok
-    mov si,Loading_Message
-    call ShowString	
-Find_System:
-    mov	di,Buffer
-    call	ReadSector
-    jc	Near Boot_Error
-    xor	bx,bx
-Next_Root_Entrie:
-    cmp	byte [di],0
-    je	near Boot_Error
-    push	di
-    push	cx
-    mov	si,System_File
-    mov	cx,32
-    rep	cmpsb
-    pop	cx
-    pop	di
-    je	System_Found
-    add	di,32
-    add	bx,32
-    inc	dx
-    cmp	dx,[Fits_Number]
-    ja	near Boot_Error
-    cmp	bx,[Sectors_Size]
-    jb	Next_Root_Entrie
-    inc	cx
-    jmp	Find_System
-System_Found:
-    call Boot_Ok
-    mov si,Entre_Message
-    call ShowString	
-    mov	cx,[di+26+32]
-    mov	ax,0x0080
-    mov	es,ax
-    push	es
-    mov	di,0x0
-    push	di
-	mov	si,The_Dot
-Resume_Loading:
-    cmp	cx,0x0FF0
-    jae	Finish_Loading
-    push	cx
-    add	cx,word [Serial_Number]
-    call	ReadSector
-    pop	cx
-    jc  near Boot_Error
-	call    ShowString
-    add	    di,[Sectors_Size]
-    call	NextFatGroup
-    jc	near Boot_Error
-    jmp	Resume_Loading
-Finish_Loading:
-	call	Boot_Ok
-    retf
-
-;====================READSECTOR=======================
-;Lit le secteur logique LBA CX et le met en es:di
-;-> CX (limité à 65536 secteurs, soit 32 Mo avec secteur 512 octets)
-;<- Flag Carry si erreur
-;=====================================================
-ReadSector:
-	pusha
-	mov ax,cx
-	xor	dx,dx
-	div	word [Sectors_Per_Track]
-	inc	dl
-	mov	bl,dl
-	xor	dx,dx
-	div word [Heads_Number]
-	mov dh, [Boot_Drive]
-	xchg    dl,dh
-	mov	cx,ax
-	xchg	cl,ch
-	shl	cl,6
-	or	cl, bl
-	mov	bx,di
-	mov	si, 4
-	mov	al, 1
-Read_Again:
-  	mov	ah, 2
-  	int	0x13
-  	jnc	Read_Done
-  	dec	si
-  	jnz	Read_Again
-Read_Done:
-  	popa
-	ret
-
-;===================NEXTFATGROUP======================
-;Renvoie en CX le groupe qui succède dans la FAT le groupe CX
-;-> CX
-;<-
-;=====================================================
-NextFatGroup:
-	push	bx
-	push	dx
-	push	di
-	mov	    ax,cx
-	mov	    bx,ax
-	and	    bx,0000000000000001b
-	shr	    ax,1
-	mov	    cx,3
-	mul	    cx
-	mov	    di,Fat_Buffer
-	add	    di,ax
-	cmp	    bx,0
-	jnz	    Even_Group
-Odd_Group:
-	mov	    dx,[di]
-	and	    dx,0x0FFF
-	mov	    cx,dx
-	jmp	    Next_Group_Found
-Even_Group:
-	mov	    dx,[di+1]
-	and	    dx,0xFFF0
-	shr	    dx,4
-	mov	    cx,dx
-Next_Group_Found:
-	pop	    di
-	pop	    dx
-	pop	    bx
-	ret
-
-;======================SHOWSTR========================
-;Affiche la chaine de caractère pointé par ds:si à l'écran
-;-> DS, SI
-;<- Flag Carry si erreur
-;=====================================================
-ShowString:
-	    pusha
-Next_Char:
-        lodsb
-        or	al,al
-        jz	End_Show
-        mov	ah,0x0E
-        mov	bx,0x07
-        int	0x10
-        jmp	Next_Char
-End_Show:
-	    popa
-        ret
-
-times 510-($-$$) db ' '
-
-dw	0xAA55
-
-Buffer		equ $
-Fat_Buffer	equ $+512
-
-section .bss
-
-;Buffer		resb 512
-;Fat_Buffer	resb 10000

boot/boot16.asm

@@ -1,270 +0,0 @@
-[BITS 16]
-[ORG 0x7C00]
-
-section .text
-
-start:
-	jmp	near Boot
-			
-Disk_ID			db	"COS2000A"	;Fabricant + n° de série Formatage
-Sectors_Size		dw	512		;Nombre d'octets/secteur
-Sectors_Per_Cluster	db	4		;Nombre de secteurs/cluster
-Reserved_Sectors	dw	1		;Nombre de secteurs réservé
-Fats_Number		db	2		;Nombre de copies de la FAT
-Fits_Number		dw	512		;Taille du répertoire racine
-Sectors_Per_Disk	dw	2880		;Nombre secteurs du volume si < 32 Mo
-Media_Descriptor	db	0xF8		;Descripteur de média
-Sectors_Per_Fat		dw	207		;Nombre secteurs/FAT
-Sectors_Per_Track	dw	18		;Nombre secteurs/piste
-Heads_Number		dw	38		;Nombre de tete de lecture/écriture
-Sectors_Hidden		dd	16		;Nombre de secteurs cachés
-Sectors_Per_Disk2	dd	39		;Nombre secteurs du volume si > 32 Mo
-Boot_Drive		db	0x80		;Lecteur de démarrage
-Reserved		db	0		;NA (pour NT seulement)
-Extended_Boot_ID	db	0x29		;Signature Boot étendu 29h
-Serial_Number		dd	0x01020304	;N° de série
-Disk_Name		db	"COS2000    "	;Nom de volume
-Fat_Type		db	"FAT16   "	;Type de système de fichiers
-
-;Cpu_Message		db "CPU test",0
-;Boot_Message		db "Booting ",0
-;Finding_Message	db "System  ",0
-;Loading_Message	db "Loading ",0
-System_File		db "SYSTEM  SYS"
-Is_Ok			db "[  OK  ]",0x0A,0x0D,0
-Is_Failed		db "[Failed]",0x0A,0x0D,"Press a key",0x0A,0x0D,0
-The_Dot			db '.',0
-
-Boot_Error:
-        mov	si,Is_Failed
-        call	ShowString
-        mov	ah,0
-        int	0x16
-        int	0x19
-
-Boot_Ok:
-;	mov	al,[Stage]
-;	cmp	al,0
-;	jz	No_Ok
-	mov	si,Is_Ok
-	call	ShowString
-;No_Ok:	
-;	xor	ah,ah
-;	mov	si,ax
-;	add	si,Boot_Message ;Cpu_Message
-;	call	ShowString
-;	add	byte [Stage],0x09	
-       ret
-;
-;Stage	db 0
-
-Boot:
-	push	cs
-        push	cs
-        pop	es
-        pop	ds
-        mov	[Boot_Drive],dl
-        cli
-        mov	ax,0x9000
-        mov	ss,ax
-        mov	sp,0xFFFF
-        sti
-;	call	Detect_Cpu
-;	jc	Boot_Error	
-;       call	Boot_Ok
-        xor	ax,ax
-        int	0x13
-;        jc	Boot_Error
-	xor	eax,eax
-        add	ax,[Reserved_Sectors]
-        add	ecx,eax
-        mov	di,Fat_Buffer
-        call	ReadSector
-        jc	Boot_Error
-        xor	eax,eax
-        mov	al,[Fats_Number]
-        mov	bx,[Sectors_Per_Fat]
-        mul	bx
-        add	ecx,eax
-        mov	ax,32
-        mul	word [Fits_Number]
-        div	word [Sectors_Size]
-        add	eax,ecx
-        mov	dword [Serial_Number],eax
-        xor	dx,dx
-;        call	Boot_Ok
-Find_System:
-        mov	di,Buffer
-        call	ReadSector
-        jc	near Boot_Error
-        xor	bx,bx
-Next_Root_Entrie:
-        cmp	byte [di],0
-        je	near Boot_Error
-        push	di 
-	push	cx
-        mov	si,System_File
-        mov	cx,11
-        rep	cmpsb
-        pop	cx 
-	pop	di
-        je	System_Found
-        add	di,32
-        add	bx,32
-        inc	dx
-        cmp	dx,[Fits_Number]
-        ja	near Boot_Error
-        cmp	bx,[Sectors_Size]
-        jb	Next_Root_Entrie
-        inc	ecx
-        jmp	Find_System
-System_Found:
-	xor	ecx,ecx
-        mov	cx,[di+26]	
-        mov	ax,0x0071
-        mov	es,ax
-        push	es
-        mov	di,0x100
-        push	di
-;        call	Boot_Ok
-        mov	si,The_Dot
-Resume_Loading:
-        cmp	cx,0x0FFF0
-        jae	Finish_Loading
-        call	ReadGroup
-        jc	near Boot_Error
-        call	ShowString
-        mov  	bx,cx
-        shl  	bx,1
-        mov  	cx,[bx+Fat_Buffer]
-        jmp  	Resume_Loading
-Finish_Loading:
-	call	Boot_Ok
-        retf
-
-;====================READSECTOR=======================
-;Lit le secteur logique LBA ECX et le met en es:di
-;-> ECX (limité à 2^32 secteurs, soit 2 To avec secteur 512 octets)
-;<- Flag Carry si erreur
-;=====================================================
-ReadSector:
-        pushad
-        mov     ax, cx
-        ror     ecx,16
-        mov     dx,cx
-        rol     ecx,16
-        cmp     ecx,4128705
-        ja      Extended_CHS
-        div     word [Sectors_Per_Track]
-        inc     dl
-        mov     bl, dl
-        xor     dx,dx
-        div     word [Heads_Number]
-        mov     dh, [Boot_Drive]
-        xchg    dl, dh
-        mov     cx, ax
-        xchg    cl, ch
-        shl     cl, 6
-        or      cl, bl
-        mov     bx, di
-        mov     si, 4
-        mov     al, 1
-Read_Again:
-        mov     ah, 2
-        int     0x13
-        jnc     Read_Done
-        dec     si
-        jnz     Read_Again
-Read_Done:
-        popad
-        ret
-Extended_CHS:
-        mov     si,ECHS_Block
-        mov     byte [si+Sizes],0x10
-        mov     byte [si+Reserve],0x01
-        mov     byte [si+NumSectors],0x01
-        mov     [si+Adressseg],es
-        mov     [si+Adressoff],di
-        mov     [si+SectorLow],ax
-        mov     [si+SectorHigh],dx
-        mov     di,4
-        mov     dl,[Boot_Drive]
-Read_AgainX:
-        mov     ah, 42h
-        int     13h
-        jnc     Read_Done
-        dec     di
-        jnz     Read_AgainX
-
-;======================READGROUP======================
-;lit le groupe cx en es:di et incr‚mente DI
-;-> cx, es:di
-;<- di, Flag Carry si erreur
-;=====================================================
-ReadGroup:
-        push 	ax 
-	push	cx 
-	push	dx
-        mov  	al,[Sectors_Per_Cluster]
-        sub  	cx,2
-        xor  	ah,ah
-        mul  	cx
-        mov  	cx,dx
-        shl  	ecx,16
-        mov  	cx,ax
-        add  	ecx,dword [Serial_Number]
-        mov  	al,[Sectors_Per_Cluster]
-read:
-        call 	ReadSector
-        jc	errors
-        inc 	ecx
-        add  	di,[Sectors_Size]
-        dec  	al
-        jnz  	read
-        clc	
-errors:
-        pop  	dx 
-	pop	cx 
-	pop	ax
-        ret      
-
-;======================SHOWSTR========================
-;Affiche la chaine de caractère pointé par ds:si à l'écran
-;-> DS, SI
-;<- Flag Carry si erreur
-;=====================================================
-ShowString:
-        ;push 	ax
-        ;push	bx
-        ;push	si
-	pusha
-Next_Char:
-        lodsb
-        or	al,al
-        jz	End_Show
-        mov	ah,0x0E
-        mov	bx,0x07
-        int	0x10
-        jmp	Next_Char
-End_Show:
-        ;pop 	si
-        ;pop	bx
-        ;pop	ax
-	popa
-        ret
-
-times 510-($-$$) db ' '
-
-dw	0xAA55
-
-ECHS_Block	equ $
-Buffer		equ $+26
-Fat_Buffer	equ $+26+512
-
-section .bss
-
-%include "echs.h"
-
-;ECHS_Block	resb 24
-;Buffer		resb 512
-;Fat_Buffer	resb 10000

boot/echs.h

@@ -1,10 +0,0 @@
-struc echs
-Sizes    	resb 1
-Reserve 	resb 1
-NumSectors 	resw 1
-Adressoff 	resw 1
-Adressseg 	resw 1
-SectorLow 	resw 1
-SectorHigh 	resw 1
-Dummy 		resq 1
-endstuc

boot/elf.h

@@ -1,116 +0,0 @@
-struc ELFheader
-.Magic                  resb 1;"0x7F"
-.MagicStr               resb 3;"ELF"
-.Computertype           resb 1;1
-.Endianness             resb 1;1
-.Original               resb 1;1
-.OS                     resb 1;0
-.ABI                    resb 1;0
-.Dummy                  resb 7;0
-.Type                   resw 1;2
-.Target                 resw 1;3
-.Version                resd 1;1
-.Entrypoint             resd 1
-.Offsetprogram          resd 1
-.Offsetsection          resd 1
-.Flags                  resd 1
-.SizeELFheader          resw 1
-.Sizeprogram            resw 1
-.Nbprogram              resw 1
-.Sizesection            resw 1
-.Nbsection              resw 1
-.Index                  resw 1
-.end                    equ $
-endstruc 
-
-struc Program
-.Type                   resd 1
-.Offset                 resd 1
-.Vadress                resd 1
-.PAdress                resd 1
-.Size                   resd 1
-.Memsize                resd 1
-.Flags                  resd 1
-.Align                  resd 1
-.end                    equ $
-endstruc 
-
-struc Sections
-.Name                   resd 1
-.Type                   resd 1
-.Flags                  resd 1
-.Vadress                resd 1
-.Offset                 resd 1
-.Size                   resd 1
-.Link                   resd 1
-.Info                   resd 1
-.Align                  resd 1
-.Entrysize              resd 1
-.end                    equ $
-endstruc 
-
-
-;type
-PT_NULL equ 	0
-PT_LOAD equ	1
-PT_DYNAMIC equ	2
-PT_INTERP equ	3
-PT_NOTE equ	4
-PT_SHLIB equ	5
-PT_PHDR equ	6
-PT_TLS equ	7
-PT_LOOS equ	0x60000000
-PT_HIOS equ	0x6fffffff
-PT_LOPROC equ	0x70000000
-PT_HIPROC equ	0x7fffffff
-
-;flags
-PF_WRITE equ	0x1
-PF_ALLOC equ	0x2
-PF_X equ	0x1 	;Execute
-PF_W equ	0x2 	;Write
-PF_R equ	0x4 	;Read
-PF_MASKOS equ	0x0ff00000 	;Unspecified
-PF_MASKPROC equ	0xf0000000 	;Unspecified
-
-;type
-ST_EXIT  equ 1
-ST_NULL equ	0
-ST_PROGBITS equ	1
-ST_SYMTAB equ	2
-ST_STRTAB equ	3
-ST_RELA equ	4
-ST_HASH equ	5
-ST_DYNAMIC equ	6
-ST_NOTE equ	7
-ST_NOBITS equ	8
-ST_REL equ	9
-ST_SHLIB equ	10
-ST_DYNSYM equ	11
-ST_INIT_ARRAY equ	14
-ST_FINI_ARRAY equ	15
-ST_PREINIT_ARRAY equ	16
-ST_GROUP equ	17
-ST_SYMTAB_SHNDX equ	18
-ST_LOOS equ	0x60000000
-ST_HIOS equ	0x6fffffff
-ST_LOPROC equ	0x70000000
-ST_HIPROC equ	0x7fffffff
-ST_LOUSER equ	0x80000000
-ST_HIUSER equ	0xffffffff
-
-;flags
-SF_WRITE equ	0x1
-SF_ALLOC equ	0x2
-SF_EXECINSTR equ	0x4
-SF_MERGE equ	0x10
-SF_STRINGS equ	0x20
-SF_INFO_LINK equ	0x40
-SF_LINK_ORDER equ	0x80
-SF_OS_NONCONFORMING equ	0x100
-SF_GROUP equ	0x200
-SF_TLS equ	0x400
-SF_COMPRESSED equ	0x800
-SF_MASKOS equ	0x0ff00000
-SF_MASKPROC equ	0xf0000000
-

boot/loader.asm

@@ -1,852 +0,0 @@
-[BITS 16]
-[ORG 0x0]
-
-	SECTION .text
-		push 	cs
-		push 	cs
-		pop 	ds
-		pop 	es
-		mov   si,msg0
-		call showstr
-        		
-		mov   si,msg1
-		call showstr
-		call    initfat
-        call ok	
-		
-		mov   si,msg2
-		call showstr	
-        mov si,System_File	
-		call    search
-        call ok	
-		
-		mov   si,msg3
-		call showstr		
-        call    EnableA20
-        call ok	
-        	
-		mov   si,msg4
-		call showstr		
-		mov eax,cs		
-		shl eax,4
-		mov [GDT.Entry1+2],ax
-		mov [GDT.Entry2+2],ax
-		shr eax,16
-		mov [GDT.Entry1+4],al
-		mov [GDT.Entry2+4],al
-		mov eax,cs		
-		shl eax,4
-		add eax,gdt0
-		mov [GDTR.Address],eax
-		lgdt [GDTR]		
-call ok	
-        
-	    mov   si,msg5
-		call showstr
-		cli
-       mov eax,cr0
-           or al,1
-           mov cr0,eax
-           jmp short $+2
-           mov bx,SYS_DATA_SEL
-           mov fs,bx              
-           mov ds,bx
-           mov es,bx
-           mov gs,bx
-           and al,0FEh
-           mov cr0,eax
-           jmp short $+2
-           mov bx,cs
-           mov fs,bx              
-           mov ds,bx
-           mov es,bx
-           mov gs,bx           
-           sti
-call ok	
-        
-        
-        		
-		mov   si,msg6
-		call showstr		
-        mov  ebx,0x300000
-		call    load
-call ok		
-        		
-		mov   si,msg7
-		call showstr	
-		call    initpe
-call ok	
-		suite:
-		;mov cx,suite
-        ;call debug
-		mov   si,msg8
-		call showstr
-		cli
-		mov al,0x80	
-		out 0x70,al
-		mov eax,cr0	
-		or al,1
-		mov cr0,eax
-		jmp SYS_CODE_SEL:GoPMode32
-		
-		
-Boot_Error:
-		mov   si,error
-		call showstr 
-        xor ax,ax
-        int 16h
-        jmp 0xFFFF:0x0 	
-        
-ok:
-        push si 
-        push cx
-        mov cl,67
-        call eol
-		mov   si,okay
-		call showstr
-		pop cx 
-        pop si
-        ret	
-        
-;======================INITPE========================
-;Initialise le PE de l'adresse EBX 
-;-> 
-;<- Flag Carry si erreur
-;=====================================================              
-initpe:
-     pusha
-     push es
-     xor ax,ax
-     mov es,ax
-     mov [begin],ebx
-     cmp word [es:ebx+ELFheader.Magic],0x457F  ; bien l'entete .elf ?
-     jne near errorelf
-     cmp word [es:ebx+ELFheader.Magic+2],"LF"  ; bien l'entete .elf ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.Computertype],0x1  ; type ok ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.Endianness],0x1  ; type ok ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.Original],0x1  ; type ok ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.OS],0x0  ; type ok ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.ABI],0x0  ; type ok ?
-     jne near errorelf
-     cmp byte [es:ebx+ELFheader.Dummy],0x0  ; type ok ?
-     jne near errorelf
-     mov si,info1
-     call showstr
-     mov esi,[es:ebx+ELFheader.Entrypoint]
-     mov [entriepoint],esi    
-     mov esi,[es:ebx+ELFheader.Offsetprogram]
-     add esi,ebx
-     mov [offsetheader],esi
-     mov esi,[es:ebx+ELFheader.Offsetsection]
-     add esi,ebx
-     mov [offsetsection],esi  
-     mov cx,[es:ebx+ELFheader.Nbprogram]
-     mov [cs:nbprogram],cx
-     mov cx,[es:ebx+ELFheader.Nbsection]
-     mov [cs:nbsection],cx 
-     xor eax,eax
-     mov ax,[es:ebx+ELFheader.Index]
-     xor edx,edx
-     mov dx,[es:ebx+ELFheader.Sizesection]
-     mul edx
-     add eax,esi
-     mov eax,[es:eax+Sections.Offset]
-     add eax,ebx
-     mov [cs:symbol],eax
-     xor eax,eax
-     add ax,[es:ebx+ELFheader.Sizesection]
-     add esi,eax
-sections:
-     mov edi,esi
-     cmp dword [es:edi+Sections.Type],0x00
-     jz nothing
-     mov esi,info2
-     call showstr
-     push ds
-     push es
-     pop ds
-     mov esi,[es:edi+Sections.Name]
-     add esi,[cs:symbol]
-     call showstr
-     pop ds
-     mov esi,info3
-     call showstr 
-     mov edx,[es:edi+Sections.Offset]
-     push cx
-     mov cx,32
-     call ShowHex
-     pop cx
-     mov esi,info4
-     call showstr 
-     mov edx,[es:edi+Sections.Size]
-     push cx
-     mov cx,32
-     call ShowHex
-     pop cx
-     mov esi,info5
-     call showstr 
-     mov edx,[es:edi+Sections.Vadress]
-     push cx
-     mov cx,32
-     call ShowHex
-     pop cx
-     and dword [es:edi+Sections.Flags],SF_ALLOC
-     jne itsok
-     mov esi,info6
-     call showstr 
-     jmp itsok2
-itsok:
-     mov esi,info10
-     call showstr 
-call copy2mem
-     cmp dword [es:edi+Sections.Type],ST_NOBITS
-     jne itsok2
-     mov esi,info9
-     call showstr 
-     mov esi,info10
-     call showstr 
-call zero2mem
-itsok2:   
-     push cx
-     xor cx,cx
-     mov edx,[es:edi+Sections.Align]
-     mov esi,info8
-     call showstr 
-nextpower:
-     cmp edx,0
-     je powerok
-     cmp edx,1
-     je powerok
-     cmp cx,32
-     je powerok
-     inc cx
-     shr edx,1
-     jnc nextpower
-powerok:
-     mov edx,ecx
-     mov cx,4
-     call ShowHex
-     pop cx
-     call showrtn
-     mov esi,edi
-nothing:
-     add esi,eax
-     dec cx
-     jnz sections
-     mov esi,info7
-     call showstr 
-     mov edx,[cs:entriepoint]
-     mov cx,32
-     call ShowHex
-     clc
-     pop es
-     popa
-     ret     
-
-errorelf:
-    stc
-    pop es
-    popa
-    ret
-
-;==========DEBUG===========
-;CX adresse
-;->CX
-;<- 
-;===========================================
-debug:
-    mov esi,info11
-    call showstr 
-    xor edx,edx
-    mov dx,cs
-    shl edx,4     
-    add edx,ecx
-     mov cx,32
-     call ShowHex     
-infini:
-    jmp infini
-
-
-;==========COPY2MEM===========
-;Copie de es:esi vers es:edi
-;->ES:ESI ES:EDI CX
-;<- Flag
-;===========================================
-copy2mem:
- push eax
- push esi
- push edi
-push ecx
-mov esi,[es:edi+Sections.Offset]
-add esi,[cs:begin]
-mov ecx,[es:edi+Sections.Size]
-shr ecx,2
-inc ecx
-mov edi,[es:edi+Sections.Vadress]
-copietomem:
-       mov eax,[es:esi]
-       mov [es:edi],eax
-       add edi,4
-       add esi,4       
-       dec ecx
-       jnz copietomem       
-pop ecx
-pop edi
-pop esi
-pop eax
-ret
-
-;==========ZERO2MEM===========
-;Remise à zero de es:edi
-;->ES:EDI CX
-;<- Flag
-;===========================================
-zero2mem:
- push eax
- push esi
- push edi
-push ecx
-mov esi,[es:edi+Sections.Offset]
-add esi,[cs:begin]
-mov ecx,[es:edi+Sections.Size]
-shr ecx,2
-inc ecx
-mov edi,[es:edi+Sections.Vadress]
-      mov eax,0
-zerotomem:
-      mov [es:edi],eax
-      add edi,4
-       dec ecx
-       jnz zerotomem  
-pop ecx
-pop edi
-pop esi
-pop eax
-ret
-
-begin dd 0
-entriepoint dd 0
-offsetheader dd 0
-offsetsection dd 0
-nbprogram dw 0
-nbsection dw 0
-symbol dd 0
-
-;==========SHOWHEX===========
-;Affiche un nombre hexadécimal EDX de taille CX aprés le curseur
-;-> EDX un entier, CX la taille
-;<- 
-;===========================================
-ShowHex:
-       push  ax
-       push bx 
-       push cx 
-       push edx
-       push si
-       mov   ax,cx
-	 shr   ax,2
-       sub   cx,32
-       neg   cx
-       shl   edx,cl
-       xor cx,cx
-       inc cx
-Hexaize:
-       rol   edx,4
-       mov   bx,dx
-       and   bx,0fh
-       mov   si,ax
-       mov   al,[cs:bx+Tab]
-       xor  bx,bx  
-        mov	ah,0x09
-        mov	bl,[cs:thecolor]
-        int	0x10
-        mov	ah,0x0E
-        int	0x10 
-       mov ax,si
-       dec   al
-       jnz   Hexaize
-       pop si
-       pop   edx 
-       pop cx 
-       pop bx 
-       pop ax
-       ret
-Tab db '0123456789ABCDEF'
-
-;======================EOL========================
-;Va en colonne CX
-;-> 
-;<- Flag Carry si erreur
-;=====================================================              
-eol:
-  pusha
-  mov bp,cx
-    mov ah,03
-    xor bx,bx
-    int 10h
-    mov ah,02
-    mov cx,bp
-    mov dl,cl
-    int 10h
-    popa
-    ret
-
-
-;======================LOAD========================
-;Charge le groupe en mémoire en ebx
-;-> 
-;<- Flag Carry si erreur
-;=====================================================              
-load:
-     push ax
-     push ebx
-     push ecx 
-     push edx
-     push esi 
-     push edi
-     push fs
-      xor edx,edx
-      xor ax,ax
-      mov fs,ax
-       mov	si,The_Dot
-	   mov dx,[Sectors_Size]
-Resume_Loading:
-        cmp	cx,0x0FF0
-        jae	Finish_Loading
-        push	cx
-        add	cx,word [data]
-        mov edi,Buffer
-        call	ReadSector
-        pop	cx
-        jc	near Boot_Error
-	    call	showstr
-        push esi 
-        push ebx
-        push cx
-        mov esi,Buffer
-        mov cx,dx
-        shr cx,2
-copie:
-       mov eax,[ds:esi]
-       mov [fs:ebx],eax
-       add ebx,4
-       add esi,4       
-       dec cx
-       jnz copie
-        pop  cx
-        pop  ebx
-        pop  esi 
-        add	ebx,edx 
-        call	NextFatGroup
-        jc	near Boot_Error
-        jmp	Resume_Loading
-Finish_Loading:
-   pop fs
-   pop edi
-   pop esi
-   pop edx
-   pop ecx
-   pop ebx
-   pop ax
-   ret
-
-;======================INITFAT========================
-;Initialise les variables de la fat
-;-> 
-;<- Flag Carry si erreur
-;=====================================================
-initfat:
-        pusha
-        push ds
-        xor ax,ax
-        mov ds,ax
-        mov si,0x7C0B
-        mov di,bootsector
-        mov cx, 512
-        rep movsb
-        pop ds
-	    mov	cx,[Reserved_Sectors]
-        add	cx,[Sectors_Hidden]
-        adc	cx,[Sectors_Hidden+2]
-        mov	bx,[Sectors_Per_Fat]
-        mov di,Fat_Buffer
-        push bx
-        push cx
-readfat:
-	    call     ReadSector
-        jc       Boot_Error
-	    inc      cx
-	    add      di,[Sectors_Size]
-	    dec      bx
-	   jnz      readfat          
-        pop cx
-        pop bx
-        xor	ax,ax
-        mov	al,[Fats_Number]
-        mul	bx
-        add	cx,ax
-        mov [entries],cx
-        mov	ax,32
-        mul	word [Fits_Number]
-        div	word [Sectors_Size]
-        add	cx,ax
-        sub	cx,2
-        mov	word [data],cx    
-        popa
-        ret
-        
-;======================SEARCH========================
-;Recherche le groupe d'un fichier
-;-> si nom du fichier
-;<- Flag Carry si erreur CX
-;=====================================================
-search:
-        push bx
-        push dx 
-        push di
-        mov cx,[entries]
-        mov	di,Buffer
-        call ReadSector
-        jc Boot_Error
-        xor	bx,bx
-Next_Root_Entrie:
-        cmp	byte [di],0
-        je	Boot_Error
-        push    si
-        push	di
-        push	cx
-        mov	cx,32
-        rep	cmpsb
-        pop	cx
-        pop	di
-        pop si
-        je	Found
-        add	di,32
-        add	bx,32
-        inc	dx
-        cmp	dx,[Fits_Number]
-        ja	Boot_Error
-        cmp	bx,[Sectors_Size]
-        jb	Next_Root_Entrie
-        inc	cx
-Found:
-        mov	cx,[di+26+32]
-       pop di 
-       pop dx 
-       pop bx
-       ret
-    
-;======================SHOWRTN========================
-;Affiche la chaine de caractère return
-;-> 
-;<- Flag Carry si erreur
-;=====================================================
-showrtn:
-    push ds
-    push ax
-    push esi
-    mov esi,return
-    mov ax,cs
-    mov ds,ax
-    call showstr
-    pop esi
-    pop ax
-    pop ds
-    ret
-
-;======================SHOWSTR========================
-;Affiche la chaine de caractère pointé par ds:esi à l'écran
-;-> DS, SI
-;<- Flag Carry si erreur
-;=====================================================
-showstr:
-        pushad
-        xor  bh,bh
-nextchar:
-        mov al,[ds:esi]
-        inc esi
-        or	al,al
-        jz	endshow
-        cmp al,' '
-        jb justchar       
-        cmp al,'#'
-        jne nocolor
-        mov al,[ds:esi]
-        inc esi
-        sub al,'0'
-        shl al,3
-        mov [cs:thecolor],al
-        shr al,2
-        add [cs:thecolor],al
-        mov al,[ds:esi]
-        inc esi
-        sub al,'0'
-        add [cs:thecolor],al
-        jmp	nextchar
-nocolor:
-        cmp al,'@'
-        jne nocolor2
-        mov al,[ds:esi]
-        inc esi
-        sub al,'0'
-        shl al,3
-        mov cl,al
-        shr al,2
-        add cl,al
-        mov al,[ds:esi]
-        inc esi
-        sub cl,'0'
-        add cl,al
-        call eol
-        jmp	nextchar
-nocolor2:
-        xor  bx,bx  
-        mov	ah,0x09
-        mov	bl,[cs:thecolor]
-        xor  cx,cx
-        inc  cx
-        int	0x10
-justchar:
-        mov	ah,0x0E
-        int	0x10 
-        jmp	nextchar
-endshow:
-        popad
-	    ret
-	    
-
-;====================READSECTOR=======================
-;Lit le secteur logique LBA CX et le met en es:di
-;-> CX (limité à 65536 secteurs, soit 32 Mo avec secteur 512 octets)
-;<- Flag Carry si erreur
-;=====================================================
-ReadSector:
-	pusha
-	mov	ax,cx
-	xor	dx,dx
-	div	word [Sectors_Per_Track]
-	inc	dl
-	mov	bl,dl
-	xor	dx,dx
-	div	word [Heads_Number]
-	mov	dh, [Boot_Drive]
-	xchg	dl,dh
-	mov	cx,ax
-	xchg	cl,ch
-	shl	cl,6
-	or	cl, bl
-	mov	bx,di
-	mov	si, 4
-	mov	al, 1
-Read_Again:
-  	mov	ah, 2
-  	int	0x13
-  	jnc	Read_Done
-  	dec	si
-  	jnz	Read_Again
-Read_Done:
-  	popa
-	ret
-	
-;===================NEXTFATGROUP======================
-;Renvoie en CX le groupe qui succède dans la FAT le groupe CX
-;-> CX
-;<-
-;=====================================================
-NextFatGroup:
-	push	bx
-	push	dx
-	push	di
-	mov	ax,cx
-	mov	bx,ax
-	and	bx,0000000000000001b
-	shr	ax,1
-	mov	cx,3
-	mul	cx
-	mov	di,Fat_Buffer
-	add	di,ax
-	cmp	bx,0
-	jnz	Even_Group
-Odd_Group:
-	mov	dx,[di]
-	and	dx,0x0FFF
-	mov	cx,dx
-	jmp	Next_Group_Found
-Even_Group:
-	mov	dx,[di+1]
-	and	dx,0xFFF0
-	shr	dx,4
-	mov	cx,dx
-Next_Group_Found:
-	pop	di
-	pop	dx
-	pop	bx
-	ret
-
-;***********************EnableA20*******************************
-;-> 
-;<-
-;Ouvre l'autoroute A20	
-;***************************************************************
-EnableA20:
-		cli
-		call ClearKeybBuffer
-		call WaitKeybCommand
-		mov al,0xd1
-		out 0x64,al
-		call WaitKeybCommand
-		mov al,0xdf
-		out 0x60,al
-		call WaitKeybCommand
-		jmp A20Enabled
-WaitKeybCommand:
-		in al,0x64
-		test al,0x02
-		jnz WaitKeybCommand
-		ret
-ClearKeybBuffer:
-		in al,0x64
-		test al,0x01
-		jnz ReadKeyb
-		ret
-ReadKeyb:	
-		in al,0x60
-		jmp ClearKeybBuffer
-A20Enabled:
-		sti
-		ret		
-			
-
-GoPMode32:
-[BITS 32]
-        mov ax,ALL_DATA_SEL
-        mov es,ax
-		mov gs,ax
-		mov fs,ax
-		mov ss,ax
-		mov ds,ax
-		mov esp,0x3fffff
-		push KERNEL_SEL
-		push dword [cs:entriepoint]
-		retf
-		
-section .data
-
-thecolor db 0x07
-msg0 db '#12@20-=< Lancement du Chargeur ELF >=-',0x0A,0x0D,0x0A,0x0D,0
-msg1 db '#07Initialisation de la FAT',0
-msg2 db '#07Recherche du systeme',0
-msg3 db '#07Activation adressage 24 bits',0
-msg4 db '#07Chargement des descripteurs',0
-msg5 db '#07Passage en mode Flat real',0
-msg6 db '#07Chargement du systeme',0
-msg7 db '#07Mise en place format ELF',0
-msg8 db '#07Passage en mode protege',0
-
-
-info1 db 0x0A,0x0D,'Format ELF i386 reconnu, #08Sections :',0x0A,0x0D,0
-info2 db '  ',0
-info3 db '@12 | ',0
-info4 db ' - ',0
-info5 db ' -> ',0
-info6 db '@35#12NON ALLOUE #08',0
-info7 db 'Point entree en ',0
-info8 db '@48 2**',0
-info9 db '@15#12  VIDE  #08',0
-info10 db '@70MEM',0
-info11 db 0x0A,0x0D,'#12Arret debug en ',0
-
-return db 0x0A,0x0D,0
-
-okay db '    #15[  #10OK  #15]',0x0A,0x0D,0
-error db '     #15[#12Erreur#15]',0x0A,0x0D,0x0A,0x0D,'    <Appuyez une touche pour redemarrer>',0
-The_Dot db '.',0
-System_File		    db "As",0,"y",0,"s",0,"t",0,"e",0,0x0F,0,0xB8,"m",0,".",0,"s",0,"y",0,"s",0,0,0,0,0,0xFF,0xFF,0xFF,0xFF
-entries dw 0
-data dw 0
-xy dw 0
-
-GDTR:
-.Size:		dw GDT_END 
-.Address:	dd 0 
-
-gdt0 equ $			; null entry
-GDT:
-.Entry0:	dw 0		; limit 15:0
-		dw 0		; base 15:0
-		db 0		; base 23:16
-		db 0		; type
-		db 0		; limit 19:16, flags
-		db 0		; base 31:24
-
-
-SYS_CODE_SEL equ $-gdt0		; code segment descriptor
-
-.Entry1:	dw 0xFFFF
-		dw 0x0		; base
-		db 0x0         	; base
-		db 0x9A         ; present, ring 0, code, non-conforming, readable
-		db 0xCF   	; 32 bit
-		db 0
-
-
-SYS_DATA_SEL equ $-gdt0		; data segment descriptor
-
-.Entry2:	dw 0xFFFF
-		dw 0x0    	; base
-		db 0x0	  	; base
-		db 0x92         ; present, ring 0, data, expand-up, writable
-		db 0xCF		; 32 bit
-		db 0
-
-
-ALL_DATA_SEL equ $-gdt0	; 4meg data segment descriptor
-
-.Entry3:	dw 0xFFFF
-		dw 0x0          ; base
-		db 0x0          ; base
-		db 0x92         ; present, ring 0, data, expand-up, writable
-		db 0xCF		; 4k pages, 32 bit
-		db 0
-
-
-KERNEL_SEL equ $-gdt0	; 4g code segment descriptor
-
-.Entry4:	dw 0xffff
-		dw 0x0          ; base
-		db 0x0          ; base
-		db 0x9A         ; present, ring 0, code, non-conforming, readable
-		db 0xCF		; 4k pages, 32 bit
-		db 0
-
-GDT_END equ $-gdt0 -1
-
-bootsector equ $
-Sectors_Size		dw	0		;Nombre d'octets/secteur
-Sectors_Per_Cluster	db	0		;Nombre de secteurs/cluster
-Reserved_Sectors	dw	0		;Nombre de secteurs réservé
-Fats_Number		    db	0		;Nombre de copies de la FAT
-Fits_Number		    dw	0		;Taille du répertoire racine
-Sectors_Per_Disk	dw	0		;Nombre secteurs du volume si < 32 Mo
-Media_Descriptor	db	0		;Descripteur de média
-Sectors_Per_Fat		dw	0		;Nombre secteurs/FAT
-Sectors_Per_Track	dw	0		;Nombre secteurs/piste
-Heads_Number		dw	0		;Nombre de tete de lecture/écriture
-Sectors_Hidden		dd	0		;Nombre de secteurs cachés
-Sectors_Per_Disk2	dd	0		;Nombre secteurs du volume si > 32 Mo
-Boot_Drive		    db	0		;Lecteur de démarrage
-Reserved		    db	0		;NA (pour NT seulement)
-Extended_Boot_ID	db	0		;Signature Boot étendu 29h
-
-Buffer            equ $
-Fat_Buffer        equ $+512
-        	
-	SECTION .bss
-
-%include "elf.h"
-

boot/makefile

@@ -1,22 +0,0 @@
-CC=nasm -f bin -o 
-
-all:	makall
-
-makall: boot12.bin boot16.bin loader.sys
-
-boot12.bin: boot12.asm
-	$(CC) $@ $^	
-
-boot16.bin: boot16.asm
-	$(CC) $@ $^	
-
-loader.sys: loader.asm
-	$(CC) $@ $^	
-
-clean:
-	rm -f *.o
-	rm -f *.bin
-	rm -f *.sys
-	rm -f *.com
-	
-

debug/boot.txt

@@ -1,8 +1,10 @@
 target remote localhost:1234
-set disassembly-flavor intel
+set disassembly-flavor att
+add-symbol-file ./system/realmode/setup.sym 0x902f6
 set architecture i8086
-break *0x7c00
+break *0x90200
 cont
-clear *0x7c00
-layout asm
-layout regs
+clear *0x90200
+break main
+###cont
+clear main

debug/debug.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+session="debug"
+tmux start-server
+tmux new-session -d -s $session -n gdb
+
+tmux splitw -h -p 90
+tmux splitw -t 0 -v -p 50
+tmux splitw -t 2 -h -p 45
+tmux splitw -v -p 50
+tmux splitw -v -p 50
+
+tmux send-keys -t 5 "gdb --init-command=./debug/gdbinit -x $1" Enter
+tmux send-keys -t 3 "telnet 127.0.0.1 6666" Enter 
+tmux send-keys -t 5 "dashboard stack -output /dev/pts/4" Enter
+tmux send-keys -t 5 "dashboard threads -output /dev/null" Enter
+tmux send-keys -t 5 "dashboard assembly -output /dev/pts/3" Enter 
+tmux send-keys -t 5 "dashboard registers -output /dev/pts/2" Enter
+tmux send-keys -t 5 "dashboard expressions -output /dev/pts/6" Enter
+tmux send-keys -t 5 "dashboard memory -output /dev/pts/6" Enter
+tmux send-keys -t 5 "dashboard source -output /dev/pts/3" Enter
+tmux send-keys -t 5 "dashboard history -output /dev/pts/7" Enter
+tmux send-keys -t 5 "dashboard threads -output /dev/null" Enter
+tmux send-keys -t 5 "dashboard stack -output /dev/pts/4" Enter
+tmux new-window -t $session:1 -n scratch
+tmux select-window -t $session:0
+tmux attach-session -t $session

debug/loader.txt

@@ -1,7 +0,0 @@
-target remote localhost:1234
-set disassembly-flavor intel
-set architecture i8086
-break *0x800
-cont
-display/20i $pc+$cs*16
-clear *0x800

debug/system.txt

@@ -1,8 +1,11 @@
 target remote localhost:1234
-set disassembly-flavor intel
+set disassembly-flavor att
 set architecture i386
-break *0x50000
+symbol-file ./system/system.sym
+break start
+break *0x100000
+cont
+clear *0x100000
+si
+break *0x100000
 cont
-symbol-file ./system/system.sys
-clear *0x50000
-display/20i $pc

docker/dockerfile.alpine

@@ -0,0 +1,10 @@
+FROM alpine:3.12.0
+RUN echo "http://alpine.42.fr/v3.12/main" > /etc/apk/repositories
+RUN echo "http://alpine.42.fr/v3.12/community" >> /etc/apk/repositories
+RUN apk --no-cache update
+RUN apk --no-cache upgrade
+RUN apk --no-cache add font-noto git gcc make qemu qemu-system-i386 qemu-system-x86_64 sed gdb ovmf tar wget gzip indent binutils hexdump dos2unix xxd xz tmux git musl-dev gnome-terminal spice-gtk spice-gtk-tools python2 cramfs
+RUN mkdir -p /usr/share/qemu/
+RUN ln -s /usr/share/OVMF/OVMF.fd /usr/share/qemu/OVMF.fd
+RUN mkdir /data
+WORKDIR /data

docker/dockerfile.debian

@@ -0,0 +1,9 @@
+FROM debian:10
+
+RUN apt-get update -yq \
+&& apt-get install --no-install-recommends gcc make qemu fusefat fuseext2 gdb ovmf xz-utils psmisc tmux git libc6-dev bsdmainutils tar wget bsdmainutils indent binutils xxd dos2unix gnome-terminal spice-client-gtk python2.7 qemu-system-x86 -yq \
+&& apt-get clean -y
+RUN wget http://ftp.fr.debian.org/debian/pool/main/c/cramfs/cramfsprogs_1.1-6_amd64.deb -O /tmp/cramfsprogs_1.1-6_amd64.deb
+RUN dpkg -i /tmp/cramfsprogs_1.1-6_amd64.deb
+RUN mkdir /data
+WORKDIR /data

final/makefile

@@ -1,13 +1,57 @@
-all: cos2000.img
+REMOVE=rm -f
+INSTALL=sudo apt-get install
+COPY=cp
+DISKCOPY=dd
+COMPRESS=xz
+SYNC=sync
+CREATEDIR=mkdir
+CAT=cat
 
-cos2000.img:
-	(dd if=/dev/zero of=cos2000.img count=2880 bs=512)
-	(mkfs.msdos -F 12 -n "COS2000" cos2000.img)
-	(fusefat cos2000.img ./mnt -o rw+)
-	(cp ../boot/loader.sys ./mnt/)
-	(cp ../system/system.sys ./mnt/;sync)
-	(fusermount ./mnt -u)
-	(dd if=../boot/boot12.bin of=cos2000.img seek=0 count=1 conv=notrunc;sync)
+all: harddisk.img.final harddiskuefi.img.final
+
+harddiskuefi.img.before:
+	$(COMPRESS) -d -k harddiskuefi.img.xz
+	$(DISKCOPY) if=harddiskuefi.img of=harddiskuefi.img.part1 skip=13672 bs=512
+	$(DISKCOPY) if=harddiskuefi.img of=harddiskuefi.img.before count=13672 bs=512
+	$(SYNC)
+	$(CREATEDIR) ./mnt -p
+
+harddiskuefi.img.final: harddiskuefi.img.before
+	mount -t ext2 -o rw harddiskuefi.img.part1 ./mnt
+	$(COPY) ../system/system.sys ./mnt/boot/
+	$(SYNC)
+	umount ./mnt
+	cat harddiskuefi.img.before > harddiskuefi.img.final
+	cat harddiskuefi.img.part1 >> harddiskuefi.img.final
+	$(SYNC)
+
+harddisk.img.before:
+	$(COMPRESS) -d -k harddisk.img.xz
+	$(DISKCOPY) if=harddisk.img of=harddisk.img.part1 skip=63 bs=512
+	$(DISKCOPY) if=harddisk.img of=harddisk.img.before count=63 bs=512
+	$(SYNC)
+	$(CREATEDIR) ./mnt -p
+
+harddisk.img.final: harddisk.img.before
+	mount -t ext2 -o rw harddisk.img.part1 ./mnt
+	$(COPY) ../system/system.sys ./mnt/boot/
+	$(SYNC)
+	umount ./mnt
+	cat harddisk.img.before > harddisk.img.final
+	cat harddisk.img.part1 >> harddisk.img.final
+	$(SYNC)
+
+initram.img:
+	$(MAKE) ../programs
+
+littleclean:
+	$(REMOVE) *.final
+
+togit: clean
 
 clean:
-	rm -f *.img
+	$(REMOVE) *.before
+	$(REMOVE) *.part1
+	$(REMOVE) *.img
+	$(REMOVE) *.final
+

final/makeimage

@@ -0,0 +1,31 @@
+#!/bin/bash
+dd if=/dev/zero of=harddisk.img count=10 bs=1048576
+parted -s -a cylinder harddisk.img mklabel msdos
+parted -s -a cylinder harddisk.img mkpart primary ext2 63s 10M
+parted -s -a cylinder harddisk.img toggle 1 boot
+lo=`losetup -f`
+echo ${lo}
+losetup -P ${lo} harddisk.img
+mkfs.ext2 ${lo}p1
+mount ${lo}p1 /mnt
+grub-install --no-floppy --install-modules="biosdisk part_msdos ext2 configfile normal linux16 linux vbe png gfxmenu video video_colors video_cirrus video_fb" --boot-directory=/mnt/boot ${lo} --target=i386-pc
+echo -en "\
+insmod ext2
+insmod biosdisk
+insmod part_msdos
+insmod linux
+insmod vbe
+insmod gfxterm
+insmod png
+insmod font
+set timeout=4\n\
+set default=0\n\
+menuentry "cos2000" {\n\
+set root=(hd0,1)\n\
+linux16 /boot/system.sys root=hd0,2 vesa=0318\n\
+initrd16 /boot/initram.img\n\
+boot\n\
+}" > /mnt/boot/grub/grub.cfg
+umount /mnt
+losetup -d ${lo}
+#xz -c harddisk.img > harddisk.img.xz

final/makeimageuefi

@@ -0,0 +1,41 @@
+#!/bin/bash
+dd if=/dev/zero of=harddiskuefi.img count=10 bs=1048576
+parted -s harddiskuefi.img mklabel gpt
+parted -s -a cylinder harddiskuefi.img mkpart ESP fat16 63s 7M
+parted -s -a cylinder harddiskuefi.img mkpart linux ext2 7M 10M
+parted -s -a cylinder harddiskuefi.img toggle 1 boot
+lo=`losetup -f`
+echo ${lo}
+losetup -P ${lo} harddiskuefi.img
+mkfs.fat -F16 -s1 ${lo}p1
+mkfs.ext2 ${lo}p2
+mount ${lo}p1 /mnt
+mkdir /mnt/grub
+echo -en "(hd0) ${lo}\n(hd0,1) ${lo}p1\n(hd0,2) ${lo}p2" > /mnt/grub/device.map
+#LS MINICMD pour avoir vision paritions
+grub-install --no-floppy --boot-directory=/mnt/ --efi-directory=/mnt/ ${lo} --install-modules="part_gpt ext2 configfile normal linux16 video video_colors video_cirrus video_fb videotest all_video" --locales=fr --target=x86_64-efi --no-nvram
+mkdir /mnt/EFI/BOOT
+cp /mnt/EFI/ubuntu/grubx64.efi /mnt/EFI/BOOT/bootx64.efi
+#grub-mkimage -d /usr/lib/grub/x86_64-efi -o /mnt/EFI/BOOT/bootx64.efi -c /mnt/EFI/ubuntu/grub.cfg -p "(hd0,1)/grub/" -O x86_64-efi part_gpt ext2 configfile normal multiboot2 video video_color video_cirrus video_fb videotest all_video
+echo -en "\
+insmod ext2
+insmod biosdisk
+insmod part_msdos
+insmod linux
+insmod vbe
+insmod gfxterm
+insmod png
+insmod font
+set timeout=4\n\
+set default=0\n\
+menuentry "cos2000" {\n\
+set root=(hd0,gpt2)\n\
+linux16 /boot/system.sys root=hd0,gpt2\n
+boot\n\
+}" > /mnt/grub/grub.cfg
+umount /mnt
+mount ${lo}p2 /mnt
+mkdir /mnt/boot/
+umount /mnt
+losetup -d ${lo}
+xz -c harddiskuefi.img > harddiskuefi.img.xz

include/3d.h

@@ -0,0 +1,171 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "types.h"
+#include "matrix.h"
+#include "video.h"
+
+typedef struct triface
+{
+	u16     V1;
+	u16     V2;
+	u16     V3;
+} triface __attribute__ ((packed));
+
+typedef struct model3d
+{
+	u8      name[12];
+	matrix44 view;
+	vector4 *vertexlist;
+	u16     vertexnb;
+	triface *facelist;
+	u16     facenb;
+} model3d __attribute__ ((packed));
+
+typedef struct vertex3d
+{
+	union
+	{
+		struct
+		{
+			float   x;
+			float   y;
+			float   z;
+		};
+		float   v[3];
+	};
+} vertex3d __attribute__ ((packed));
+
+typedef enum type3D
+{
+	TYPE3D_POINTS,
+	TYPE3D_LINES,
+	TYPE3D_FACES,
+	TYPE3D_FLAT,
+	TYPE3D_TEXTURE,
+} type3D __attribute__ ((packed));
+
+
+void    proj(vector4 list[], vertex2d plane[], vector4 origin[],
+	     u16 number, float factor);
+void    cube(model3d * model, vector4 * origin, u16 size);
+int     load3ds(u8 * pointer, u32 size, model3d * model);
+void    show3dmodel(model3d * model, matrix44 * transformation,
+		    vector4 origin[], float factor, type3D type);
+
+/*******************************************************************************/
+/* Fichier 3DS */
+
+typedef enum dsState
+{
+	DS_READ_CHUNK_ID,
+	DS_READ_CHUNK_LENGTH,
+	DS_READ_OBJECT_NAME,
+	DS_SKIP_CHUNK,
+	DS_READ_POINT_COUNT,
+	DS_READ_POINTS,
+	DS_READ_FACE_COUNT,
+	DS_READ_FACES,
+	DS_READ_MATRIX,
+	DS_READ_DONE
+} dsState __attribute__ ((packed));
+
+
+#define MAIN3DS       0x4D4D
+
+//>------ Main Chunks
+
+#define EDIT3DS       0x3D3D	// this is the start of the editor config
+#define KEYF3DS       0xB000	// this is the start of the keyframer config
+
+//>------ sub defines of EDIT3DS
+
+#define EDIT_MATERIAL 0xAFFF
+#define EDIT_CONFIG1  0x0100
+#define EDIT_CONFIG2  0x3E3D
+#define EDIT_VIEW_P1  0x7012
+#define EDIT_VIEW_P2  0x7011
+#define EDIT_VIEW_P3  0x7020
+#define EDIT_VIEW1    0x7001
+#define EDIT_BACKGR   0x1200
+#define EDIT_AMBIENT  0x2100
+#define EDIT_OBJECT   0x4000
+
+#define EDIT_UNKNW01  0x1100
+#define EDIT_UNKNW02  0x1201
+#define EDIT_UNKNW03  0x1300
+#define EDIT_UNKNW04  0x1400
+#define EDIT_UNKNW05  0x1420
+#define EDIT_UNKNW06  0x1450
+#define EDIT_UNKNW07  0x1500
+#define EDIT_UNKNW08  0x2200
+#define EDIT_UNKNW09  0x2201
+#define EDIT_UNKNW10  0x2210
+#define EDIT_UNKNW11  0x2300
+#define EDIT_UNKNW12  0x2302	// new chunk type
+#define EDIT_UNKNW13  0x3000
+#define EDIT_UNKNW14  0xAFFF
+
+//>------ sub defines of EDIT_MATERIAL
+#define MAT_NAME01    0xA000	//> includes name (see mli doc for materials)
+
+//>------ sub defines of EDIT_OBJECT
+
+#define OBJ_TRIMESH   0x4100
+#define OBJ_LIGHT     0x4600
+#define OBJ_CAMERA    0x4700
+
+#define OBJ_UNKNWN01  0x4010
+#define OBJ_UNKNWN02  0x4012	//>>---- Could be shadow
+
+//>------ sub defines of OBJ_CAMERA
+#define CAM_UNKNWN01  0x4710	// new chunk type
+#define CAM_UNKNWN02  0x4720	// new chunk type
+
+//>------ sub defines of OBJ_LIGHT
+#define LIT_OFF       0x4620
+#define LIT_SPOT      0x4610
+#define LIT_UNKNWN01  0x465A
+
+//>------ sub defines of OBJ_TRIMESH
+#define TRI_VERTEXL   0x4110
+#define TRI_FACEL2    0x4111	// unknown yet
+#define TRI_FACEL1    0x4120
+#define TRI_SMOOTH    0x4150
+#define TRI_LOCAL     0x4160
+#define TRI_VISIBLE   0x4165
+
+//>>------ sub defs of KEYF3DS
+
+#define KEYF_UNKNWN01 0xB009
+#define KEYF_UNKNWN02 0xB00A
+#define KEYF_FRAMES   0xB008
+#define KEYF_OBJDES   0xB002
+
+#define KEYF_OBJHIERARCH  0xB010
+#define KEYF_OBJDUMMYNAME 0xB011
+#define KEYF_OBJUNKNWN01  0xB013
+#define KEYF_OBJUNKNWN02  0xB014
+#define KEYF_OBJUNKNWN03  0xB015
+#define KEYF_OBJPIVOT     0xB020
+#define KEYF_OBJUNKNWN04  0xB021
+#define KEYF_OBJUNKNWN05  0xB022
+
+//>>------  these define the different color chunk types
+#define COL_RGB  0x0010
+#define COL_TRU  0x0011
+#define COL_UNK  0x0013		// unknown
+
+//>>------ defines for viewport chunks
+
+#define TOP           0x0001
+#define BOTTOM        0x0002
+#define LEFT          0x0003
+#define RIGHT         0x0004
+#define FRONT         0x0005
+#define BACK          0x0006
+#define USER          0x0007
+#define CAMERA        0x0008	// 0xFFFF is the code read from file
+#define LIGHT         0x0009
+#define DISABLED      0x0010
+#define BOGUS         0x0011

include/Kmemory.h

@@ -1,26 +0,0 @@
-/***********************************/
-/* Librairie Kmemory.h             */
-/* 20 Mars 2007                    */
-/***********************************/
-
-
-#ifndef JREKCED_KERNEL_MEMORY
-# define JREKCED_KERNEL_MEMORY
-
-# include "type.h"
-
-# define MEMORY_BLOC_SIZE (1024L)       /* Taille des blocs */
-
-                                                // Initialise les gestionnaire de memoire.
-void Kernel_InitMemory (void *DataMemory,       // DataMemory pointe vers la zone de memoire disponible.
-                       UDWORD TotalMemorySize); // TotalMemorySize est la quantite total de memoire disponible.
-
-void * Kernel_mballoc(UDWORD Size);    // Alloue SIZE blocs de memoire et retourne un pointeur sur la zone.
-                                       // Retourne un pointeur nul si l'allocation est impossible.
-
-int    Kernel_mbfree (void *Adresse);  // Libere le bloc memoire alloue a l'adresse ADRESSE.
-                                       // Retourne -1 si adresse incorrecte et 0 si tout s'est bien deroule.
-
-void * Kernel_mbrealloc (void *Adresse, UDWORD Size); // Redimensionne un bloc, retourne NULL si le bloc
-                                                      // n'est pas redimensionne.
-#endif

include/LDT.h

@@ -1,85 +0,0 @@
-/***********************************/
-/* Librairie LDT.h                 */
-/* 23 Mars 2007                    */
-/***********************************/
-
-#ifndef JREKCED_LDT
-# define JREKCED_LDT
-
-# include "type.h"
-
-# define LDT_BLOC_SIZE  (128)        /* Nombre de descripteur LDT dans un bloc */
-
-// Types d'acces
-# define GLT_ACCESSED         (0x1)
-
-# define LDT_DATA             (0x0)
-# define LDT_DATA_WRITE       (0x2)
-# define LDT_DATA_EXPAND      (0x4)
-
-# define LDT_CODE             (0x8)
-# define LDT_CODE_READ        (0xA)
-# define LDT_CODE_CONFORMING  (0xD)
-
-// Granularite
-# define LDT_BYTE             (0x0)
-# define LDT_4KB              (0x1)
-
-// Mode du CPU
-# define LDT_16BIT            (0x0)
-# define LDT_32BIT            (0x1)
-
-
-typedef struct
-{
-    UWORD Limite_0_15;      // Bit 00-15 : Limite (0-15)
-    UWORD Adresse_0_15;     // Bit 16-31 : Adresse (0-15)
-    UBYTE Adresse_16_23;    // Bit 32-39 : Adresse (16-23)
-    UBYTE Acces : 1;        // 0 = System
-                            // 1 = Code ou data
-    UBYTE Type : 4;         // Bit 41-44 : Type
-    UBYTE DPL : 2;          // Spécifie le niveau de privilège du segment
-    UBYTE Present : 1;      // Indique si le segment est en mémoire (bit a 1) ou non (bit a 0)
-    UBYTE Limite_16_19 : 4; // Bit 48-51 : Limite (16-19)
-    UBYTE UserDefine : 1;   // Bit 52    : Utilisation libre
-    UBYTE Unused : 1;       // Bit 53    : Non utilise (toujours = 0)
-    UBYTE CPUMode : 1;      // Bit 54    : = 0 -> 16-Bit
-                            //             = 1 -> 32-Bit
-    UBYTE Granularite : 1;  // Si = 0 : Limite = 1 octet -> 1 Mo
-                            // Si = 1 : Limite = 4 Ko -> 4 Go
-    UBYTE Adresse_24_31;    // Bit 56-63 : Adresse (24-31)
-} T_LDT;
-
-
-typedef struct
-{
-   UWORD  Size;     // Taille de la GDT
-   void * Adresse;  // Adresse phisique de la GDT;
-   UWORD  Empty;
-
-} T_LDT_reg;
-
-
-// T_LDT *GDT_BASE = ((T_LDT*)0x0800L); /* Addresse physique ou reside la GDT, le 1e element est toujours null */
-
-
-T_LDT * LDT_balloc (UWORD Size);       // Alloue un bloc de Size LDT
-
-int     LDT_bfree  (void * Adresse);   // Libere un bloc LDT
-
-T_LDT * LDT_brealloc (T_LDT * OldLDT, UWORD NewSize); // Redimensionne un bloc LDT, retourne NULL en cas d'erreur.
-
-T_LDT * LDT_AllocLDT (T_LDT *BaseLDT); // Cherche un LDT libre dans un bloc precedement
-                                       // alloue avec LDT_balloc.
-                                       // Retourne NULL si aucun bloc disponible.
-                                       // Si un bloc libre est trouve, il est marque comme
-                                       // utilise et un pointeur sur ce LDT est retourne.
-
-int LDT_FreeLDT (T_LDT *LDT); // Marque le LDT comme non utilise et le met a NULL.
-
-int LDT_MapMemory (T_LDT *LDT, void * Linear,   // Met des donnees dans un LDT.
-                   UDWORD Size,                 // Cette fonction est a tester.
-                   UBYTE Granularite,
-                   UBYTE DPL, UBYTE Type, 
-                   UBYTE CPUMode);
-#endif

include/asm.h

@@ -1,74 +1,134 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
 
+#ifndef _ASM
+#   define _ASM
+
 /******************************************************************************/
 
-#define sti() asm("sti"::)
+#   define int20 asm("int $0x14")
 
-#define cli() asm("cli"::)
+#   define halt() asm("hlt"::)
 
-#define nop() asm("nop"::)
+#   define sti() asm("sti"::)
 
-#define pushad() asm("pushal"::)
+#   define cli() asm("cli"::)
 
-#define popad() asm("popal"::)
+#   define nop() asm("nop"::)
 
-#define pushf() asm("pushf"::)
+#   define pushad() asm("pushal"::)
 
-#define popf() asm("popf"::)
+#   define popad() asm("popal"::)
 
-#define iret() asm("iret"::)
+#   define pushf() asm("pushf"::)
 
-#define irqendmaster() asm("movb $0x20,%al; \
+#   define pop(mem) asm("popl %0":"=m" (mem))
+
+#   define push(mem) asm("pushl %0"::"m" (mem))
+
+#   define popf() asm("popf"::)
+
+#   define iret() asm("iret"::)
+
+#   define leave() asm("leave"::)
+
+#   define irqendmaster() asm("movb $0x20,%al; \
                        outb %al,$0x20;")
 
-#define irqendslave() asm("movb $0x20,%al; \
+#   define irqendslave() asm("movb $0x20,%al; \
                        outb %al,$0xA0;")
 
-#define lidt(dtr) asm ("lidtl %0"::"m" (*dtr))
+#   define lidt(idtr) asm ("lidtl %0"::"m" (idtr))
 
+#   define lgdt(gdtr) asm ("lgdtl %0"::"m" (gdtr))
+
+#   define lldt(ldtr) asm ("lldtl %0"::"m" (ldtr))
+
+#   define ltr(tss) asm volatile ("ltr %%ax":: "a" (tss))
+
+#   define sidt(idtr) asm ("sidtl %0"::"m" (idtr))
+
+#   define sgdt(gdtr) asm ("sgdtl %0"::"m" (gdtr))
+
+#   define sldt(ldtr) asm ("sldtl %0"::"m" (ldtr))
+
+#   define str(tss) asm volatile ("str %%ax;\
+                                mov %%ax,%0":: "m" (tss))
+
+#   define wrmsr(reg,low,high) asm volatile ("wrmsr" :: "c" (reg), "a" (low), "d" (high))
+
+#   define rdmsr(reg,low,high) asm volatile ("rdmsr" :: "=a" (low), "=d" (high) : "c" (reg) )
+
+#   define movsb(src,dst,count) \
+	asm volatile ("cld;rep movsb"::"S" (src), "D" (dst), "c" (count));
+
+#   define movsw(src,dst,count) \
+	asm volatile ("cld;rep movsw"::"S" (src), "D" (dst), "c" (count));
+
+#   define movsd(src,dst,count) \
+	asm volatile ("cld;rep movsl"::"S" (src), "D" (dst), "c" (count));
+
+#   define stosb(pattern,dst,count) \
+	asm volatile ("cld;rep stosb"::"c" (count), "D" (dst), "a" (pattern));
+
+#   define stosw(pattern,dst,count) \
+	asm volatile ("cld;rep stosw"::"c" (count), "D" (dst), "a" (pattern));
+
+#   define stosd(pattern,dst,count) \
+	asm volatile ("cld;rep stosl"::"c" (count), "D" (dst), "a" (pattern));
+
+#   define rol(addr) \
+	asm volatile ("rolb $0x1,%0":"=m" (addr):);
+
+#   define ror(addr) \
+	asm volatile ("rorb $0x1,%0":"=m" (addr):);
+
+#   define finit() \
+    asm volatile ("finit"::);
 /******************************************************************************/
 
-#define outb(port,value) \
+#   define outb(port,value) \
 	asm volatile ("outb %%al,%%dx"::"d" (port), "a" (value));
 
-#define outw(port,value) \
+#   define outw(port,value) \
 	asm volatile ("outw %%ax,%%dx"::"d" (port), "a" (value));
 
-#define outd(port,value) \
+#   define outd(port,value) \
 	asm volatile ("outl %%eax,%%dx"::"d" (port), "a" (value));
 
 /******************************************************************************/
 
-#define inb(port) ({	\
+#   define inb(port) ({	\
 	u8 _v;	\
 	asm volatile ("inb %%dx,%%al" : "=a" (_v) : "d" (port)); \
 	_v;	\
 })
 
-#define inw(port) ({	\
+#   define inw(port) ({	\
 	u16 _v;	\
  	asm volatile ("inw %%dx,%%ax" : "=a" (_v) : "d"(port));	\
 	_v;	\
-}
+})
 
 
-#define ind(port) ({	\
+#   define ind(port) ({	\
 	u32 _v;	\
  	asm volatile ("inl %%dx,%%eax" : "=a" (_v) : "d"(port));	\
 	_v;	\
-}
+})
 
 /******************************************************************************/
 
 /* pas terminé */
 
-#define rolb(input,rotate) ({	\
+#   define rolb(input,rotate) ({	\
 	u32 _v;	\
         asm volatile ("roll %1,%0" : "=g" (_v) : "cI" (rotate), "0" (input));  \
 	_v;	\
 }
 
+/******************************************************************************/
 
-
-
-
+#endif

include/boot.h

@@ -0,0 +1,85 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/uapi/asm/bootparam.h
+/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/asm/e820/type.h
+
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+#ifndef _BOOT
+#define _BOOT 
+
+#include "types.h"
+#include "gdt.h"
+
+#define E820_MAX_ENTRIES 128
+
+typedef struct entrye820 {
+	u64 addr;
+	u64 size;
+	u32 type;
+} entrye820 __attribute__((packed));
+
+typedef struct bootparams {
+	entrye820 e820_table[E820_MAX_ENTRIES];
+	u32	e820_numbers;
+	u8* cmdline;
+	u8 kbflag;
+	u32 ramdisksize;
+	u32 ramdiskaddr;
+} bootparams;
+
+
+enum e820_type {
+	E820_TYPE_RAM		= 1,
+	E820_TYPE_RESERVED	= 2,
+	E820_TYPE_ACPI		= 3,
+	E820_TYPE_NVS		= 4,
+	E820_TYPE_UNUSABLE	= 5,
+	E820_TYPE_PMEM		= 7,
+	E820_TYPE_PRAM		= 12,
+	E820_TYPE_RESERVED_KERN	= 128,
+};
+
+typedef struct header {
+	u8	setup_sects;
+	u16	root_flags;
+	u32	syssize;
+	u16	ram_size;
+	u16	vid_mode;
+	u16	root_dev;
+	u16	boot_flag;
+	u16	jump;
+	u32	header;
+	u16	version;
+	u32	realmode_swtch;
+	u16	start_sys_seg;
+	u16	kernel_version;
+	u8	type_of_loader;
+	u8	loadflags;
+	u16	setup_move_size;
+	u32	code32_start;
+	u32	ramdisk_image;
+	u32	ramdisk_size;
+	u32	bootsect_kludge;
+	u16	heap_end_ptr;
+	u8	ext_loader_ver;
+	u8	ext_loader_type;
+	u32	cmd_line_ptr;
+	u32	initrd_addr_max;
+	u32	kernel_alignment;
+	u8	relocatable_kernel;
+	u8	min_alignment;
+	u16	xloadflags;
+	u32	cmdline_size;
+	u32	hardware_subarch;
+	u64	hardware_subarch_data;
+	u32	payload_offset;
+	u32	payload_length;
+	u64	setup_data;
+	u64	pref_address;
+	u32	init_size;
+	u32	handover_offset;
+} __attribute__((packed)) header;
+
+#endif

include/cpu.h

@@ -1,31 +1,46 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "interrupts.h"
+
 typedef struct cpuinfo
 {
-u8 vendor[13];
-u8 names[32];
-u8 detectedname[48];
-u8 techs[48];
-u8 stepping;
-u8 models;
-u8 family;
-u8 types;
-u8 emodels;
-u8 efamily;
-u8 apicid;
-u8 count;
-u8 linesize;
-u8 brandid;
-bool mmx;
-bool mmx2;
-bool sse;
-bool sse2;
-bool sse3;
-bool fpu;
-bool now3d;
-bool now3d2;
-bool htt;
-bool apic;
-} cpuinfo  __attribute__ ((packed));	
-
-
-u8 getcpuinfos(cpuinfo *inf); 
+	u8      vendor[13];
+	u8      names[32];
+	u8      detectedname[256];
+	u8      techs[256];
+	u8      stepping;
+	u8      models;
+	u8      family;
+	u8      types;
+	u8      emodels;
+	u8      efamily;
+	u8      apicid;
+	u8      count;
+	u8      linesize;
+	u8      brandid;
+	bool    mmx;
+	bool    mmx2;
+	bool    sse;
+	bool    sse2;
+	bool    sse3;
+	bool    fpu;
+	bool    now3d;
+	bool    now3d2;
+	bool    htt;
+	bool    apic;
+	bool    bits64;
+	bool    syscall;
+	bool    msr;
+	bool    sse4a;
+	bool    vmx;
+	bool    sse41;
+	bool    sse42;
+	bool    apic2;
+} cpuinfo __attribute__ ((packed));
 
+bool    cansetflag(u32 flag);
+void    cpuid(u32 op, u32 * eax, u32 * ebx, u32 * ecx, u32 * edx);
+u8      getcpuinfos(cpuinfo * inf);
+void    show_cpu(regs * stack);
+void    cpuerror(const u8 * src, const regs * dump, bool returnto);

include/cpuid.h

@@ -1,6 +0,0 @@
-
-bool cansetflag (u32 flag);
-
-void cpuid(u32 op, u32 *eax, u32 *ebx,u32 *ecx, u32 *edx);
-
-void dump_regs();

include/cramfs.h

@@ -0,0 +1,83 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+/* Sources modifiées du noyau Linux cramfs_fs.h
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+#include "types.h"
+
+#ifndef _CRAMFS
+#define _CRAMFS
+
+#define CRAMFS_SIGNATURE	"Compressed ROMFS"
+
+#define CRAMFS_MODE_WIDTH 16
+#define CRAMFS_UID_WIDTH 16
+#define CRAMFS_SIZE_WIDTH 24
+#define CRAMFS_GID_WIDTH 8
+#define CRAMFS_NAMELEN_WIDTH 6
+#define CRAMFS_OFFSET_WIDTH 26
+#define CRAMFS_MAGIC                0x28cd3d45
+#define CRAMFS_MAXPATHLEN (((1 << CRAMFS_NAMELEN_WIDTH) - 1) << 2)
+#define PAD_SIZE 512
+#define PAGE_CACHE_SIZE (4096)
+typedef struct cramfs_inode {
+	u32 mode:CRAMFS_MODE_WIDTH;
+	u32 uid:CRAMFS_UID_WIDTH;
+	u32 size:CRAMFS_SIZE_WIDTH;
+	u32 gid:CRAMFS_GID_WIDTH;
+	u32 namelen:CRAMFS_NAMELEN_WIDTH;
+	u32 offset:CRAMFS_OFFSET_WIDTH;
+} cramfs_inode;
+
+typedef struct cramfs_info {
+	u32 crc;
+	u32 edition;
+	u32 blocks;
+	u32 files;
+} cramfs_info;
+
+typedef struct cramfs_super {
+	u32 magic;			/* 0x28cd3d45 - random number */
+	u32 size;			/* length in bytes */
+	u32 flags;			/* feature flags */
+	u32 future;			/* reserved for future use */
+	u8 signature[16];		/* "Compressed ROMFS" */
+	cramfs_info fsid;		/* unique filesystem info */
+	u8 name[16];		/* user-defined name */
+	cramfs_inode root;	/* root inode data */
+} cramfs_super;
+
+#define	S_ISDIR(m)	((m & 0170000) == 0040000)	/* directory */
+#define	S_ISCHR(m)	((m & 0170000) == 0020000)	/* char special */
+#define	S_ISBLK(m)	((m & 0170000) == 0060000)	/* block special */
+#define	S_ISREG(m)	((m & 0170000) == 0100000)	/* regular file */
+#define	S_ISFIFO(m)	((m & 0170000) == 0010000)	/* fifo */
+#define	S_ISLNK(m)	((m & 0170000) == 0120000)	/* symbolic link */
+#define	S_ISSOCK(m)	((m & 0170000) == 0140000)	/* socket */
+
+#define CRAMFS_FLAG_FSID_VERSION_2	0x00000001	/* fsid version #2 */
+#define CRAMFS_FLAG_SORTED_DIRS		0x00000002	/* sorted dirs */
+#define CRAMFS_FLAG_HOLES		0x00000100	/* support for holes */
+#define CRAMFS_FLAG_WRONG_SIGNATURE	0x00000200	/* reserved */
+#define CRAMFS_FLAG_SHIFTED_ROOT_OFFSET	0x00000400	/* shifted root fs */
+#define CRAMFS_FLAG_EXT_BLOCK_POINTERS	0x00000800	/* block pointer extensions */
+
+#define CRAMFS_SUPPORTED_FLAGS	( 0x000000ff \
+				| CRAMFS_FLAG_HOLES \
+				| CRAMFS_FLAG_WRONG_SIGNATURE \
+				| CRAMFS_FLAG_SHIFTED_ROOT_OFFSET \
+				| CRAMFS_FLAG_EXT_BLOCK_POINTERS )
+
+#define CRAMFS_BLK_FLAG_UNCOMPRESSED	(1 << 31)
+#define CRAMFS_BLK_FLAG_DIRECT_PTR	(1 << 30)
+
+#define CRAMFS_BLK_FLAGS	( CRAMFS_BLK_FLAG_UNCOMPRESSED \
+				| CRAMFS_BLK_FLAG_DIRECT_PTR )
+
+#define CRAMFS_BLK_DIRECT_PTR_SHIFT	2
+
+u32 test_super(u8 *src, u32 length);
+
+#endif

include/ctype.h

@@ -1,42 +0,0 @@
-#ifndef __TL_CTYPE_H
-#define	__TL_CTYPE_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-extern char g_ctype[];
-
-#define CT_UP	0x01	/* upper case */
-#define CT_LOW	0x02	/* lower case */
-#define CT_DIG	0x04	/* digit */
-#define CT_CTL	0x08	/* control */
-#define CT_PUN	0x10	/* punctuation */
-#define CT_WHT	0x20	/* white space (space/cr/lf/tab) */
-#define CT_HEX	0x40	/* hex digit */
-#define CT_SP	0x80	/* hard space (0x20) */
-
-/* without the cast to unsigned, DJGPP complains (using -Wall) */
-#define isalnum(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
-#define isalpha(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
-#define iscntrl(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_CTL))
-#define isdigit(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_DIG))
-#define isgraph(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
-#define islower(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_LOW))
-#define isprint(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
-#define ispunct(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_PUN))
-#define isspace(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_WHT))
-#define isupper(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_UP))
-#define isxdigit(c)	((g_ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
-#define isascii(c)	((unsigned)(c) <= 0x7F)
-#define toascii(c)	((unsigned)(c) & 0x7F)
-
-#define tolower(c)	(isupper(c) ? c + 'a' - 'A' : c)
-#define toupper(c)	(islower(c) ? c + 'A' - 'a' : c)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

include/debug.h

@@ -0,0 +1,51 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "types.h"
+
+#define opBufSz 32
+
+#define decodeSIB()                 \
+    base = r32[*b&0x07];            \
+    indx = r32[(*b&0x38)>>3];       \
+    scale = ((*b&0xc0)>>6)*2;       \
+    if(scale && !indx){             \
+        print("Invalid SIB byte.");  \
+        return;                   \
+    }
+
+#define setG()                              \
+    reg = (*b&0x38)>>3;                     \
+    if(!Gsz){                               \
+    } else if(Gsz == 1){                    \
+        G = r8[reg];                        \
+    } else if(Gsz == 2){                    \
+        G = r16[reg];                       \
+    } else if(Gsz == 3){                    \
+        G = r32[reg];                       \
+    } else if(Gsz == 4){                    \
+        if(reg < 8){                        \
+            G = rseg[reg];                  \
+        } else{                             \
+            print("Invalid Mod R/M byte.");  \
+            return;                       \
+        }                                   \
+    } else{                                 \
+        print("Invalid Mod R/M byte.");      \
+        return;                           \
+    }
+
+
+#define DBG_EXEC        0b00
+#define DBG_WRITE       0b01
+#define DBG_CLEAR       0b10
+#define DBG_READWRITE   0b11
+
+#define DBG_ONEBYTE     0b00
+#define DBG_TWOBYTE     0b01
+#define DBG_FOURBYTE    0b11
+
+
+void    setdebugreg(u8 number, u8 * address, u8 type);
+u8     *getdebugreg(u8 number);
+u32     disasm(u8 * a, u8 * string, bool show);

include/gdt.h

@@ -0,0 +1,99 @@
+#ifndef _GDT
+#define _GDT
+
+/* Ordre imposé par SYSENTER */
+#define	SEL_KERNEL_CODE  0x8	/* Selecteur code du kernel */
+#define	SEL_KERNEL_STACK 0x10	/* Selecteur pile du kernel */
+#define	SEL_USER_CODE    0x18	/* Selecteur code utilisateur */
+#define	SEL_USER_STACK   0x20	/* Selecteur pile utilisateur */
+#define	SEL_KERNEL_DATA  0x28	/* Selecteur data du kernel */
+#define	SEL_USER_DATA    0x30	/* Selecteur data utilisateur */
+#define	SEL_TSS 0x38		/* Selecteur TSR */
+
+#define GDT_SIZE		0x8	/* Nombre de descripteurs */
+
+/* Drapeau des descripteurs GDT  */
+#define GRANULARITY_4K  0b00001000	/* Granularité alignement 4096 octet */
+#define GRANULARITY_1B  0b00000000	/* Granularité alignement 1 octet */
+#define OPSIZE_32B      0b00000100	/* Taille opérandes 32 bits */
+#define OPSIZE_16B      0b00000000	/* Taille opérandes 16 bits */
+#define SYS_AVAILABLE   0b00000001	/* Disponible pour le système (à définir) */
+
+#define SEG_ACCESSED    0b00000001	/* Segment accédé (code ou data) */
+
+#define SEG_DATA        0b00000000	/* Segment de données */
+#define SEG_CODE        0b00001000	/* Segment de données */
+
+#define SEG_READ_WRITE  0b00000010	/* Segment lecture-ecriture (data) */
+#define SEG_EXPAND_DOWN 0b00000100	/* Segment avec expand-down (data) */
+
+#define SEG_READ        0b00000010	/* Segment lecture          (code) */
+#define SEG_CONFORMING  0b00000100	/* Segment conforming       (code) */
+
+#define SEG_PRESENT     0b10000000	/* Segment défini (obligatoire) */
+
+#define SEG_RING0       0b00000000	/* Segment anneau 0 */
+#define SEG_RING1       0b00100000	/* Segment anneau 1 */
+#define SEG_RING2       0b01000000	/* Segment anneau 2 */
+#define SEG_RING3       0b01100000	/* Segment anneau 3 */
+
+#define SEG_NORMAL      0b00010000	/* Segment normal pile/data/code (0 pour système) */
+
+#ifndef __ASSEMBLY__
+
+#include "types.h"
+
+typedef struct gdtdes
+{
+	u16     lim0_15;
+	u16     base0_15;
+	u8      base16_23;
+	u8      acces;
+	u8      lim16_19:4;
+	u8      flags:4;
+	u8      base24_31;
+} gdtdes __attribute__ ((packed));
+
+struct gdtr
+{
+	u16     limite;
+	u32     base;
+} __attribute__ ((packed));
+
+typedef struct tss
+{
+	u16     prevtask, reserved00;
+	u32     esp0;
+	u16     ss0, reserved0;
+	u32     esp1;
+	u16     ss1, reserved1;
+	u32     esp2;
+	u16     ss2, reserved2;
+	u32     cr3;
+	u32     eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;
+	u16     es, reserved3;
+	u16     cs, reserved4;
+	u16     ss, reserved5;
+	u16     ds, reserved6;
+	u16     fs, reserved7;
+	u16     gs, reserved8;
+	u16     ldt_selector, reserved9;
+	u16     trapflag, iomap;
+} __attribute__ ((packed));
+
+void    inittr(void);
+void    initgdt();
+void    makegdtdes(u32 base, u32 limite, u8 acces, u8 flags,
+		   gdtdes * desc);
+u32     getdesbase(u16 sel);
+u8      getdestype(u16 sel);
+u32     getdessize(u16 sel);
+u32     getdeslimit(u16 sel);
+bool    isdesvalid(u16 sel);
+u8      getdesbit3(u16 sel);
+u32     getdesdpl(u16 sel);
+u16     getdesalign(u16 sel);
+void    setTSS(u32 ss, u32 sp);
+
+#endif
+#endif

include/graph.h

@@ -1 +0,0 @@
-void line(u32 x1, u32 y1, u32 x2, u32 y2, u8 color);

include/handlers.h

@@ -0,0 +1,41 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "types.h"
+__attribute__ ((noreturn)) void exception_handler(regs *dump);
+__attribute__((interrupt)) void interruption(exception_stack_noerror *caller);
+void exception0();
+void exception1();
+void exception2();
+void exception3();
+void exception4();
+void exception5();
+void exception6();
+void exception7();
+void exception8();
+void exception9();
+void exception10();
+void exception11();
+void exception12();
+void exception13();
+void exception14();
+void exception15();
+void exception16();
+void exception17();
+void exception18();
+__attribute__((interrupt)) void irq0(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq1(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq2(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq3(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq4(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq5(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq6(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq7(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq8(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq9(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq10(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq11(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq12(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq13(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq14(exception_stack_noerror *caller);
+__attribute__((interrupt)) void irq15(exception_stack_noerror *caller);

include/idt.h

@@ -1,31 +0,0 @@
-#include "types.h"
-
-
-
-#define INTGATE 0x8E00  /* utilise pour gerer les interruptions */
-#define TRAPGATE 0x8F00 /* utilise pour faire des appels systemes */
-#define TASKGATE 0x8500 /* utilise pour commuter des taches */
-#define CALLGATE 0x8C00 /* utilise pour appeler du code */
-#define LDTDES 0x8200 /* utilise pour pointer une LDT */
-
-/* descripteur de segment */
-typedef struct idtdes {
-	u16 offset0_15;	
-	u16 select;
-	u16 type;
-	u16 offset16_31;	
-} idtdes  __attribute__ ((packed));
-
-
-
- void initidt(void);
- void setidt(u32 offset, u16 select, u16 type,u16 index);
- void makeidtdes(u32 offset, u16 select, u16 type, idtdes* desc);
- void initpic(void);
- void enableirq(u8 irq);
- void disableirq(u8 irq);
- void cpuerror(const u8 *src);
- 
-
- 
-

include/interrupts.h

@@ -0,0 +1,373 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "types.h"
+#include "asm.h"
+
+#ifndef _INTERRUPTS
+#   define _INTERRUPTS
+
+#   define PIC1_CMD    0x20	/*PIC 8259A Commandes n°1 */
+#   define PIC1_DATA   0x21	/*PIC 8259A Données n°1 */
+#   define PIC2_CMD    0xa0	/*PIC 8259A Commandes n°2 */
+#   define PIC2_DATA   0xa1	/*PIC 8259A Données n°1 */
+
+#   define ICW1_ICW4       0x01	/* ICW4 ou pas */
+#   define ICW1_SINGLE     0x02	/* mode seul ou cascadé */
+#   define ICW1_INTERVAL4  0x04	/* adresses appel d'interval 4 ou 8 */
+#   define ICW1_LEVEL      0x08	/* déclenchement sur niveau ou sur front */
+#   define ICW1_INIT       0x10	/* Initialization */
+
+#   define ICW4_8086       0x01	/* 8086/88 (MCS-80/85) mode */
+#   define ICW4_AUTO       0x02	/* Auto EOI ou normal */
+#   define ICW4_BUF_SLAVE  0x08	/* mode/slave avec tampon */
+#   define ICW4_BUF_MASTER 0x0C	/* mode/master avec tampon */
+#   define ICW4_SFNM       0x10	/* Complètement lié ou non */
+
+#   define INTGATE     0x0E00	/* utilise pour gerer les interruptions */
+#   define TRAPGATE    0x0F00	/* utilise pour faire des appels systemes */
+#   define TASKGATE    0x0500	/* utilise pour commuter des taches */
+#   define CALLGATE    0x0C00	/* utilise pour appeler du code */
+#   define LDTDES      0x0200	/* utilise pour pointer une LDT */
+
+#   define ENTRY_PRESENT     0b1000000000000000	/* Segment défini (obligatoire) */
+
+#   define ENTRY_STORAGE     0b0001000000000000	/* Segment défini (obligatoire) */
+
+#   define ENTRY_RING0       0b0000000000000000	/* Segment anneau 0 */
+#   define ENTRY_RING1       0b0010000000000000	/* Segment anneau 1 */
+#   define ENTRY_RING2       0b0100000000000000	/* Segment anneau 2 */
+#   define ENTRY_RING3       0b0110000000000000	/* Segment anneau 3 */
+
+/* 00-11-010-0 : Compteur 0 - LSB puis MSB - generateur taux - binaire */
+#   define TIMER0         0x40	/* port E/S pour le timer canal 0 */
+#   define TIMER_MODE     0x43	/* port E/S pour le mode controle du timer */
+#   define RATE_GENERATOR 0x34	/* générateur de fréquence */
+#   define SQUARE_WAVE    0x36	/* générateur d'onde carrée */
+#   define TIMER_FREQ     1193180
+				/* fréquence pour timer dans un PC ou AT */
+#   define HZ             100	/* Fréquence d'horloge (ajutste logiciellement sur IBM-PC) */
+
+#   define setESP(mem) ({ \
+        asm volatile ("movl %[frommem],%%esp;":[frommem] "=m" (mem):); \
+})
+
+#   define savecpu(dump,caller,oldesp) ({\
+	getEBP(oldesp);\
+	dumpcpu();\
+	getESP(dump);\
+	caller = (exception_stack *) (oldesp + 1);\
+	dump->ebp = *oldesp;\
+	dump->eip = caller->eip;\
+	dump->cs = caller->cs;\
+	if (caller->cs==SEL_KERNEL_CODE)\
+		dump->esp = (u32) oldesp + sizeof(exception_stack);\
+	else\
+	{\
+		dump->esp = (u32) ((exception_stack_user*) caller)->esp;\
+		dump->ss = (u32) ((exception_stack_user*) caller)->ss;\
+	}\
+})
+
+#   define savecpu_noerror(dump,caller,oldesp) ({\
+	getEBP(oldesp);\
+	dumpcpu();\
+	getESP(dump);\
+	caller = (exception_stack_noerror *) (oldesp + 1);\
+	dump->ebp = *oldesp;\
+	dump->eip = caller->eip;\
+	dump->cs = caller->cs;\
+	if (caller->cs==SEL_KERNEL_CODE)\
+		dump->esp = (u32) oldesp + sizeof(exception_stack_noerror);\
+	else\
+	{\
+		dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;\
+		dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;\
+	}\
+})
+
+#   define createdump(dump) ({ \
+        push(dump.ss);\
+        push(dump.esp);\
+        push(dump.eflags);\
+        push(dump.cs);\
+        push(dump.eip);\
+        push(dump.ds);\
+        push(dump.es);\
+        push(dump.fs);\
+        push(dump.gs);\
+        push(dump.eax);\
+        push(dump.ebx);\
+        push(dump.ecx);\
+        push(dump.edx);\
+        push(dump.esi);\
+        push(dump.edi);\
+        push(dump.ebp);\
+        push(dump.cr0);\
+        push(dump.cr2);\
+        push(dump.cr3);\
+        push(dump.cr4);\
+        push(dump.dr0);\
+        push(dump.dr1);\
+        push(dump.dr2);\
+        push(dump.dr3);\
+        push(dump.dr6);\
+        push(dump.dr7);\
+        u32 eferlow=(u32) dump.efer & 0xFFFF;\
+        u32 eferhigh=(u32) dump.efer >> 32;\
+        push(eferlow);\
+        push(eferhigh);\
+})
+
+#   define dumpcpu()  ({ \
+	asm("\
+        pushl %%ss\n \
+        pushl %%esp\n \
+        pushf \n \
+        pushl %%cs\n \
+        pushl $0x0\n \
+    	pushl %%ds\n \
+        pushl %%es\n \
+        pushl %%fs\n \
+        pushl %%gs\n \
+        pushl %%eax\n \
+        pushl %%ebx\n \
+        pushl %%ecx\n \
+        pushl %%edx\n \
+        pushl %%esi\n \
+        pushl %%edi\n \
+        pushl %%ebp\n \
+        mov %%cr0, %%eax \n \
+        pushl %%eax\n \
+        mov %%cr2, %%eax \n \
+        pushl %%eax\n \
+        mov %%cr3, %%eax \n \
+        pushl %%eax\n \
+        mov %%cr4, %%eax \n \
+        pushl %%eax \n \
+        mov %%dr0, %%eax \n \
+        pushl %%eax\n \
+        mov %%dr1, %%eax \n \
+        pushl %%eax\n \
+        mov %%dr2, %%eax \n \
+        pushl %%eax\n \
+        mov %%dr3, %%eax \n \
+        pushl %%eax\n \
+        mov %%dr6, %%eax \n \
+        pushl %%eax\n \
+        mov %%dr7, %%eax \n \
+        pushl %%eax\n \
+        mov $0xC0000080, %%ecx \n \
+        rdmsr \n \
+        pushl %%edx \n \
+        pushl %%eax":::);\
+})
+
+#   define restcpu_kernel() ({\
+	asm("\
+        popl %%eax \n \
+        popl %%edx \n \
+        mov $0xC0000080, %%ecx \n \
+	wrmsr\n \
+        popl %%eax\n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+	mov %%eax,%%cr3 \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%ebp\n \
+        popl %%edi\n \
+        popl %%esi\n \
+        popl %%edx\n \
+        popl %%ecx\n \
+        mov 36(%%esp),%%eax\n \
+        mov 32(%%esp),%%ebx\n \
+        mov %%ebx,-4(%%eax)\n \
+        mov 28(%%esp),%%ebx\n \
+        mov %%ebx,-8(%%eax)\n \
+        mov 24(%%esp),%%ebx\n \
+        mov %%ebx,-12(%%eax)\n \
+        popl %%ebx\n \
+        popl %%eax\n \
+        popl %%gs\n \
+        popl %%fs\n \
+        popl %%es\n \
+        popl %%ds\n \
+        add $12,%%esp\n \
+  	  popl %%esp\n \
+        sub $12,%%esp\n \
+        iret ":::);\
+})
+
+#   define restcpu_user() ({\
+	asm("\
+        popl %%eax \n \
+        popl %%edx \n \
+        mov $0xC0000080, %%ecx \n \
+	wrmsr\n \
+        popl %%eax\n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%eax \n \
+	mov %%eax,%%cr3 \n \
+        popl %%eax \n \
+        popl %%eax \n \
+        popl %%ebp\n \
+        popl %%edi\n \
+        popl %%esi\n \
+        popl %%edx\n \
+        popl %%ecx\n \
+        popl %%ebx\n \
+        popl %%eax\n \
+        popl %%gs\n \
+        popl %%fs\n \
+        popl %%es\n \
+  	popl %%ds":::);\
+})
+
+
+/*
+lors d'un iret en mode user:
+	pushl %%ss\n \
+        pushl %%esp\n \
+lors d'un iret en mode kernel:
+        pushf \n \
+        pushl $cs\n \
+        pushl $0x0\
+*/
+
+
+/* save pile */
+typedef struct regs
+{
+	union {
+		struct {
+			u64     efer;
+			u32     dr7;
+			u32     dr6;
+			u32     dr3;
+			u32     dr2;
+			u32     dr1;
+			u32     dr0;
+			u32     cr4;
+			u32     cr3;
+			u32     cr2;
+			u32     cr0;
+			u32     ebp;
+			u32     edi;
+			u32     esi;
+			u32     edx;
+			u32     ecx;
+			u32     ebx;
+			u32     eax;
+			u32     gs;
+			u32     fs;
+			u32     es;
+			u32     ds;
+			u32     eip;
+			u32     cs;
+			u32     eflags;
+			u32     esp;
+			u32     ss;
+		};
+		struct {
+			u32     efer_low, efer_high;
+			u32     dummy[13*sizeof(u32)];
+			u16     dx,hdx;
+			u16     cx,hcx;
+			u16     bx,hbx;
+			u16     ax,hax;
+			u16     gsl,dummy_gs;
+			u16     fsl,dummy_fs;
+			u16     esl,dummy_es;
+			u16     dsl,dummy_ds;
+			u16     ip,hip;
+			u16     csl,dummy_cs;
+			u16     flags,hflags;
+			u16     sp,hsp;
+			u16     ssl,dummy_ss;
+		};
+		struct {
+			u64    dummy2;
+			u32    dummy3[13*sizeof(u32)];
+			u8     dl,dh,dx2,hdx2;
+			u8     cl,ch,cx2,hcx2;
+			u8     bl,bh,bx2,hbx2;
+			u8     al,ah,ax2,hax2;
+		};
+	}
+} regs __attribute__ ((packed));
+
+/* exception pile depuis code kernel*/
+typedef struct exception_stack
+{
+	u32     error_code;
+	u32     eip;
+	u32     cs;
+	u32     eflags;
+} exception_stack __attribute__ ((packed));
+
+/* sans code erreur depuis code kernel*/
+typedef struct exception_stack_noerror
+{
+	u32     eip;
+	u32     cs;
+	u32     eflags;
+} exception_stack_noerror __attribute__ ((packed));
+
+/* exception pile depuis code user */
+typedef struct exception_stack_user
+{
+	u32     error_code;
+	u32     eip;
+	u32     cs;
+	u32     eflags;
+	u32     esp;
+	u32     ss;
+} exception_stack_user __attribute__ ((packed));
+
+/* sans code erreu depuis code user */
+typedef struct exception_stack_noerror_user
+{
+	u32     eip;
+	u32     cs;
+	u32     eflags;
+	u32     esp;
+	u32     ss;
+} exception_stack_noerror_user __attribute__ ((packed));
+
+/* descripteur de segment */
+typedef struct idtdes
+{
+	u16     offset0_15;
+	u16     select;
+	u16     type;
+	u16     offset16_31;
+} idtdes __attribute__ ((packed));
+
+
+struct idtr
+{
+	u16     limite;
+	u32     base;
+} __attribute__ ((packed));
+
+void    initretry(u32 address);
+void    initidt(void);
+u32     getinitretry(void);
+void    setidt(u32 offset, u16 select, u16 type, u16 index);
+void    makeidtdes(u32 offset, u16 select, u16 type, idtdes * desc);
+void    initpic(void);
+void    enableirq(u8 irq);
+void    disableirq(u8 irq);
+void    cpuerror(const u8 * src, const regs * stack, bool returnto);
+#endif

include/keyboard.h

@@ -1,3 +1,9 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "interrupts.h"
+
 #define	SCAN_CTRL		0x1D
 #define	SCAN_LEFTSHIFT		0x2A
 #define	SCAN_RIGHTSHIFT	0x36
@@ -28,6 +34,8 @@
 #define	STATUS_NUM	0x2000
 #define	STATUS_SCRL	0x4000
 
-void keyboard();
-void outkbd(u8 port, u8 data);
-u8 waitascii();
+__attribute__((interrupt)) void keyboard_handler(exception_stack_noerror *caller);
+void    reboot(void);
+void    outkbd(u8 port, u8 data);
+u8      waitascii(void);
+u8     *getstring(u8 * temp);

include/math.h

@@ -1,3 +1,31 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #define sgn(x) ((x<0)?-1:((x>0)?1:0));
-                                        
-u32 abs(int x);
+#define M_PI 3.14159265358979323846	//Pi
+#define M_2_PI 0.636619772367581343076	//2 fois la réciproque de Pi
+#define M_PI_2 1.57079632679489661923	//Pi divisé par two
+#define EPSILON 1E-40
+#define degtorad(deg) (deg * PI / 180.0)
+#define radtodeg(rad) (rad * 180.0 / PI)
+u32 crc32(u32 inCrc32, u8 *buf, u32 size);
+double  cos(double x);
+double  sin(double x);
+float   cosf(float x);
+float   sinf(float x);
+float   fabsf(float n);
+double  fabs(double n);
+float   sqrtf(float n);
+float   rsqrtf(float n);
+double  sqrt(double n);
+double  rsqrt(double n);
+u32     abs(int x);
+u32     random(u32 lower, u32 upper);
+u32     rand(void);
+void    randomize(void);
+u8      log2(u64 n);
+u8      log10(u64 n);
+unsigned long long __udivdi3(unsigned long long num,
+			     unsigned long long den);
+unsigned long long __umoddi3(unsigned long long n, unsigned long long d);
+u32     pow(u32 a, u8 n);

include/matrix.h

@@ -0,0 +1,81 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#ifndef MATRIX
+#   define MATRIX
+
+typedef struct vector4
+{
+	union
+	{
+		struct
+		{
+			float   x;
+			float   y;
+			float   z;
+			float   w;
+		};
+		float   v[4];
+	};
+} vector4 __attribute__ ((packed));
+
+typedef struct matrix44
+{
+	union
+	{
+		struct
+		{
+			vector4 V[4];
+		};
+		float   v[16];
+	};
+} matrix44 __attribute__ ((packed));
+
+void    vector4_show(vector4 src);
+void    vector4_create(float x, float y, float z, float w, vector4 * dst);
+void    vector4_copy(vector4 src, vector4 * dst);
+void    vector4_add(vector4 v1, vector4 v2, vector4 * dst);
+void    vector4_sub(vector4 v1, vector4 v2, vector4 * dst);
+void    vector4_scale(vector4 * dst, float factor);
+void    vector4_crossproduct(vector4 v1, vector4 v2, vector4 * dst);
+void    vector4_normalize(vector4 * dst);
+void    vector4_divide(vector4 * v1, vector4 v2, vector4 * dst);
+void    vector4_perpendicular(vector4 v1, vector4 v2, vector4 * dst);
+void    vector4_rotate_x(vector4 * dst, float angle);
+void    vector4_rotate_y(vector4 * dst, float angle);
+void    vector4_rotate_z(vector4 * dst, float angle);
+float   vector4_len(vector4 src);
+float   vector4_dotproduct(vector4 v1, vector4 v2);
+float   vector4_norm(vector4 src);
+float   vector4_distance(vector4 v1, vector4 v2);
+int     vector4_isequals(vector4 v1, vector4 v2);
+void    vector4_planenormal(vector4 v1, vector4 v2, vector4 v3,
+			    vector4 * dst);
+
+void    matrix44_homogen(matrix44 * matrix);
+void    matrix44_empty(matrix44 * matrix);
+void    matrix44_scaling(vector4 v, matrix44 * dst);
+void    matrix44_translation(vector4 v, matrix44 * dst);
+void    matrix44_scale(matrix44 * dst, float factor);
+void    matrix44_scale_translation(vector4 scale, vector4 translation,
+				   matrix44 * dst);
+void    matrix44_rotation_x(float angle, matrix44 * dst);
+void    matrix44_rotation_y(float angle, matrix44 * dst);
+void    matrix44_rotation_z(float angle, matrix44 * dst);
+void    matrix44_rotation(vector4 axis, float angle, matrix44 * dst);
+void    matrix44_multiply(matrix44 * m1, matrix44 * m2, matrix44 * dst);
+void    matrix44_transform(matrix44 * matrix, vector4 * dst);
+float   matrix44_determinant(matrix44 * matrix);
+float   todeterminant(float a1, float a2, float a3, float b1, float b2,
+		      float b3, float c1, float c2, float c3);
+void    matrix44_adjoint(matrix44 * matrix);
+void    matrix44_show(matrix44 * matrix);
+void    matrix44_invert(matrix44 * matrix);
+void    matrix44_transpose(matrix44 * matrix);
+void    matrix44_lookat(vector4 eye, vector4 dst, vector4 up,
+			matrix44 * matrix);
+int     matrix44_isequals(matrix44 * m1, matrix44 * m2);
+float  *toarray(matrix44 * m);
+
+#endif

include/memory.h

@@ -1,6 +1,144 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#ifndef _MEMORY
+#   define _MEMORY
+
+#   define TOPAGE(addr)	  (addr) >> 12
+#   define	TOPD(addr)	((addr) & 0xFFC00000) >> 22
+#   define	TOPT(addr)	((addr) & 0x003FF000) >> 12
+#   define	TOPG(addr)	(addr) & 0x00000FFF
+
+#   define	PAGESIZE 	4096
+				/* Taille d'une page */
+#   define	PAGENUMBER 	1024
+				/* Nombre de pages */
+#   define KERNELSIZE  PAGESIZE*PAGENUMBER*2	/* 2 pages de 4mo en identity mapping */
+
+#   define IDT_ADDR		0x00000000	/* adresse de la IDT */
+#   define GDT_ADDR		0x00000800	/* adresse de la GDT */
+#   define	KERNEL_PD_ADDR		0x00001000
+						/* adresse de la page directory */
+#   define	KERNEL_STACK_ADDR	0x0009FFFF
+						/* adresse de la pile du kernel */
+#   define	KERNEL_CODE_ADDR	0x00100000
+						/* adresse du code du noyau */
+#   define KERNEL_PAGES		0x00800000	/* adresse des pages */
+#   define KERNEL_HEAP		0x10000000	/* adresse du heap */
+#   define VESA_FBMEM		    0x38000000	/* adresse du framebuffer VESA */
+#   define	USER_CODE 		0x40000000
+						/* adresse du code utilisateur */
+#   define	USER_STACK 		0xE0000000
+						/* adresse de la pile utilisateur */
+
+/* limites de la mémoire 32 bits */
+#   define	MAXMEMSIZE	0x100000000
+#   define	MAXMEMPAGE	1024*1024
+#   define MAXHEAPSIZE	VESA_FBMEM-KERNEL_HEAP
+#   define MAXPAGESSIZE	KERNEL_HEAP-KERNEL_PAGES
+
+/* page directory */
+#   define PAGE_NOFLAG	0x0
+#   define PAGE_PRESENT	0b000000001	/* page directory / table */
+#   define PAGE_WRITE	    0b000000010	/* page lecture ecriture */
+#   define PAGE_ALL		0b000000100	/* accessible user & supervisor */
+#   define PAGE_WTROUGH	0b000001000	/* write-through cache */
+#   define PAGE_NOCACHE	0b000010000	/* cache desactivé */
+#   define PAGE_ACCESS 	0b000100000	/* page accedée */
+#   define PAGE_4MB		0b010000000	/* page de 4mb au lieu de 4k (NECESSITE PSE) */
+
+/* page table */
+#   define PAGE_CACHE      0b000010000	/* page en cache */
+#   define PAGE_DIRTY      0b001000000	/* page écrite */
+#   define PAGE_GLOBAL     0b100000000	/* évite que le TLB mette à jour l'adresse dans le cache si CR4 est remis à zéro (NECESSITE CR4) */
+
+/* Selecteur RPL */
+#   define RPL_RING0       0b00	/* Anneau 0 */
+#   define RPL_RING1       0b01	/* Anneau 1 */
+#   define RPL_RING2       0b01	/* Anneau 2 */
+#   define RPL_RING3       0b11	/* Anneau 3 */
+
+#   define MALLOC_MINIMUM		16
+
+#   define setCR3(addr) \
+    asm volatile ("mov %[memaddr], %%eax; mov %%eax, %%cr3"::[memaddr] "m" (addr) );
+
+#ifndef __ASSEMBLY__
+
 #include "types.h"
+#include "queue.h"
+#include "boot.h"
 
-void memset(void *dst, u8 val, u32 count,u32 size);
-void memcpy(void *src, void *dst, u32 count, u32 size);
-u32 memcmp(void *src, void *dst, u32 count, u32 size);
+/* Malloc, pour l'attribution de mémoire en heap */
+typedef struct tmalloc
+{
+	u32     size:31;
+	u32     used:1;
+} __attribute__ ((packed)) tmalloc;
 
+/* Page, pour la gestion de la mémoire virtuelle */
+typedef struct page
+{
+	u8     *vaddr;
+	u8     *paddr;
+	        TAILQ_ENTRY(page) tailq;
+} __attribute__ ((packed)) page;
+
+typedef TAILQ_HEAD(page_s, page) page_t;
+
+/* Page directory, pour la gestion de la mémoire virtuelle */
+     typedef struct pd
+     {
+	     page   *addr;
+	     page_t page_head;
+     } __attribute__ ((packed)) pd;
+
+/* vaddrrange, pour la gestion des pages de la mémoire virtuelle */
+     typedef struct vrange
+     {
+	     u8     *vaddrlow;
+	     u8     *vaddrhigh;
+	     TAILQ_ENTRY(vrange) tailq;
+     } __attribute__ ((packed)) vrange;
+
+     typedef TAILQ_HEAD(vrange_s, vrange) vrange_t;
+
+     void virtual_pd_show(pd *dst);
+     void panic(u8 * string);
+     void memset(void *dst, u8 val, u32 count, u32 size);
+     void memcpy(void *src, void *dst, u32 count, u32 size);
+     u32 memcmp(void *src, void *dst, u32 count, u32 size);
+     u64 getmemoryfree(void);
+     u64 physical_getmemorysize();
+     void physical_page_use(u32 page);
+     void physical_page_free(u32 page);
+     void physical_range_use(u64 addr, u64 len);
+     void physical_range_free(u64 addr, u64 len);
+     u8     *physical_page_getfree(void);
+     void physical_init();
+     void initpaging();
+     void virtual_init(void);
+     tmalloc *mallocpage(u64 size);
+     void   *vmalloc(u32 size);
+     void vfree(void *vaddr);
+     page   *virtual_page_getfree(void);
+     pd     *virtual_pd_create();
+     void virtual_pd_destroy(pd * dst);
+     void virtual_page_free(u8 * vaddr);
+     u8     *virtual_to_physical(u8 * vaddr);
+     void virtual_pd_page_remove(u8 * vaddr);
+     void virtual_pd_page_add(pd * dst, u8 * vaddr, u8 * paddr, u32 flags);
+     void virtual_range_use(pd * dst, u8 * vaddr, u8 * paddr, u64 len,
+			    u32 flags);
+     void virtual_range_free(pd * dst, u8 * vaddr, u64 len);
+     void virtual_range_new(pd * dst, u8 * vaddr, u64 len, u32 flags);
+     void malloc_init(void);
+     void identity_init(void);
+     void registry_init(void);
+     u32 getmallocused(void);
+     u32 getmallocfree(void);
+     u32 getmallocnonallocated(void);
+     u32 virtual_getpagesfree();
+
+#endif
+#endif

include/mouse.h

@@ -1,4 +1,10 @@
-bool initmouse();
-void mouse();
-void outmseack(u8 value);
-void outmsecmd(u8 command);
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "interrupts.h"
+
+bool    initmouse(void);
+__attribute__((interrupt)) void mouse_handler(exception_stack_noerror *caller);
+void    outmseack(u8 value);
+void    outmsecmd(u8 command);

include/pci.h

@@ -0,0 +1,50 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+
+
+typedef struct pciclass
+{
+	u16     number;
+	u8     *name;
+} pciclass __attribute__ ((packed));
+
+typedef struct pcidev
+{
+	u16     vendor_id;
+	u16     device_id;
+	u16     command;
+	u16     status;
+	u8      revision_id;
+	u8      interface;
+	u8      sub_class;
+	u8      base_class;
+	u8      cache_line_size;
+	u8      latency_timer;
+	u8      header_type;
+	u8      bist;
+} pcidev __attribute__ ((packed));
+
+
+typedef struct pcidevmini
+{
+	union
+	{
+		struct
+		{
+			u16     vendor_id;
+			u16     device_id;
+		};
+		u32     dword;
+	};
+} pcidevmini __attribute__ ((packed));
+
+u16     pciConfigReadWord(const u8 bus, const u8 dev, const u8 function,
+			  const u8 offset);
+void    scanPCImini(void);
+pcidevmini getPCImininfo(const u8 bus, const u8 dev, const u8 function);
+bool    getPCInfo(pcidev * device, const u8 bus, const u8 dev,
+		  const u8 function);
+void    scanPCI(void);
+u8     *pcigetclassname(const pcidev * device);

include/port.h

@@ -1,6 +0,0 @@
-#include "types.h"
-
-void outreg(u16 port,u8 *src,u16 num);
-void outregsame(u16 port,u8 *src,u16 num);
-void inreg(u16 port,u8 *src,u16 num);
-void inregsame(u16 port,u8 *src,u16 num);

include/process.h

@@ -0,0 +1,226 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "types.h"
+#include "interrupts.h"
+#include "memory.h"
+
+#define MAXPIDVALUE	    0xFFFF
+#define MAXNUMPROCESS	256
+
+#define PROCESS_STATUS_FREE   0x0
+#define PROCESS_STATUS_READY  0x1
+#define PROCESS_STATUS_RUN    0x2
+#define PROCESS_STATUS_SLEEP  0x3
+#define PROCESS_STATUS_ALL    0xFF
+
+#define TASK_STATUS_READY	0x0
+#define TASK_STATUS_RUN		0x1
+#define TASK_STATUS_STOP	0x2
+#define TASK_STATUS_ALL		0xFF
+
+/* ELF type */
+#define ET_NONE 	0	//No file type
+#define ET_REL 	    1		//Relocatable file
+#define ET_EXEC 	2	//Executable file
+#define ET_DYN 	    3		//Shared object file
+#define ET_CORE 	4	//Core file
+#define ET_LOOS 	0xfe00	//Operating system-specific
+#define ET_HIOS 	0xfeff	//Operating system-specific
+#define ET_LOPROC 	0xff00	//Processor-specific
+#define ET_HIPROC 	0xffff	//Processor-specific
+
+/* ELF identification */
+#define	EI_MAG0		    0	//File identification
+#define	EI_MAG1		    1	//File identification
+#define	EI_MAG2		    2	//File identification
+#define	EI_MAG3		    3	//File identification
+#define	EI_CLASS	    4	//File class
+#define	EI_DATA		    5	//Data encoding
+#define	EI_VERSION	    6	//File version
+#define	EI_OSABI 	    7	//Operating system/ABI identification
+#define	EI_ABIVERSION 	8	//ABI version
+#define	EI_PAD 	        9	//Start of padding bytes
+#define	EI_NIDENT 	    16	//Size of e_ident[]
+
+/* ELF version */
+#define EV_NONE 	0	//Invalid version
+#define EV_CURRENT 	1	//Current version
+
+/* ELF machine type */
+
+#define EM_NONE     0		//No machine
+#define EM_386 	    3		//Intel 80386
+#define EM_IA_64 	50	//Intel IA-64 processor architecture
+#define EM_X86_64 	62	//AMD x86-64 architecture
+
+/* EI signature */
+#define	ELFMAG0		0x7f
+#define	ELFMAG1		'E'
+#define	ELFMAG2		'L'
+#define	ELFMAG3		'F'
+
+/* EI file class  */
+#define	ELFCLASSNONE	0	/* invalid class */
+#define	ELFCLASS32	    1	/* 32-bit objects */
+#define	ELFCLASS64	    2	/* 64-bit objects */
+
+/* EI data structure */
+#define	ELFDATANONE	0	/* invalide data encoding */
+#define	ELFDATA2LSB	1	/* least significant byte first (0x01020304 is 0x04 0x03 0x02 0x01) */
+#define	ELFDATA2MSB	2	/* most significant byte first (0x01020304 is 0x01 0x02 0x03 0x04) */
+
+/* p type */
+#define	PT_NULL             0
+#define	PT_LOAD             1
+#define	PT_DYNAMIC          2
+#define	PT_INTERP           3
+#define	PT_NOTE             4
+#define	PT_SHLIB            5
+#define	PT_PHDR             6
+#define	PT_LOPROC  0x70000000
+#define	PT_HIPROC  0x7fffffff
+
+/* p flags */
+#define PF_X	0x1
+#define PF_W	0x2
+#define PF_R	0x4
+
+/* OS identification */
+#define ELFOSABI_NONE 	0	//No extensions or unspecified
+#define ELFOSABI_LINUX 	3	//Linux
+#define ELFOSABI_COS2000 16	//COS2000
+
+/* ELF header */
+typedef struct elf32
+{
+	u8      e_ident[EI_NIDENT];
+	u16     e_type;
+	u16     e_machine;
+	u32     e_version;
+	u8     *e_entry;
+	u32     e_phoff;
+	u32     e_shoff;
+	u32     e_flags;
+	u16     e_ehsize;
+	u16     e_phentsize;
+	u16     e_phnum;
+	u16     e_shentsize;
+	u16     e_shnum;
+	u16     e_shstrndx;
+} elf32  __attribute__ ((packed));
+
+typedef struct elf32p
+{
+	u32     p_type;
+	u32     p_offset;
+	u8     *p_vaddr;
+	u8     *p_paddr;
+	u32     p_filesz;
+	u32     p_memsz;
+	u32     p_flags;
+	u32     p_align;
+} elf32p  __attribute__ ((packed));
+
+typedef unsigned int pid_t;
+
+typedef struct tid_t
+{
+	pid_t pid;
+	u32 number;
+} tid_t __attribute__ ((packed));
+
+typedef struct stack
+{
+	u32     esp0;
+	u16     ss0;
+} stack __attribute__ ((packed));
+
+typedef struct task
+{
+	tid_t tid;
+	stack kernel_stack;
+	stack syscall_stack;
+	u32	status;
+	regs    dump;
+      TAILQ_ENTRY(task) tailq;
+} task __attribute__ ((packed));
+
+typedef TAILQ_HEAD(task_s, task) task_t;
+
+typedef struct child
+{
+	pid_t	pid;
+      TAILQ_ENTRY(child) tailq;
+} child __attribute__ ((packed));
+
+typedef TAILQ_HEAD(child_s, child) child_t;
+
+typedef struct other
+{
+	pid_t	pid;
+      TAILQ_ENTRY(other) tailq;
+} other __attribute__ ((packed));
+
+typedef TAILQ_HEAD(other_s, other) other_t;
+
+typedef struct process
+{
+	pid_t   pid;
+	pid_t   parent;
+	bool    iskernel;
+	pd     *pdd;
+	s8	  priority;
+	u32     result;
+	u8      status;
+	u8     *exec_low;
+	u8     *exec_high;
+	u8     *bss_low;
+	u8     *bss_high;
+	page_t  page_head;
+	task_t  task_head;
+      child_t child_head;
+	other_t other_head;
+	u32     entry;
+} process __attribute__ ((packed));
+
+pid_t     getcurrentpid(void);
+pid_t     getparentpid(void);
+pid_t     getfreepid(void);
+tid_t	getcurrenttid(void);
+tid_t	maketid(pid_t pid, u32 number);
+
+void      stop(void);
+void      wait(void);
+pid_t     fork(void);
+pid_t     clone(void);
+pid_t     exec(u8* entry, u8* args, bool kerneltask);
+
+void      switchtask(tid_t tid);
+process* getnextprocess(process *aprocess, u32 status);
+task* getnexttask(task* atask, u32 status);
+task*     getschedule(void);
+task* findtask(tid_t tid);
+task* findcurrenttask(void);
+process* findprocess(pid_t pid);
+process* findcurrentprocess(void);
+task* findfirsttask(process* aprocess);
+
+tid_t createtask(pid_t pid,u8 *entry, bool kerneltask);
+void      deletetask(tid_t tid);
+void      runtask(tid_t tid);
+void      stoptask(tid_t tid);
+
+pid_t createprocess(u8 *src, bool kerneltask);
+void      deleteprocess(pid_t pid);
+void      runprocess(pid_t pid);
+void      stopprocess(pid_t pid);
+
+
+void      setpriority(pid_t pid,s8 priority);
+
+void      initprocesses(void);
+
+u32     iself(u8 * src);
+u32     loadelf(u8 * src, pid_t pid);

include/queue.h

@@ -0,0 +1,698 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_QUEUE_H_
+#   define	_SYS_QUEUE_H_
+
+//#include <sys/cdefs.h>
+
+/*
+ * This file defines four types of data structures: singly-linked lists,
+ * singly-linked tail queues, lists and tail queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
+ * head of the list and the other to the tail of the list. The elements are
+ * singly linked for minimum space and pointer manipulation overhead at the
+ * expense of O(n) removal for arbitrary elements. New elements can be added
+ * to the list after an existing element, at the head of the list, or at the
+ * end of the list. Elements being removed from the head of the tail queue
+ * should use the explicit macro for this purpose for optimum efficiency.
+ * A singly-linked tail queue may only be traversed in the forward direction.
+ * Singly-linked tail queues are ideal for applications with large datasets
+ * and few or no removals or for implementing a FIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may be traversed in either direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ *
+ *
+ *				SLIST	LIST	STAILQ	TAILQ
+ * _HEAD			+	+	+	+
+ * _HEAD_INITIALIZER		+	+	+	+
+ * _ENTRY			+	+	+	+
+ * _INIT			+	+	+	+
+ * _EMPTY			+	+	+	+
+ * _FIRST			+	+	+	+
+ * _NEXT			+	+	+	+
+ * _PREV			-	+	-	+
+ * _LAST			-	-	+	+
+ * _FOREACH			+	+	+	+
+ * _FOREACH_FROM		+	+	+	+
+ * _FOREACH_SAFE		+	+	+	+
+ * _FOREACH_FROM_SAFE		+	+	+	+
+ * _FOREACH_REVERSE		-	-	-	+
+ * _FOREACH_REVERSE_FROM	-	-	-	+
+ * _FOREACH_REVERSE_SAFE	-	-	-	+
+ * _FOREACH_REVERSE_FROM_SAFE	-	-	-	+
+ * _INSERT_HEAD			+	+	+	+
+ * _INSERT_BEFORE		-	+	-	+
+ * _INSERT_AFTER		+	+	+	+
+ * _INSERT_TAIL			-	-	+	+
+ * _CONCAT			-	-	+	+
+ * _REMOVE_AFTER		+	-	+	-
+ * _REMOVE_HEAD			+	-	+	-
+ * _REMOVE			+	+	+	+
+ * _SWAP			+	+	+	+
+ *
+ */
+#   ifdef QUEUE_MACRO_DEBUG
+/* Store the last 2 places the queue element or head was altered */
+struct qm_trace
+{
+	unsigned long lastline;
+	unsigned long prevline;
+	const char *lastfile;
+	const char *prevfile;
+};
+
+#      define	TRACEBUF	struct qm_trace trace;
+#      define	TRACEBUF_INITIALIZER	{ __FILE__, __LINE__, NULL, 0 } ,
+#      define	TRASHIT(x)	do {(x) = (void *)-1;} while (0)
+#      define	QMD_SAVELINK(name, link)	void **name = (void *)&(link)
+
+#      define	QMD_TRACE_HEAD(head) do {					\
+	(head)->trace.prevline = (head)->trace.lastline;		\
+	(head)->trace.prevfile = (head)->trace.lastfile;		\
+	(head)->trace.lastline = __LINE__;				\
+	(head)->trace.lastfile = __FILE__;				\
+} while (0)
+
+#      define	QMD_TRACE_ELEM(elem) do {					\
+	(elem)->trace.prevline = (elem)->trace.lastline;		\
+	(elem)->trace.prevfile = (elem)->trace.lastfile;		\
+	(elem)->trace.lastline = __LINE__;				\
+	(elem)->trace.lastfile = __FILE__;				\
+} while (0)
+
+#   else
+#      define	QMD_TRACE_ELEM(elem)
+#      define	QMD_TRACE_HEAD(head)
+#      define	QMD_SAVELINK(name, link)
+#      define	TRACEBUF
+#      define	TRACEBUF_INITIALIZER
+#      define	TRASHIT(x)
+#   endif
+       /* QUEUE_MACRO_DEBUG */
+
+/*
+ * Singly-linked List declarations.
+ */
+#   define	SLIST_HEAD(name, type)						\
+struct name {								\
+	struct type *slh_first;	/* first element */			\
+}
+
+#   define	SLIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#   define	SLIST_ENTRY(type)						\
+struct {								\
+	struct type *sle_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#   define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
+
+#   define	SLIST_FIRST(head)	((head)->slh_first)
+
+#   define	SLIST_FOREACH(var, head, field)					\
+	for ((var) = SLIST_FIRST((head));				\
+	    (var);							\
+	    (var) = SLIST_NEXT((var), field))
+
+#   define	SLIST_FOREACH_FROM(var, head, field)				\
+	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
+	    (var);							\
+	    (var) = SLIST_NEXT((var), field))
+
+#   define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SLIST_FIRST((head));				\
+	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
+	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
+	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
+	for ((varp) = &SLIST_FIRST((head));				\
+	    ((var) = *(varp)) != NULL;					\
+	    (varp) = &SLIST_NEXT((var), field))
+
+#   define	SLIST_INIT(head) do {						\
+	SLIST_FIRST((head)) = NULL;					\
+} while (0)
+
+#   define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
+	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);	\
+	SLIST_NEXT((slistelm), field) = (elm);				\
+} while (0)
+
+#   define	SLIST_INSERT_HEAD(head, elm, field) do {			\
+	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
+	SLIST_FIRST((head)) = (elm);					\
+} while (0)
+
+#   define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
+
+#   define	SLIST_REMOVE(head, elm, type, field) do {			\
+	QMD_SAVELINK(oldnext, (elm)->field.sle_next);			\
+	if (SLIST_FIRST((head)) == (elm)) {				\
+		SLIST_REMOVE_HEAD((head), field);			\
+	}								\
+	else {								\
+		struct type *curelm = SLIST_FIRST((head));		\
+		while (SLIST_NEXT(curelm, field) != (elm))		\
+			curelm = SLIST_NEXT(curelm, field);		\
+		SLIST_REMOVE_AFTER(curelm, field);			\
+	}								\
+	TRASHIT(*oldnext);						\
+} while (0)
+
+#   define SLIST_REMOVE_AFTER(elm, field) do {				\
+	SLIST_NEXT(elm, field) =					\
+	    SLIST_NEXT(SLIST_NEXT(elm, field), field);			\
+} while (0)
+
+#   define	SLIST_REMOVE_HEAD(head, field) do {				\
+	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
+} while (0)
+
+#   define SLIST_SWAP(head1, head2, type) do {				\
+	struct type *swap_first = SLIST_FIRST(head1);			\
+	SLIST_FIRST(head1) = SLIST_FIRST(head2);			\
+	SLIST_FIRST(head2) = swap_first;				\
+} while (0)
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#   define	STAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *stqh_first;/* first element */			\
+	struct type **stqh_last;/* addr of last next element */		\
+}
+
+#   define	STAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).stqh_first }
+
+#   define	STAILQ_ENTRY(type)						\
+struct {								\
+	struct type *stqe_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#   define	STAILQ_CONCAT(head1, head2) do {				\
+	if (!STAILQ_EMPTY((head2))) {					\
+		*(head1)->stqh_last = (head2)->stqh_first;		\
+		(head1)->stqh_last = (head2)->stqh_last;		\
+		STAILQ_INIT((head2));					\
+	}								\
+} while (0)
+
+#   define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
+
+#   define	STAILQ_FIRST(head)	((head)->stqh_first)
+
+#   define	STAILQ_FOREACH(var, head, field)				\
+	for((var) = STAILQ_FIRST((head));				\
+	   (var);							\
+	   (var) = STAILQ_NEXT((var), field))
+
+#   define	STAILQ_FOREACH_FROM(var, head, field)				\
+	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
+	   (var);							\
+	   (var) = STAILQ_NEXT((var), field))
+
+#   define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = STAILQ_FIRST((head));				\
+	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)		\
+	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
+	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	STAILQ_INIT(head) do {						\
+	STAILQ_FIRST((head)) = NULL;					\
+	(head)->stqh_last = &STAILQ_FIRST((head));			\
+} while (0)
+
+#   define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_NEXT((tqelm), field) = (elm);				\
+} while (0)
+
+#   define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_FIRST((head)) = (elm);					\
+} while (0)
+
+#   define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
+	STAILQ_NEXT((elm), field) = NULL;				\
+	*(head)->stqh_last = (elm);					\
+	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
+} while (0)
+
+#   define	STAILQ_LAST(head, type, field)					\
+	(STAILQ_EMPTY((head)) ? NULL :					\
+	    __containerof((head)->stqh_last, struct type, field.stqe_next))
+
+#   define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
+
+#   define	STAILQ_REMOVE(head, elm, type, field) do {			\
+	QMD_SAVELINK(oldnext, (elm)->field.stqe_next);			\
+	if (STAILQ_FIRST((head)) == (elm)) {				\
+		STAILQ_REMOVE_HEAD((head), field);			\
+	}								\
+	else {								\
+		struct type *curelm = STAILQ_FIRST((head));		\
+		while (STAILQ_NEXT(curelm, field) != (elm))		\
+			curelm = STAILQ_NEXT(curelm, field);		\
+		STAILQ_REMOVE_AFTER(head, curelm, field);		\
+	}								\
+	TRASHIT(*oldnext);						\
+} while (0)
+
+#   define STAILQ_REMOVE_AFTER(head, elm, field) do {			\
+	if ((STAILQ_NEXT(elm, field) =					\
+	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+} while (0)
+
+#   define	STAILQ_REMOVE_HEAD(head, field) do {				\
+	if ((STAILQ_FIRST((head)) =					\
+	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
+		(head)->stqh_last = &STAILQ_FIRST((head));		\
+} while (0)
+
+#   define STAILQ_SWAP(head1, head2, type) do {				\
+	struct type *swap_first = STAILQ_FIRST(head1);			\
+	struct type **swap_last = (head1)->stqh_last;			\
+	STAILQ_FIRST(head1) = STAILQ_FIRST(head2);			\
+	(head1)->stqh_last = (head2)->stqh_last;			\
+	STAILQ_FIRST(head2) = swap_first;				\
+	(head2)->stqh_last = swap_last;					\
+	if (STAILQ_EMPTY(head1))					\
+		(head1)->stqh_last = &STAILQ_FIRST(head1);		\
+	if (STAILQ_EMPTY(head2))					\
+		(head2)->stqh_last = &STAILQ_FIRST(head2);		\
+} while (0)
+
+
+/*
+ * List declarations.
+ */
+#   define	LIST_HEAD(name, type)						\
+struct name {								\
+	struct type *lh_first;	/* first element */			\
+}
+
+#   define	LIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#   define	LIST_ENTRY(type)						\
+struct {								\
+	struct type *le_next;	/* next element */			\
+	struct type **le_prev;	/* address of previous next element */	\
+}
+
+/*
+ * List functions.
+ */
+
+#   if (defined(_KERNEL) && defined(INVARIANTS))
+#      define	QMD_LIST_CHECK_HEAD(head, field) do {				\
+	if (LIST_FIRST((head)) != NULL &&				\
+	    LIST_FIRST((head))->field.le_prev !=			\
+	     &LIST_FIRST((head)))					\
+		panic("Bad list head %p first->prev != head", (head));	\
+} while (0)
+
+#      define	QMD_LIST_CHECK_NEXT(elm, field) do {				\
+	if (LIST_NEXT((elm), field) != NULL &&				\
+	    LIST_NEXT((elm), field)->field.le_prev !=			\
+	     &((elm)->field.le_next))					\
+	     	panic("Bad link elm %p next->prev != elm", (elm));	\
+} while (0)
+
+#      define	QMD_LIST_CHECK_PREV(elm, field) do {				\
+	if (*(elm)->field.le_prev != (elm))				\
+		panic("Bad link elm %p prev->next != elm", (elm));	\
+} while (0)
+#   else
+#      define	QMD_LIST_CHECK_HEAD(head, field)
+#      define	QMD_LIST_CHECK_NEXT(elm, field)
+#      define	QMD_LIST_CHECK_PREV(elm, field)
+#   endif
+       /* (_KERNEL && INVARIANTS) */
+
+#   define	LIST_EMPTY(head)	((head)->lh_first == NULL)
+
+#   define	LIST_FIRST(head)	((head)->lh_first)
+
+#   define	LIST_FOREACH(var, head, field)					\
+	for ((var) = LIST_FIRST((head));				\
+	    (var);							\
+	    (var) = LIST_NEXT((var), field))
+
+#   define	LIST_FOREACH_FROM(var, head, field)				\
+	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
+	    (var);							\
+	    (var) = LIST_NEXT((var), field))
+
+#   define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = LIST_FIRST((head));				\
+	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	LIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
+	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
+	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	LIST_INIT(head) do {						\
+	LIST_FIRST((head)) = NULL;					\
+} while (0)
+
+#   define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
+	QMD_LIST_CHECK_NEXT(listelm, field);				\
+	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
+		LIST_NEXT((listelm), field)->field.le_prev =		\
+		    &LIST_NEXT((elm), field);				\
+	LIST_NEXT((listelm), field) = (elm);				\
+	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
+} while (0)
+
+#   define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
+	QMD_LIST_CHECK_PREV(listelm, field);				\
+	(elm)->field.le_prev = (listelm)->field.le_prev;		\
+	LIST_NEXT((elm), field) = (listelm);				\
+	*(listelm)->field.le_prev = (elm);				\
+	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
+} while (0)
+
+#   define	LIST_INSERT_HEAD(head, elm, field) do {				\
+	QMD_LIST_CHECK_HEAD((head), field);				\
+	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
+		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
+	LIST_FIRST((head)) = (elm);					\
+	(elm)->field.le_prev = &LIST_FIRST((head));			\
+} while (0)
+
+#   define	LIST_NEXT(elm, field)	((elm)->field.le_next)
+
+#   define	LIST_PREV(elm, head, type, field)				\
+	((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL :		\
+	    __containerof((elm)->field.le_prev, struct type, field.le_next))
+
+#   define	LIST_REMOVE(elm, field) do {					\
+	QMD_SAVELINK(oldnext, (elm)->field.le_next);			\
+	QMD_SAVELINK(oldprev, (elm)->field.le_prev);			\
+	QMD_LIST_CHECK_NEXT(elm, field);				\
+	QMD_LIST_CHECK_PREV(elm, field);				\
+	if (LIST_NEXT((elm), field) != NULL)				\
+		LIST_NEXT((elm), field)->field.le_prev = 		\
+		    (elm)->field.le_prev;				\
+	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
+	TRASHIT(*oldnext);						\
+	TRASHIT(*oldprev);						\
+} while (0)
+
+#   define LIST_SWAP(head1, head2, type, field) do {			\
+	struct type *swap_tmp = LIST_FIRST((head1));			\
+	LIST_FIRST((head1)) = LIST_FIRST((head2));			\
+	LIST_FIRST((head2)) = swap_tmp;					\
+	if ((swap_tmp = LIST_FIRST((head1))) != NULL)			\
+		swap_tmp->field.le_prev = &LIST_FIRST((head1));		\
+	if ((swap_tmp = LIST_FIRST((head2))) != NULL)			\
+		swap_tmp->field.le_prev = &LIST_FIRST((head2));		\
+} while (0)
+
+/*
+ * Tail queue declarations.
+ */
+#   define	TAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *tqh_first;	/* first element */			\
+	struct type **tqh_last;	/* addr of last next element */		\
+	TRACEBUF							\
+}
+
+#   define	TAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
+
+#   define	TAILQ_ENTRY(type)						\
+struct {								\
+	struct type *tqe_next;	/* next element */			\
+	struct type **tqe_prev;	/* address of previous next element */	\
+	TRACEBUF							\
+}
+
+/*
+ * Tail queue functions.
+ */
+#   if (defined(_KERNEL) && defined(INVARIANTS))
+#      define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
+	if (!TAILQ_EMPTY(head) &&					\
+	    TAILQ_FIRST((head))->field.tqe_prev !=			\
+	     &TAILQ_FIRST((head)))					\
+		panic("Bad tailq head %p first->prev != head", (head));	\
+} while (0)
+
+#      define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
+	if (*(head)->tqh_last != NULL)					\
+	    	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
+} while (0)
+
+#      define	QMD_TAILQ_CHECK_NEXT(elm, field) do {				\
+	if (TAILQ_NEXT((elm), field) != NULL &&				\
+	    TAILQ_NEXT((elm), field)->field.tqe_prev !=			\
+	     &((elm)->field.tqe_next))					\
+		panic("Bad link elm %p next->prev != elm", (elm));	\
+} while (0)
+
+#      define	QMD_TAILQ_CHECK_PREV(elm, field) do {				\
+	if (*(elm)->field.tqe_prev != (elm))				\
+		panic("Bad link elm %p prev->next != elm", (elm));	\
+} while (0)
+#   else
+#      define	QMD_TAILQ_CHECK_HEAD(head, field)
+#      define	QMD_TAILQ_CHECK_TAIL(head, headname)
+#      define	QMD_TAILQ_CHECK_NEXT(elm, field)
+#      define	QMD_TAILQ_CHECK_PREV(elm, field)
+#   endif
+       /* (_KERNEL && INVARIANTS) */
+
+#   define	TAILQ_CONCAT(head1, head2, field) do {				\
+	if (!TAILQ_EMPTY(head2)) {					\
+		*(head1)->tqh_last = (head2)->tqh_first;		\
+		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
+		(head1)->tqh_last = (head2)->tqh_last;			\
+		TAILQ_INIT((head2));					\
+		QMD_TRACE_HEAD(head1);					\
+		QMD_TRACE_HEAD(head2);					\
+	}								\
+} while (0)
+
+#   define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
+
+#   define	TAILQ_FIRST(head)	((head)->tqh_first)
+
+#   define	TAILQ_FOREACH(var, head, field)					\
+	for ((var) = TAILQ_FIRST((head));				\
+	    (var);							\
+	    (var) = TAILQ_NEXT((var), field))
+
+#   define	TAILQ_FOREACH_FROM(var, head, field)				\
+	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
+	    (var);							\
+	    (var) = TAILQ_NEXT((var), field))
+
+#   define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = TAILQ_FIRST((head));				\
+	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)			\
+	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
+	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#   define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
+	for ((var) = TAILQ_LAST((head), headname);			\
+	    (var);							\
+	    (var) = TAILQ_PREV((var), headname, field))
+
+#   define	TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)		\
+	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
+	    (var);							\
+	    (var) = TAILQ_PREV((var), headname, field))
+
+#   define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
+	for ((var) = TAILQ_LAST((head), headname);			\
+	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
+	    (var) = (tvar))
+
+#   define	TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
+	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
+	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
+	    (var) = (tvar))
+
+#   define	TAILQ_INIT(head) do {						\
+	TAILQ_FIRST((head)) = NULL;					\
+	(head)->tqh_last = &TAILQ_FIRST((head));			\
+	QMD_TRACE_HEAD(head);						\
+} while (0)
+
+#   define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	QMD_TAILQ_CHECK_NEXT(listelm, field);				\
+	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
+		    &TAILQ_NEXT((elm), field);				\
+	else {								\
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
+		QMD_TRACE_HEAD(head);					\
+	}								\
+	TAILQ_NEXT((listelm), field) = (elm);				\
+	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);		\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+	QMD_TRACE_ELEM(&listelm->field);				\
+} while (0)
+
+#   define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
+	QMD_TAILQ_CHECK_PREV(listelm, field);				\
+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
+	TAILQ_NEXT((elm), field) = (listelm);				\
+	*(listelm)->field.tqe_prev = (elm);				\
+	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);		\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+	QMD_TRACE_ELEM(&listelm->field);				\
+} while (0)
+
+#   define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
+	QMD_TAILQ_CHECK_HEAD(head, field);				\
+	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
+		TAILQ_FIRST((head))->field.tqe_prev =			\
+		    &TAILQ_NEXT((elm), field);				\
+	else								\
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
+	TAILQ_FIRST((head)) = (elm);					\
+	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
+	QMD_TRACE_HEAD(head);						\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (0)
+
+#   define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
+	QMD_TAILQ_CHECK_TAIL(head, field);				\
+	TAILQ_NEXT((elm), field) = NULL;				\
+	(elm)->field.tqe_prev = (head)->tqh_last;			\
+	*(head)->tqh_last = (elm);					\
+	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
+	QMD_TRACE_HEAD(head);						\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (0)
+
+#   define	TAILQ_LAST(head, headname)					\
+	(*(((struct headname *)((head)->tqh_last))->tqh_last))
+
+#   define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#   define	TAILQ_PREV(elm, headname, field)				\
+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+#   define	TAILQ_REMOVE(head, elm, field) do {				\
+	QMD_SAVELINK(oldnext, (elm)->field.tqe_next);			\
+	QMD_SAVELINK(oldprev, (elm)->field.tqe_prev);			\
+	QMD_TAILQ_CHECK_NEXT(elm, field);				\
+	QMD_TAILQ_CHECK_PREV(elm, field);				\
+	if ((TAILQ_NEXT((elm), field)) != NULL)				\
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
+		    (elm)->field.tqe_prev;				\
+	else {								\
+		(head)->tqh_last = (elm)->field.tqe_prev;		\
+		QMD_TRACE_HEAD(head);					\
+	}								\
+	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);		\
+	TRASHIT(*oldnext);						\
+	TRASHIT(*oldprev);						\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (0)
+
+#   define TAILQ_SWAP(head1, head2, type, field) do {			\
+	struct type *swap_first = (head1)->tqh_first;			\
+	struct type **swap_last = (head1)->tqh_last;			\
+	(head1)->tqh_first = (head2)->tqh_first;			\
+	(head1)->tqh_last = (head2)->tqh_last;				\
+	(head2)->tqh_first = swap_first;				\
+	(head2)->tqh_last = swap_last;					\
+	if ((swap_first = (head1)->tqh_first) != NULL)			\
+		swap_first->field.tqe_prev = &(head1)->tqh_first;	\
+	else								\
+		(head1)->tqh_last = &(head1)->tqh_first;		\
+	if ((swap_first = (head2)->tqh_first) != NULL)			\
+		swap_first->field.tqe_prev = &(head2)->tqh_first;	\
+	else								\
+		(head2)->tqh_last = &(head2)->tqh_first;		\
+} while (0)
+
+#endif /* !_SYS_QUEUE_H_ */

include/setup.h

@@ -0,0 +1,97 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/uapi/asm/bootparam.h
+/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/asm/e820/type.h
+
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+#include "types.h"
+#include "gdt.h"
+#include "boot.h"
+
+typedef struct miniregs {
+	union {
+		struct {
+			u32 eax;
+			u32 ebx;
+			u32 ecx;
+			u32 edx;
+			u32 esi;
+			u32 edi;
+			u32 ebp;
+			u32 eflags;
+		};
+		struct {
+			u16 ax, hax;
+			u16 bx, hbx;
+			u16 cx, hcx;
+			u16 dx, hdx;
+			u16 si, hsi;
+			u16 di, hdi;
+			u16 bp, hbp;
+			u16 flags, hflags;
+		};
+		struct {
+			u8 al, ah, hax2, hax3;
+			u8 bl, bh, hbx2, hbx3;
+			u8 cl, ch, hcx2, hcx3;
+			u8 dl, dh, hdx2, hdx3;
+		};
+	};
+} miniregs  __attribute__ ((packed));
+
+
+#define STRINGIFY(x) #x
+#define MACRO(x)     STRINGIFY(x)
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
+#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
+#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:(-!!(e)); }))
+
+#define EFLAGS_CF			0x00000001
+#define LOOPS_8042		100000
+#define FF_8042			32
+#define LOOPS_A20_ENABLE 	255
+#define LOOPS_DELAY 		32768
+#define SMAP	0x534d4150
+
+#define interrupt(num, regs) ({\
+	asm("mov %[eflagsregs],%%eax\n\
+	    pushl %%eax\n\
+	    popfl\n\
+	    mov %[eaxregs],%%eax\n\
+	    mov %[ebxregs],%%ebx\n\
+	    mov %[ecxregs],%%ecx\n\
+	    mov %[edxregs],%%edx\n\
+	    mov %[esiregs],%%esi\n\
+	    mov %[ediregs],%%edi\n\
+          int %[numregs]\n\
+	    pushfl\n\
+          popl %[eflagsregs]\n\
+	    mov %%eax,%[eaxregs]\n\
+	    mov %%ebx,%[ebxregs]\n\
+	    mov %%ecx,%[ecxregs]\n\
+	    mov %%edx,%[edxregs]\n\
+	    mov %%esi,%[esiregs]\n\
+	    mov %%edi,%[ediregs]":[eaxregs] "+m" (regs.eax),[ebxregs] "+m" (regs.ebx),[ecxregs] "+m" (regs.ecx),[edxregs] "+m" (regs.edx),[esiregs] "+m" (regs.esi),[ediregs] "+m" (regs.edi),[eflagsregs] "+m" (regs.eflags):[numregs] "i" (num):"%eax","%ebx","%ecx","%edx","%esi","%edi");})
+void cleanreg(miniregs *reg);
+u8 initmemory(void);
+void showchar(u8 achar);
+void showstr(u8 *str);
+u8 gettime(void);
+u8 waitchar(void);
+void initkeyboard(void);
+u8 empty8042(void);
+void iodelay(void);
+u8 testA20(void);
+void enableA20kbc(void);
+void enableA20fast(void);
+u8 enableA20(void);
+void memcpyto(void *src, void *dst, u32 count);
+void makegdtdes(u32 base, u32 limite, u8 acces, u8 flags, gdtdes * desc);
+void initgdt();
+void maskinterrupts(void);
+void initcoprocessor(void);
+void initpmode();
+void main(void);

include/shell.h

@@ -0,0 +1,33 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+typedef struct command
+{
+	u8      name[64];
+	u8      params[64];
+int     (*function) ()} command __attribute__ ((packed));
+
+int     rebootnow();
+int     test2d();
+int     test3d();
+int     showidt();
+int     showgdt();
+int     detectcpu();
+int     mode();
+int     clear();
+int     showregs();
+int     showinfo();
+int     err();
+int     view();
+int     test(void);
+int     disas(u8 * commandline);
+int     bpset(u8 * commandline);
+int     bpclr(u8 * commandline);
+int     sfont(u8 * commandline);
+int     help();
+int     logo();
+int     detectpci();
+int     showmem();
+int     testmem();
+int     testtask();
+int	  ps();

include/stdarg.h

@@ -1,20 +1,23 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #ifndef _VA_LIST_T_H
-#define _VA_LIST_T_H
+#   define _VA_LIST_T_H
 
-#define __GNUC_VA_LIST
+#   define __GNUC_VA_LIST
 
 typedef void *__gnuc_va_list;
 
-#define __va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
+#   define __va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
 
-#define va_start(AP, LASTARG) (AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
+#   define va_start(AP, LASTARG) (AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
 
-void va_end (__gnuc_va_list);		 
-#define va_end(AP)	((void)0)
+void    va_end(__gnuc_va_list);
+#   define va_end(AP)	((void)0)
 
-#define va_arg(AP, TYPE)	(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)),	*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
+#   define va_arg(AP, TYPE)	(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)),	*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
 
-#define __va_copy(dest, src) (dest) = (src)
+#   define __va_copy(dest, src) (dest) = (src)
 
 typedef __gnuc_va_list va_list;
 

include/string.h

@@ -1,8 +1,29 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
 
-s8 strcmp(const u8 *src,const u8 *des);
-u32 strlen(const u8 *src);
-u8 *strchr(const u8 *src, u8 achar);
-u8 *strncpy(const u8 *src,u8 *des,u32 count);
-u8 *strcat(const u8 *src,u8 *des);
-u8* strcpy(const u8 *src, u8 *des);
+s8      strcmp(const u8 * src, const u8 * des);
+u32     strlen(const u8 * src);
+u8     *strchr(const u8 * src, u8 achar);
+u8     *strncpy(const u8 * src, u8 * des, u32 count);
+u8     *strcat(const u8 * src, u8 * des);
+u8     *strcpy(const u8 * src, u8 * des);
+void    strtolower(u8 * src);
+void    strtoupper(u8 * src);
+void    stronecase(u8 * src);
+void    strsetlen(u8 * src, u32 size);
+void    strinvert(u8 * src);
+void    strreplace(u8 * src, u8 search, u8 replaced);
+u8     *strfill(u8 * dst, u8 pattern, u32 size);
+void    strright(u8 * src, u8 * dest, u32 size);
+void    strleft(u8 * src, u8 * dest, u32 size);
+void    strdelete(u8 * src, u32 index, u32 size);
+void    strcompressdelimiter(u8 * src, u8 delim);
+void    strinsert(u8 * src, u8 * dest, u32 index);
+u8     *strgetitem(u8 * src, u8 * dest, u8 delim, u32 index);
+u8     *strgetpointeritem(u8 * src, u8 delim, u32 index);
+u32     strgetnbitems(u8 * src, u8 delim);
+u8      strgetminbase(u8 * src);
+u8      strgetbase(u8 * src);
+u32     strtoint(u8 * src);

include/syscall.h

@@ -0,0 +1,51 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#define sysexit() asm volatile ("sysexit"::);
+
+
+#define syscall0(syscall) ({ \
+	u32 _v; \
+	asm volatile (\
+	"mov %%esp,%%ecx;\
+	mov $1f,%%edx;\
+	sysenter;\
+	1:" : "=a" (_v) : "a" (syscall): "ecx","edx","memory"); \
+	_v; \
+})
+
+#define syscall1(syscall,arg1) ({ \
+	u32 _v; \
+	asm volatile (\
+	"mov %%esp,%%ecx;\
+	mov $1f,%%edx;\
+	sysenter;\
+	1:" : "=a" (_v) : "a" (syscall), "b" (arg1) : "ecx","edx","memory"); \
+	_v; \
+})
+
+#define syscall2(syscall,arg1,arg2) ({ \
+	u32 _v; \
+	asm volatile (\
+	"mov %%esp,%%ecx;\
+	mov $1f,%%edx;\
+	sysenter;\
+	1:" : "=a" (_v) : "a" (syscall), "b" (arg1), "S" (arg2) : "ecx","edx","memory"); \
+	_v; \
+})
+
+#define syscall3(syscall,arg1,arg2,arg3) ({ \
+	u32 _v; \
+	asm volatile (\
+	"mov %%esp,%%ecx;\
+	mov $1f,%%edx;\
+	sysenter;\
+	1:" : "=a" (_v) : "a" (syscall), "b" (arg1), "S" (arg2), "D" (arg3)  : "ecx","edx","memory"); \
+	_v; \
+})
+
+/* Vers 6 arguments maximum */
+void    initsyscall(void);
+__attribute__ ((noreturn)) void sysenter_handler(regs *dump);
+

include/system.h

@@ -0,0 +1,7 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "boot.h";
+
+extern restart;

include/timer.h

@@ -1 +1,7 @@
-void timer();
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "interrupts.h"
+
+__attribute__ ((noreturn)) void timer_handler(regs *dump);

include/type.h

@@ -1,31 +0,0 @@
-/***********************************/
-/* Librairie Type.h                */
-/* 20 Mars 2007                    */
-/***********************************/
-
-#ifndef JREKCED_TYPE
-# define JREKCED_TYPE
-
-# define NULL (0x0LL)
-
-typedef char            	int8;
-typedef short           	int16;
-typedef int             	int32;
-typedef long long       	int64;
-
-typedef char	      	        BYTE;
-typedef short	      	        WORD;
-typedef long	      	        DWORD;
-typedef long long       	QWORD;
-
-typedef signed char		SBYTE;
-typedef signed short		SWORD;
-typedef signed long		SDWORD;
-typedef signed long long	SQWORD;
-
-typedef unsigned char		UBYTE;
-typedef unsigned short		UWORD;
-typedef unsigned long		UDWORD;
-typedef unsigned long long	UQWORD;
-
-#endif

include/types.h

@@ -1,66 +1,70 @@
-#ifndef I386_TYPE
-#define I386_TYPE
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#ifndef ALLTYPES
+#   define ALLTYPES
 
-typedef unsigned char	u8;
-typedef unsigned short	u16;
-typedef unsigned int	u32;
-typedef char	s8;
-typedef short	s16;
-typedef int	s32;
+typedef char int8;
+typedef short int16;
+typedef int int32;
+typedef long long int64;
+
+typedef char BYTE;
+typedef short WORD;
+typedef long DWORD;
+typedef long long QWORD;
+
+typedef signed char SBYTE;
+typedef signed short SWORD;
+typedef signed long SDWORD;
+typedef signed long long SQWORD;
+
+typedef unsigned char UBYTE;
+typedef unsigned short UWORD;
+typedef unsigned long UDWORD;
+typedef unsigned long long UQWORD;
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long long int u64;
+typedef char s8;
+typedef short s16;
+typedef int s32;
+typedef long int s64;
 typedef int bool;
 
-
-#define true -1;
-#define false 0;
-#define NULL 0x0000;
-
-struct dtr {
-
-	u16 limite;
-
-	u32 base;
-
-}  __attribute__ ((packed));
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
 extern char ctype[];
 
-#define CT_UP	0x01	/* upper case */
-#define CT_LOW	0x02	/* lower case */
-#define CT_DIG	0x04	/* digit */
-#define CT_CTL	0x08	/* control */
-#define CT_PUN	0x10	/* punctuation */
-#define CT_WHT	0x20	/* white space (space/cr/lf/tab) */
-#define CT_HEX	0x40	/* hex digit */
-#define CT_SP	0x80	/* hard space (0x20) */
+#   define true 1
+#   define false 0
+#   define NULL 0x0000
+
+#   define CT_UP	0x01	/* upper case */
+#   define CT_LOW	0x02	/* lower case */
+#   define CT_DIG	0x04	/* digit */
+#   define CT_CTL	0x08	/* control */
+#   define CT_PUN	0x10	/* punctuation */
+#   define CT_WHT	0x20	/* white space (space/cr/lf/tab) */
+#   define CT_HEX	0x40	/* hex digit */
+#   define CT_SP	0x80	/* hard space (0x20) */
 
 /* without the cast to unsigned, DJGPP complains (using -Wall) */
-#define isalnum(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
-#define isalpha(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
-#define iscntrl(c)	((ctype + 1)[(unsigned)(c)] & (CT_CTL))
-#define isdigit(c)	((ctype + 1)[(unsigned)(c)] & (CT_DIG))
-#define isgraph(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
-#define islower(c)	((ctype + 1)[(unsigned)(c)] & (CT_LOW))
-#define isprint(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
-#define ispunct(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN))
-#define isspace(c)	((ctype + 1)[(unsigned)(c)] & (CT_WHT))
-#define isupper(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP))
-#define isxdigit(c)	((ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
-#define isascii(c)	((unsigned)(c) <= 0x7F)
-#define toascii(c)	((unsigned)(c) & 0x7F)
+#   define isalnum(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
+#   define isalpha(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
+#   define iscntrl(c)	((ctype + 1)[(unsigned)(c)] & (CT_CTL))
+#   define isdigit(c)	((ctype + 1)[(unsigned)(c)] & (CT_DIG))
+#   define isgraph(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
+#   define islower(c)	((ctype + 1)[(unsigned)(c)] & (CT_LOW))
+#   define isprint(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
+#   define ispunct(c)	((ctype + 1)[(unsigned)(c)] & (CT_PUN))
+#   define isspace(c)	((ctype + 1)[(unsigned)(c)] & (CT_WHT))
+#   define isupper(c)	((ctype + 1)[(unsigned)(c)] & (CT_UP))
+#   define isxdigit(c)	((ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
+#   define isascii(c)	((unsigned)(c) <= 0x7F)
+#   define toascii(c)	((unsigned)(c) & 0x7F)
 
-#define tolower(c)	(isupper(c) ? c + 'a' - 'A' : c)
-#define toupper(c)	(islower(c) ? c + 'A' - 'a' : c)
-
-#ifdef __cplusplus
-}
-#endif
+#   define tolower(c)	(isupper(c) ? c + 'a' - 'A' : c)
+#   define toupper(c)	(islower(c) ? c + 'A' - 'a' : c)
 
 #endif
-
-
-

include/vesa.h

@@ -0,0 +1,49 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "types.h"
+#include "video.h"
+
+#define STATE       0x3da
+
+/* fonction obligatoires */
+void    VESA_remap_memory(u32 vaddr);
+u8     *VESA_detect_hardware(void);
+u8      VESA_setvideo_mode(u8 mode);
+u8     *VESA_getvideo_drivername(void);
+u8     *VESA_getvideo_capabilities(void);
+videoinfos *VESA_getvideo_info(void);
+u32     VESA_mem_to_video(void *src, u32 dst, u32 size,
+			  bool increment_src);
+u32     VESA_video_to_mem(u32 src, void *dst, u32 size);
+u32     VESA_video_to_video(u32 src, u32 dst, u32 size);
+void    VESA_wait_vretrace(void);
+void    VESA_wait_hretrace(void);
+void    VESA_page_set(u8 page);
+void    VESA_page_show(u8 page);
+void    VESA_dummy();
+
+static videofonction vesafonctions = {
+	&VESA_remap_memory,
+	&VESA_detect_hardware,
+	&VESA_setvideo_mode,
+	&VESA_getvideo_drivername,
+	&VESA_getvideo_capabilities,
+	&VESA_getvideo_info,
+	&VESA_mem_to_video,
+	&VESA_video_to_mem,
+	&VESA_video_to_video,
+	&VESA_wait_vretrace,
+	&VESA_wait_hretrace,
+	&VESA_page_set,
+	&VESA_page_show,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy,
+	&VESA_dummy
+};

include/vga.h

@@ -1,37 +1,148 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
+#include "video.h"
 
-#define TEXTSCREEN 0xB8000	/* debut de la memoire video texte*/
-#define GRPHSCREEN 0xA0000	/* debut de la memoire video graphique*/
+#define TEXTSCREEN 0xB8000	/* debut de la memoire video texte */
+#define GRPHSCREEN 0xA0000	/* debut de la memoire video graphique */
+#define ENDOFVMEM  0xC0000
 
-typedef u8 mode_def[64];
+/* Registres VGAs */
 
+#define SEQUENCER   0x3c4
+#define MISC_WRITE  0x3c2
+#define MISC_READ   0x3cc
+#define CCRT        0x3D4
+#define ATTRIBS     0x3c0
+#define GRAPHICS    0x3ce
+#define STATE       0x3da
 
-u32 setvmode(u8);
-u32 loadfont(u8* def,u8 size,u8 font);
-void gotoscr(u16 x,u16 y);
-void useplane(u8 plan);
-u8 getfont();
-void setfont(u8 num);
-void waitvretrace (void);
-void waithretrace (void);
-void enablecursor (void);
-void disablecursor (void);
-void enablescroll (void);
-void disablescroll (void);
-void (*writepxl)(u16 x, u16 y, u32 c);
-void (*showchar)(u16 coordx,u16 coordy,u8 thechar,u8 attrib);
-void (*fill)(u8 attrib);
-void (*scroll)(u8 lines,u8 attrib);
-void split(u16 x);
-void showpage(u8 page);
-u8 getpage();
-void setpage(u8 page);
-u16 getnbpages();
-u16 getyres();
-u8 getdepth();
-u16 getxres();
-u8 getfont2();
-void enableblink();
-void disableblink();
-u8 (*getchar)(u16 coordx,u16 coordy);
-u8 (*getattrib)(u16 coordx,u16 coordy);
+/* Taille d'un plan de bit */
+
+#define PLANESIZE 0x10000
+
+/* Registres VGA */
+typedef struct misc_regs
+{
+	u8      Miscellaneous_Output_Register;
+} misc_regs __attribute__ ((packed));
+
+typedef struct sequencer_regs
+{
+	u8      Reset_Register;
+	u8      Clocking_Mode_Register;
+	u8      Map_Mask_Register;
+	u8      Character_Map_Select_Register;
+	u8      Sequencer_Memory_Mode_Register;
+} sequencer_regs __attribute__ ((packed));
+
+typedef struct crtc_regs
+{
+	u8      Horizontal_Total_Register;
+	u8      End_Horizontal_Display_Register;
+	u8      Start_Horizontal_Blanking_Register;
+	u8      End_Horizontal_Blanking_Register;
+	u8      Start_Horizontal_Retrace_Register;
+	u8      End_Horizontal_Retrace_Register;
+	u8      Vertical_Total_Register;
+	u8      Overflow_Register;
+	u8      Preset_Row_Scan_Register;
+	u8      Maximum_Scan_Line_Register;
+	u8      Cursor_Start_Register;
+	u8      Cursor_End_Register;
+	u8      Start_Address_High_Register;
+	u8      Start_Address_Low_Register;
+	u8      Cursor_Location_High_Register;
+	u8      Cursor_Location_Low_Register;
+	u8      Vertical_Retrace_Start_Register;
+	u8      Vertical_Retrace_End_Register;
+	u8      Vertical_Display_End_Register;
+	u8      Offset_Register;
+	u8      Underline_Location_Register;
+	u8      Start_Vertical_Blanking_Register;
+	u8      End_Vertical_Blanking;
+	u8      CRTC_Mode_Control_Register;
+	u8      Line_Compare_Register;
+} crtc_regs __attribute__ ((packed));
+
+typedef struct graphics_regs
+{
+	u8      Set_Reset_Register;
+	u8      Enable_Set_Reset_Register;
+	u8      Color_Compare_Register;
+	u8      Data_Rotate_Register;
+	u8      Read_Map_Select_Register;
+	u8      Graphics_Mode_Register;
+	u8      Miscellaneous_Graphics_Register;
+	u8      Color_Dont_Care_Register;
+	u8      Bit_Mask_Register;
+} graphics_regs __attribute__ ((packed));
+
+typedef struct attributs_regs
+{
+	u8      Palette_Registers[16];
+	u8      Attribute_Mode_Control_Register;
+	u8      Overscan_Color_Register;
+	u8      Color_Plane_Enable_Register;
+	u8      Horizontal_Pixel_Panning_Register;
+	u8      Color_Select_Register;
+} attributs_regs __attribute__ ((packed));
+
+typedef struct vgamode
+{
+	misc_regs misc;
+	sequencer_regs sequencer;
+	crtc_regs ctrc;
+	graphics_regs graphic;
+	attributs_regs attribut;
+} vgamode __attribute__ ((packed));
+
+/* fonction obligatoires */
+void    VGA_remap_memory(u32 vaddr);
+u8     *VGA_detect_hardware(void);
+u8      VGA_setvideo_mode(u8 mode);
+u8     *VGA_getvideo_drivername(void);
+u8     *VGA_getvideo_capabilities(void);
+videoinfos *VGA_getvideo_info(void);
+u32     VGA_mem_to_video(void *src, u32 dst, u32 size, bool increment_src);
+u32     VGA_video_to_mem(u32 src, void *dst, u32 size);
+u32     VGA_video_to_video(u32 src, u32 dst, u32 size);
+void    VGA_wait_vretrace(void);
+void    VGA_wait_hretrace(void);
+void    VGA_page_set(u8 page);
+void    VGA_page_show(u8 page);
+void    VGA_page_split(u16 y);
+void    VGA_cursor_enable(void);
+void    VGA_cursor_disable(void);
+void    VGA_cursor_set(u16 x, u16 y);
+u32     VGA_font_load(u8 * def, u8 size, u8 font);
+void    VGA_font1_set(u8 num);
+void    VGA_font2_set(u8 num);
+void    VGA_blink_enable(void);
+void    VGA_blink_disable(void);
+
+static videofonction vgafonctions = {
+	&VGA_remap_memory,
+	&VGA_detect_hardware,
+	&VGA_setvideo_mode,
+	&VGA_getvideo_drivername,
+	&VGA_getvideo_capabilities,
+	&VGA_getvideo_info,
+	&VGA_mem_to_video,
+	&VGA_video_to_mem,
+	&VGA_video_to_video,
+	&VGA_wait_vretrace,
+	&VGA_wait_hretrace,
+	&VGA_page_set,
+	&VGA_page_show,
+	&VGA_page_split,
+	&VGA_cursor_enable,
+	&VGA_cursor_disable,
+	&VGA_cursor_set,
+	&VGA_font_load,
+	&VGA_font1_set,
+	&VGA_font2_set,
+	&VGA_blink_enable,
+	&VGA_blink_disable
+};

include/video.h

@@ -1,19 +1,188 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 
-typedef struct console {
-  u8 attrib;
-  s16 cursX;
-  s16 cursY; 
-  u8 ansi;
-  u8 param1;
-  u8 param2;
-  u8 param3;
-  u8 page;
-} console  __attribute__ ((packed));
+#ifndef VIDEO
+#   define VIDEO
 
+#   include "stdarg.h"
 
-void showhex(u8 src);
-void putchar(u8 thechar);
-void print(u8* string);
-void printf (const u8 *string, ...);
-void changevc(u8 vc);
+#   define MAXDRIVERS 10
+#   define MAXFONTS   10
 
+typedef struct vertex2d
+{
+	s16     x;
+	s16     y;
+} vertex2d __attribute__ ((packed));
+
+typedef struct rgbcolor
+{
+	u8      R;
+	u8      G;
+	u8      B;
+} rgbcolor __attribute__ ((packed));
+
+typedef struct videoinfos
+{
+	u8      currentmode;
+	u16     currentwidth;
+	u16     currentheight;
+	u8      currentdepth;
+	u8      currentactivepage;
+	u8      currentshowedpage;
+	u16     currentcursorX;
+	u16     currentcursorY;
+	u8      currentfont1;
+	u8      currentfont2;
+	u16     currentpitch;
+	bool    isgraphic;
+	bool    isblinking;
+	bool    iscursorvisible;
+	u8      pagesnumber;
+	u32     pagesize;
+	u32     baseaddress;
+} videoinfos __attribute__ ((packed));
+
+typedef struct videofonction
+{
+	void    (*remap_memory) ();
+	u8     *(*detect_hardware) ();
+	        u8(*setvideo_mode) ();
+	u8     *(*getvideo_drivername) ();
+	u8     *(*getvideo_capabilities) ();
+	videoinfos *(*getvideo_info) ();
+	        u32(*mem_to_video) ();
+	        u32(*video_to_mem) ();
+	        u32(*video_to_video) ();
+	void    (*wait_vretrace) ();
+	void    (*wait_hretrace) ();
+	void    (*page_set) ();
+	void    (*page_show) ();
+	void    (*page_split) ();
+	void    (*cursor_enable) ();
+	void    (*cursor_disable) ();
+	void    (*cursor_set) ();
+	        u32(*font_load) ();
+	void    (*font1_set) ();
+	void    (*font2_set) ();
+	void    (*blink_enable) ();
+	void    (*blink_disable) ();
+} videofonction __attribute__ ((packed));
+
+typedef struct drivers
+{
+	u8     *nom;
+	videofonction *pointer;
+} drivers __attribute__ ((packed));
+
+typedef struct font
+{
+	u8      nom[8];
+	u8     *pointer;
+	u8      width;
+	u8      height;
+} font __attribute__ ((packed));
+
+typedef struct capabilities
+{
+	u8      modenumber;
+	u16     width;
+	u16     height;
+	bool    graphic;
+	u8      depth;
+	u8      refresh;
+} capabilities __attribute__ ((packed));
+
+typedef struct console
+{
+	u8      attrib;
+	s16     cursX;
+	s16     cursY;
+	u8      ansi;
+	u8      param1;
+	u8      param2;
+	u8      param3;
+	u8      page;
+	bool    scroll;
+} console __attribute__ ((packed));
+
+/* Fonctions de bas niveau */
+void    fill(u8 attrib);
+void    scroll(u8 lines, u8 attrib);
+void    scroll_enable(void);
+void    scroll_disable(void);
+void    showchar(u16 coordx, u16 coordy, u8 thechar, u8 attrib);
+u8      getchar(u16 coordx, u16 coordy);
+u8      getattrib(u16 coordx, u16 coordy);
+void    v_writepxl(vertex2d * A, u32 color);
+void    writepxl(s16 x, s16 y, u32 color);
+void    line(s16 x1, s16 y1, s16 x2, s16 y2, u32 color);
+void    hline(s16 x1, s16 x2, s16 y, u32 color);
+void    changemode(u8 mode);
+u32     egatorgb(u8 ega);
+u8      egatovga(u8 ega);
+void    v_line(vertex2d * A, vertex2d * B, u32 color);
+void    trianglefilled(vertex2d * A, vertex2d * B, vertex2d * C,
+		       u32 color);
+void    triangle(vertex2d * A, vertex2d * B, vertex2d * C, u32 color);
+
+/* Fonctions de console */
+void    changevc(u8 vc);
+void    putchar(u8 thechar);
+void    clearscreen(void);
+u16     getwidth(void);
+u16     getheight(void);
+void    loadfont(u8 * name, font * pointer, u8 width, u8 height);
+void    setfont(u8 * fontname);
+
+/* Fonctions de haut niveau */
+u32     print(u8 * string);
+u32     printf(const u8 * string, ...);
+u32     sprintf(u8 * variable, const u8 * string, ...);
+u32     snprintf(u8 * variable, u32 maxsize, const u8 * string, ...);
+u32     vprintf(const u8 * string, va_list args);
+u32     vsprintf(u8 * variable, const u8 * string, va_list args);
+u32     vsnprintf(u8 * variable, u32 maxsize, const u8 * string,
+		  va_list args);
+
+u8     *itoa(u64 num, u8 * str, u8 base, u64 dim, u8 achar);
+u8     *sitoa(u64 num, u8 * str, u64 dim);
+u8     *rtoadouble(double num, u8 * str, u8 precisioni, u8 precisionf);
+u8     *rtoasingle(float num, u8 * str, u8 precisioni, u8 precisionf);
+u32     format(const u8 * string, va_list args, u32 maxsize,
+	       u32(*fonction) (u8 * src, u8 ** dest, u32 len), u8 * dest);
+
+/* Fonction pour gérer le pilote */
+void    initdriver();
+void    registerdriver(videofonction * pointer);
+void    apply_bestdriver(void);
+void    apply_nextdriver(void);
+void    apply_driver(u8 * name);
+void    apply_nextvideomode(void);
+
+/* Fonctions du pilote */
+void    (*remap_memory) (u32 vaddr);
+u8     *(*detect_hardware) (void);
+u8(*setvideo_mode) (u8 mode);
+u8     *(*getvideo_drivername) (void);
+u8     *(*getvideo_capabilities) (void);
+videoinfos *(*getvideo_info) (void);
+u32(*mem_to_video) (void *src, u32 dst, u32 size, bool increment_src);
+u32(*video_to_mem) (u32 src, void *dst, u32 size);
+u32(*video_to_video) (u32 src, u32 dst, u32 size);
+void    (*wait_vretrace) (void);
+void    (*wait_hretrace) (void);
+void    (*page_set) (u8 page);
+void    (*page_show) (u8 page);
+void    (*page_split) (u16 y);
+void    (*cursor_enable) (void);
+void    (*cursor_disable) (void);
+void    (*cursor_set) (u16 x, u16 y);
+u32(*font_load) (u8 * def, u8 size, u8 font);
+void    (*font1_set) (u8 num);
+void    (*font2_set) (u8 num);
+void    (*blink_enable) (void);
+void    (*blink_disable) (void);
+
+#endif

lib/3d.c

@@ -1,5 +1,280 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "3d.h"
-#include "vga.h"
 #include "types.h"
 #include "video.h"
-#include "graph.h"
+#include "string.h"
+
+/*******************************************************************************/
+/* Crée une projection simple pour test */
+void proj(vector4 list[], vertex2d plane[], vector4 origin[], u16 number,
+	  float factor)
+{
+	for (u32 i = 0; i < number; i++)
+	{
+		plane[i].x =
+			(int) ((list[i].x * factor) /
+			       (list[i].z + origin->z) + origin->x);
+		plane[i].y =
+			(int) ((list[i].y * factor) /
+			       (list[i].z + origin->z) + origin->y);
+	}
+}
+
+/*******************************************************************************/
+/* Crée une liste de vertex3D pour un cube */
+
+void cube(model3d * model, vector4 * origin, u16 size)
+{
+	strcpy("cube", model->name);
+	model->vertexnb = 8;
+	model->vertexlist = 0x00300000;
+	model->vertexlist[0].x = origin->x;
+	model->vertexlist[0].y = origin->y;
+	model->vertexlist[0].z = origin->z;
+	model->vertexlist[0].w = 1.0f;
+	model->vertexlist[1].x = origin->x + size;
+	model->vertexlist[1].y = origin->y;
+	model->vertexlist[1].z = origin->z;
+	model->vertexlist[1].w = 1.0f;
+	model->vertexlist[2].x = origin->x;
+	model->vertexlist[2].y = origin->y + size;
+	model->vertexlist[2].z = origin->z;
+	model->vertexlist[2].w = 1.0f;
+	model->vertexlist[3].x = origin->x + size;
+	model->vertexlist[3].y = origin->y + size;
+	model->vertexlist[3].z = origin->z;
+	model->vertexlist[3].w = 1.0f;
+	model->vertexlist[4].x = origin->x;
+	model->vertexlist[4].y = origin->y;
+	model->vertexlist[4].z = origin->z + size;
+	model->vertexlist[4].w = 1.0f;
+	model->vertexlist[5].x = origin->x + size;
+	model->vertexlist[5].y = origin->y;
+	model->vertexlist[5].z = origin->z + size;
+	model->vertexlist[5].w = 1.0f;
+	model->vertexlist[6].x = origin->x;
+	model->vertexlist[6].y = origin->y + size;
+	model->vertexlist[6].z = origin->z + size;
+	model->vertexlist[6].w = 1.0f;
+	model->vertexlist[7].x = origin->x + size;
+	model->vertexlist[7].y = origin->y + size;
+	model->vertexlist[7].z = origin->z + size;
+	model->vertexlist[7].w = 1.0f;
+	model->facelist = 0x00310000;
+	model->facelist[0].V1 = 0;
+	model->facelist[0].V2 = 1;
+	model->facelist[0].V3 = 3;
+	model->facelist[1].V1 = 0;
+	model->facelist[1].V2 = 2;
+	model->facelist[1].V3 = 3;
+	model->facelist[2].V1 = 4;
+	model->facelist[2].V2 = 5;
+	model->facelist[2].V3 = 7;
+	model->facelist[3].V1 = 4;
+	model->facelist[3].V2 = 6;
+	model->facelist[3].V3 = 7;
+	model->facelist[4].V1 = 0;
+	model->facelist[4].V2 = 1;
+	model->facelist[4].V3 = 5;
+	model->facelist[5].V1 = 0;
+	model->facelist[5].V2 = 1;
+	model->facelist[5].V3 = 4;
+	model->facelist[6].V1 = 0;
+	model->facelist[6].V2 = 0;
+	model->facelist[6].V3 = 0;
+	model->facelist[7].V1 = 0;
+	model->facelist[7].V2 = 0;
+	model->facelist[7].V3 = 0;
+	model->facelist[8].V1 = 0;
+	model->facelist[8].V2 = 0;
+	model->facelist[8].V3 = 0;
+	model->facelist[9].V1 = 0;
+	model->facelist[9].V2 = 0;
+	model->facelist[9].V3 = 0;
+	model->facelist[10].V1 = 0;
+	model->facelist[10].V2 = 0;
+	model->facelist[10].V3 = 0;
+	model->facelist[11].V1 = 0;
+	model->facelist[11].V2 = 0;
+	model->facelist[11].V3 = 0;
+}
+
+/*******************************************************************************/
+/* Affiche un modèle 3D */
+
+void show3dmodel(model3d * model, matrix44 * transformation,
+		 vector4 origin[], float factor, type3D type)
+{
+	u16     i;
+	vertex2d *plane = 0x00250000;
+	for (i = 0; i < model->vertexnb; i++)
+	{
+		matrix44_transform(transformation, &model->vertexlist[i]);
+	}
+	proj(model->vertexlist, plane, origin, model->vertexnb, factor);
+	switch (type)
+	{
+		case TYPE3D_POINTS:
+			for (i = 0; i < model->vertexnb; i++)
+			{
+				v_writepxl(&plane[i], egatorgb(4));
+			}
+			break;
+		case TYPE3D_LINES:
+			for (i = 0; i < model->facenb; i++)
+			{
+				v_line(&plane[model->facelist[i].V1],
+				       &plane[model->facelist[i].V2],
+				       egatorgb(4));
+				v_line(&plane[model->facelist[i].V1],
+				       &plane[model->facelist[i].V3],
+				       egatorgb(4));
+				v_line(&plane[model->facelist[i].V2],
+				       &plane[model->facelist[i].V3],
+				       egatorgb(4));
+			}
+			break;
+		case TYPE3D_FACES:
+			break;
+		case TYPE3D_FLAT:
+			break;
+		case TYPE3D_TEXTURE:
+			break;
+	}
+}
+
+/*******************************************************************************/
+/* Charge un fichier 3DS */
+
+int load3ds(u8 * pointer, u32 size, model3d * model)
+{
+	u8     *ptr = pointer;
+	u16     chunk_id;
+	u32     chunk_size;
+	u16     i;
+	float  *listfloat;
+	u16    *listunsigned;
+	dsState state = DS_READ_CHUNK_ID;
+	bool    dsfile = false;
+	while (ptr - pointer < size)
+	{
+		switch (state)
+		{
+			case DS_READ_CHUNK_ID:
+				chunk_id = *((u16 *) ptr);
+				ptr += 2;
+				state = DS_READ_CHUNK_LENGTH;
+				break;
+			case DS_READ_CHUNK_LENGTH:
+				chunk_size = *((u32 *) ptr);
+				ptr += 4;
+				switch (chunk_id)
+				{
+					case MAIN3DS:
+						dsfile = true;
+						ptr += 10;
+						state = DS_READ_CHUNK_ID;
+						break;
+					case EDIT3DS:
+						state = DS_READ_CHUNK_ID;
+						break;
+					case OBJ_TRIMESH:
+						state = DS_READ_CHUNK_ID;
+						break;
+					case EDIT_OBJECT:
+						state = DS_READ_OBJECT_NAME;
+						break;
+					case TRI_VERTEXL:
+						state = DS_READ_POINT_COUNT;
+						break;
+					case TRI_FACEL1:
+						state = DS_READ_FACE_COUNT;
+						break;
+					case TRI_LOCAL:
+						state = DS_READ_MATRIX;
+						break;
+					default:
+						if (!dsfile)
+							return 1;
+						ptr += (chunk_size - 6);
+						state = DS_READ_CHUNK_ID;
+						break;
+				}
+				break;
+			case DS_READ_OBJECT_NAME:
+				strcpy(ptr, model->name);
+				ptr += (strlen(ptr) + 1);
+				state = DS_READ_CHUNK_ID;
+				break;
+			case DS_SKIP_CHUNK:
+				break;
+			case DS_READ_POINT_COUNT:
+				model->vertexnb = *((u16 *) ptr);
+				state = DS_READ_POINTS;
+				ptr += 2;
+				break;
+			case DS_READ_POINTS:
+				i = 0;
+				listfloat = ptr;
+				model->vertexlist = 0x00300000;
+				while (i < model->vertexnb)
+				{
+					model->vertexlist[i].x =
+						*(listfloat++);
+					model->vertexlist[i].y =
+						*(listfloat++);
+					model->vertexlist[i].z =
+						*(listfloat++);
+					model->vertexlist[i++].w = 1.0;
+				}
+				ptr = listfloat;
+				state = DS_READ_CHUNK_ID;
+				break;
+			case DS_READ_FACE_COUNT:
+				model->facenb = *((u16 *) ptr);
+				state = DS_READ_FACES;
+				ptr += 2;
+				break;
+			case DS_READ_FACES:
+				i = 0;
+				listunsigned = ptr;
+				model->facelist = 0x00400000;
+				while (i < model->facenb)
+				{
+					model->facelist[i].V1 =
+						*(listunsigned++);
+					model->facelist[i].V2 =
+						*(listunsigned++);
+					model->facelist[i++].V3 =
+						*(listunsigned++);
+					listunsigned++;
+				}
+				ptr = listunsigned;
+				state = DS_READ_CHUNK_ID;
+				break;
+			case DS_READ_MATRIX:
+				i = 0;
+				listfloat = ptr;
+				while (i < 4)
+				{
+					model->view.V[i].x =
+						*(listfloat++);
+					model->view.V[i].y =
+						*(listfloat++);
+					model->view.V[i].z =
+						*(listfloat++);
+					model->view.V[i++].w = 0.0f;
+				}
+				model->view.V[3].w = 1.0f;
+				ptr = listfloat;
+				state = DS_READ_CHUNK_ID;
+				break;
+			case DS_READ_DONE:
+				break;
+
+		}
+
+	}
+}

lib/8x16fnt.c

@@ -1,259 +0,0 @@
-/* Police de caract鑽e fine 8x16 */
-static u8 font8x16 [4096] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0x81, 0xBD, 0x99, 0x81, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7E, 0xFF, 0xDB, 0xFF, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x36, 0x7F, 0x7F, 0x7F, 0x7F, 0x3E, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x3C, 0x3C, 0xE7, 0xE7, 0xE7, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x7E, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-	0x00, 0x00, 0x0F, 0x07, 0x0D, 0x19, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x30, 0x70, 0xF0, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x63, 0x67, 0xE7, 0xE6, 0xC0, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0xDB, 0x3C, 0xE7, 0x3C, 0xDB, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x40, 0x60, 0x70, 0x7C, 0x7F, 0x7C, 0x70, 0x60, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x01, 0x03, 0x07, 0x1F, 0x7F, 0x1F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7F, 0xDB, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3E, 0x63, 0x30, 0x1C, 0x36, 0x63, 0x63, 0x36, 0x1C, 0x06, 0x63, 0x3E, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x0C, 0x06, 0x7F, 0x06, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x7F, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x10, 0x7E, 0x90, 0x90, 0x90, 0x7C, 0x12, 0x12, 0x12, 0xFC, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x61, 0x91, 0x92, 0x64, 0x08, 0x10, 0x26, 0x49, 0x89, 0x86, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x70, 0x88, 0x88, 0x88, 0x50, 0x60, 0x91, 0x8A, 0x84, 0x4A, 0x31, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x06, 0x18, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x60, 0x18, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x10, 0x92, 0x54, 0x38, 0xFE, 0x38, 0x54, 0x92, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x83, 0x85, 0x89, 0x91, 0xA1, 0xC1, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C, 0x40, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x02, 0x06, 0x0A, 0x12, 0x22, 0x42, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFF, 0x80, 0x80, 0x80, 0xFC, 0x02, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFF, 0x81, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00, 
-	0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x38, 0x44, 0x82, 0x82, 0x04, 0x08, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x99, 0xA5, 0xA5, 0xA5, 0x9E, 0x80, 0x41, 0x3E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x24, 0x42, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFC, 0x42, 0x41, 0x41, 0x42, 0x7C, 0x42, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFC, 0x42, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x80, 0x9F, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x38, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x07, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x82, 0x84, 0x88, 0x90, 0xE0, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0xC3, 0xA5, 0x99, 0x99, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81, 0x89, 0x85, 0x42, 0x3D, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x42, 0x81, 0x80, 0x40, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFE, 0x92, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x99, 0x99, 0xA5, 0xA5, 0x42, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x82, 0x82, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFF, 0x01, 0x01, 0x02, 0x04, 0x18, 0x20, 0x40, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 
-	0x00, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x02, 0x02, 0x7E, 0x82, 0x82, 0x7D, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x01, 0x01, 0x01, 0x01, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0xFF, 0x80, 0x40, 0x3E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0E, 0x11, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x02, 0x7C, 0x00, 0x00, 
-	0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x08, 0x08, 0x00, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x02, 0x02, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x44, 0x38, 0x00, 0x00, 
-	0x00, 0x80, 0x80, 0x80, 0x80, 0x82, 0x84, 0x88, 0x90, 0xA8, 0xC4, 0x82, 0x00, 0x00, 0x00, 0x00, 
-	0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0xC4, 0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x80, 0x80, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xC1, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0x80, 0x7E, 0x01, 0x81, 0x7E, 0x00, 0x00, 0x00, 0x00, 
-	0x10, 0x10, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x11, 0x0E, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x92, 0xAA, 0x44, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x02, 0x7C, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x02, 0x04, 0x18, 0x20, 0x40, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x04, 0x08, 0x10, 0x10, 0x10, 0x20, 0x10, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x40, 0x20, 0x10, 0x10, 0x10, 0x08, 0x10, 0x10, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x70, 0x99, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x08, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1E, 0x33, 0x61, 0x60, 0x60, 0x61, 0x33, 0x1E, 0x06, 0x03, 0x3E, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x66, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x06, 0x0C, 0x18, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x08, 0x1C, 0x36, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x66, 0x66, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x1C, 0x36, 0x1C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x0C, 0x06, 0x3C, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x66, 0x66, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x66, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x3C, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x63, 0x63, 0x08, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x1C, 0x36, 0x1C, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x0C, 0x18, 0x30, 0x00, 0x7F, 0x33, 0x30, 0x3E, 0x30, 0x33, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x6E, 0x3B, 0x1B, 0x7E, 0xD8, 0xDC, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1F, 0x36, 0x66, 0x66, 0x7F, 0x66, 0x66, 0x66, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x63, 0x63, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x3C, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x30, 0x18, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x3F, 0x03, 0x06, 0x3C, 0x00, 0x00, 0x00, 
-	0x00, 0x63, 0x63, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x18, 0x18, 0x7E, 0xC3, 0xC0, 0xC0, 0xC3, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x1C, 0x36, 0x32, 0x30, 0x78, 0x30, 0x30, 0x30, 0x73, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0xC3, 0x66, 0x3C, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xFC, 0x66, 0x66, 0x7C, 0x62, 0x66, 0x6F, 0x66, 0x66, 0xF3, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0E, 0x1B, 0x18, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0xD8, 0x70, 0x00, 0x00, 0x00, 
-	0x00, 0x0C, 0x18, 0x30, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0C, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0C, 0x18, 0x30, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0C, 0x18, 0x30, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x3B, 0x6E, 0x00, 0x6E, 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x3B, 0x6E, 0x00, 0x63, 0x73, 0x7B, 0x7F, 0x6F, 0x67, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C, 0x18, 0x30, 0x6E, 0xC3, 0x06, 0x0C, 0x1F, 0x00, 0x00, 0x00, 
-	0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C, 0x18, 0x33, 0x67, 0xCF, 0x1F, 0x03, 0x03, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x1B, 0x36, 0x6C, 0x36, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x6C, 0x36, 0x1B, 0x36, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x00, 0x00, 
-	0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x00, 0x00, 
-	0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-	0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x00, 0x00, 
-	0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x6C, 0x6C, 0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3E, 0x63, 0x7E, 0x63, 0x63, 0x7E, 0x60, 0x60, 0x20, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7F, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x7F, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7F, 0x63, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x6C, 0x6C, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x7E, 0x18, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x36, 0x36, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1E, 0x30, 0x18, 0x0C, 0x3E, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x03, 0x06, 0x7E, 0xDB, 0xDB, 0xF3, 0x7E, 0x60, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x1C, 0x30, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 
-	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x00, 0x3B, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x0F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0xD8, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x70, 0xD8, 0x30, 0x60, 0xC8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};

lib/8x8fnt.c

@@ -1,131 +0,0 @@
-/* Police de caract鑽e fine 8x8 */
-static u8 font8x8 [2048] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0xBD, 0x99, 0x81, 0x7E, 
-	0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x6C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 
-	0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x38, 0x7C, 0x38, 0xFE, 0xFE, 0x7C, 0x38, 0x7C, 
-	0x10, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x7C, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 
-	0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 
-	0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78, 
-	0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x70, 0xF0, 0xE0, 
-	0x7F, 0x63, 0x7F, 0x63, 0x63, 0x67, 0xE6, 0xC0, 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99, 
-	0x80, 0xE0, 0xF8, 0xFE, 0xF8, 0xE0, 0x80, 0x00, 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02, 0x00, 
-	0x18, 0x3C, 0x7E, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00, 
-	0x7F, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00, 0x3E, 0x63, 0x38, 0x6C, 0x6C, 0x38, 0xCC, 0x78, 
-	0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x7E, 0x3C, 0x18, 0xFF, 
-	0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 
-	0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00, 
-	0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00, 
-	0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x40, 0x00, 
-	0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x50, 0xF8, 0x50, 0xF8, 0x50, 0x50, 0x00, 
-	0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 0x00, 0xC8, 0xC8, 0x10, 0x20, 0x40, 0x98, 0x98, 0x00, 
-	0x70, 0x88, 0x50, 0x20, 0x54, 0x88, 0x74, 0x00, 0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x20, 0x40, 0x80, 0x80, 0x80, 0x40, 0x20, 0x00, 0x20, 0x10, 0x08, 0x08, 0x08, 0x10, 0x20, 0x00, 
-	0x00, 0x20, 0xA8, 0x70, 0x70, 0xA8, 0x20, 0x00, 0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 
-	0x70, 0x88, 0x98, 0xA8, 0xC8, 0x88, 0x70, 0x00, 0x40, 0xC0, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00, 
-	0x70, 0x88, 0x08, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x70, 0x88, 0x08, 0x10, 0x08, 0x88, 0x70, 0x00, 
-	0x08, 0x18, 0x28, 0x48, 0xFC, 0x08, 0x08, 0x00, 0xF8, 0x80, 0x80, 0xF0, 0x08, 0x88, 0x70, 0x00, 
-	0x20, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x40, 0x40, 0x00, 
-	0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 0x00, 0x70, 0x88, 0x88, 0x78, 0x08, 0x08, 0x70, 0x00, 
-	0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x20, 
-	0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0x00, 0x00, 
-	0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 0x00, 0x78, 0x84, 0x04, 0x08, 0x10, 0x00, 0x10, 0x00, 
-	0x70, 0x88, 0x88, 0xA8, 0xB8, 0x80, 0x78, 0x00, 0x20, 0x50, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x00, 
-	0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 0x00, 
-	0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0x00, 0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0xF8, 0x00, 
-	0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x80, 0x80, 0x98, 0x88, 0x78, 0x00, 
-	0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 0x00, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00, 
-	0x38, 0x10, 0x10, 0x10, 0x10, 0x90, 0x60, 0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 0x00, 
-	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xF8, 0x00, 0x82, 0xC6, 0xAA, 0x92, 0x82, 0x82, 0x82, 0x00, 
-	0x84, 0xC4, 0xA4, 0x94, 0x8C, 0x84, 0x84, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 0x00, 
-	0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x88, 0x88, 0xA8, 0x90, 0x68, 0x00, 
-	0xF0, 0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 0x00, 0x70, 0x88, 0x80, 0x70, 0x08, 0x88, 0x70, 0x00, 
-	0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 0x00, 
-	0x88, 0x88, 0x88, 0x50, 0x50, 0x20, 0x20, 0x00, 0x82, 0x82, 0x82, 0x82, 0x92, 0x92, 0x6C, 0x00, 
-	0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x20, 0x20, 0x00, 
-	0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 0x00, 0xE0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xE0, 0x00, 
-	0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x20, 0xE0, 0x00, 
-	0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 
-	0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x74, 0x00, 
-	0x80, 0x80, 0xB0, 0xC8, 0x88, 0xC8, 0xB0, 0x00, 0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 0x00, 
-	0x08, 0x08, 0x68, 0x98, 0x88, 0x98, 0x68, 0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x70, 0x00, 
-	0x30, 0x48, 0x40, 0xE0, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, 0x34, 0x48, 0x48, 0x38, 0x08, 0x30, 
-	0x80, 0x80, 0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x20, 0x00, 0x60, 0x20, 0x20, 0x20, 0x70, 0x00, 
-	0x10, 0x00, 0x30, 0x10, 0x10, 0x10, 0x90, 0x60, 0x80, 0x80, 0x88, 0x90, 0xA0, 0xD0, 0x88, 0x00, 
-	0xC0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92, 0x92, 0x00, 
-	0x00, 0x00, 0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 0x00, 
-	0x00, 0x00, 0xB0, 0xC8, 0xC8, 0xB0, 0x80, 0x80, 0x00, 0x00, 0x68, 0x98, 0x98, 0x68, 0x08, 0x08, 
-	0x00, 0x00, 0xB0, 0xC8, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x78, 0x80, 0x70, 0x08, 0xF0, 0x00, 
-	0x40, 0x40, 0xE0, 0x40, 0x40, 0x50, 0x20, 0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x98, 0x68, 0x00, 
-	0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x6C, 0x00, 
-	0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x88, 0x88, 0x98, 0x68, 0x08, 0x70, 
-	0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x10, 0x20, 0x20, 0x40, 0x20, 0x20, 0x10, 0x00, 
-	0x40, 0x40, 0x40, 0x00, 0x40, 0x40, 0x40, 0x00, 0x40, 0x20, 0x20, 0x10, 0x20, 0x20, 0x40, 0x00, 
-	0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00, 
-	0x3E, 0x60, 0xC0, 0x60, 0x3E, 0x08, 0x04, 0x18, 0x00, 0x48, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 
-	0x18, 0x20, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x10, 0x28, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 
-	0x00, 0x48, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x30, 0x08, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 
-	0x48, 0x30, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x10, 0x08, 0x30, 
-	0x30, 0x48, 0x84, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 
-	0x30, 0x08, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 
-	0x30, 0x48, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x60, 0x10, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 
-	0x48, 0x00, 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0x30, 0x48, 0x30, 0x48, 0x84, 0xFC, 0x84, 0x84, 
-	0x18, 0x20, 0x00, 0xF8, 0x80, 0xF0, 0x80, 0xF8, 0x00, 0x00, 0x00, 0x66, 0x19, 0x77, 0x88, 0x77, 
-	0x00, 0x00, 0x00, 0x0F, 0x14, 0x3E, 0x44, 0x87, 0x30, 0x48, 0x84, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 
-	0x00, 0x48, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x60, 0x10, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 
-	0x30, 0x48, 0x84, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x60, 0x10, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 
-	0x48, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0x44, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0x6C, 0x38, 
-	0x24, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x08, 0x1C, 0x28, 0x28, 0x1C, 0x08, 0x00, 
-	0x1C, 0x22, 0x20, 0x70, 0x20, 0x22, 0x5C, 0x00, 0x44, 0x28, 0x10, 0x10, 0x38, 0x10, 0x38, 0x10, 
-	0xF0, 0x88, 0x8A, 0xF7, 0x82, 0x82, 0x83, 0x00, 0x06, 0x08, 0x08, 0x3C, 0x10, 0x10, 0x60, 0x00, 
-	0x18, 0x20, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x18, 0x20, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 
-	0x18, 0x20, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x18, 0x20, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 
-	0x80, 0x78, 0x04, 0xF8, 0xCC, 0xCC, 0xCC, 0xCC, 0x80, 0x7E, 0x01, 0xC6, 0xE6, 0xD6, 0xCE, 0xC6, 
-	0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, 0xFE, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0xFC, 
-	0x00, 0x00, 0x18, 0x18, 0x30, 0x60, 0x66, 0x3C, 0xFF, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 
-	0xFF, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC4, 0x48, 0x50, 0x26, 0x49, 0x82, 0x07, 
-	0x40, 0xC4, 0x48, 0x50, 0x26, 0x4A, 0x9F, 0x02, 0x00, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 
-	0x00, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x00, 0x48, 0x24, 0x12, 0x09, 0x12, 0x24, 0x48, 
-	0x49, 0x00, 0x92, 0x00, 0x49, 0x00, 0x92, 0x00, 0x6D, 0x00, 0xB6, 0x00, 0x6D, 0x00, 0xB6, 0x00, 
-	0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 
-	0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x10, 0x10, 
-	0x28, 0x28, 0x28, 0x28, 0xE8, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x28, 0x28, 0x28, 
-	0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x28, 0x28, 0x28, 0xE8, 0x08, 0xE8, 0x28, 0x28, 
-	0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00, 0xF8, 0x08, 0xE8, 0x28, 0x28, 
-	0x28, 0x28, 0x28, 0xE8, 0x08, 0xF8, 0x00, 0x00, 0x28, 0x28, 0x28, 0x28, 0xF8, 0x00, 0x00, 0x00, 
-	0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10, 
-	0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10, 
-	0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10, 0x10, 
-	0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x28, 0x28, 0x28, 
-	0x28, 0x28, 0x28, 0x2F, 0x20, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x20, 0x2F, 0x28, 0x28, 
-	0x28, 0x28, 0x28, 0xEF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEF, 0x28, 0x28, 
-	0x28, 0x28, 0x28, 0x2F, 0x20, 0x2F, 0x28, 0x28, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 
-	0x28, 0x28, 0x28, 0xEF, 0x00, 0xEF, 0x28, 0x28, 0x10, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x00, 0x00, 
-	0x28, 0x28, 0x28, 0x28, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x10, 0x10, 
-	0x00, 0x00, 0x00, 0x00, 0xFF, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x00, 0x00, 0x00, 
-	0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x10, 0x10, 
-	0x00, 0x00, 0x00, 0x00, 0x3F, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0xFF, 0x28, 0x28, 0x28, 
-	0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 
-	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x02, 0x34, 0x4C, 0x4C, 0x32, 0x00, 0x5C, 0x22, 0x22, 0x3C, 0x44, 0x44, 0x78, 
-	0x7E, 0x42, 0x42, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x02, 0x7C, 0xA8, 0x28, 0x28, 0x44, 
-	0x00, 0x7E, 0x61, 0x30, 0x18, 0x08, 0x10, 0x20, 0x00, 0x00, 0x08, 0x7F, 0x88, 0x88, 0x88, 0x70, 
-	0x00, 0x00, 0x00, 0x22, 0x44, 0x44, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x7C, 0x10, 0x10, 0x10, 0x10, 
-	0x00, 0x1C, 0x08, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x00, 0x38, 0x44, 0x44, 0x7C, 0x44, 0x44, 
-	0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0x66, 0x24, 0x66, 0x0C, 0x10, 0x08, 0x1C, 0x22, 0x22, 0x22, 0x1C, 
-	0x00, 0x00, 0x00, 0x00, 0x6C, 0x92, 0x92, 0x6C, 0x00, 0x01, 0x1A, 0x26, 0x2A, 0x32, 0x2C, 0x40, 
-	0x00, 0x18, 0x20, 0x20, 0x30, 0x20, 0x20, 0x18, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 
-	0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x3E, 
-	0x00, 0x10, 0x08, 0x04, 0x08, 0x10, 0x00, 0x3E, 0x00, 0x04, 0x08, 0x10, 0x08, 0x04, 0x00, 0x3E, 
-	0x00, 0x06, 0x09, 0x09, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x48, 0x48, 0x30, 
-	0x00, 0x00, 0x08, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x00, 0x60, 0x92, 0x0C, 0x60, 0x92, 0x0C, 0x00, 
-	0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, 0x30, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x04, 0xC8, 0x28, 0x10, 0x00, 
-	0x00, 0x00, 0x00, 0x7C, 0x42, 0x42, 0x42, 0x00, 0x18, 0x24, 0x08, 0x10, 0x3C, 0x00, 0x00, 0x00, 
-	0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};

lib/Kmemory.c

@@ -1,156 +0,0 @@
-/***********************************/
-/* Librairie Kmemory.c             */
-/* 20 Mars 2007                    */
-/***********************************/
-
-#include <type.h>
-#include <Kmemory.h>
-
-/* Structure table d'allocation memoire */
-typedef struct
-{
-    UBYTE Used : 1;   // = 0 -> La zone memoire est libre.
-                      // = 1 -> La zone memoire est utilisee.
-    UBYTE Expand : 1; // = 0 -> Fin du bloc.
-                      // = 1 -> Le bloc se prolonge sur le bloc suivant.
-    UBYTE UnUsed : 6; // Zone libre.
-} T_KernelMemoryMap;
-
-
-T_KernelMemoryMap * BlocAllocate = NULL;  // Table d'allocation des blocs memoire.
-void  *             BaseDynAlloc = NULL;  // Pointeur sur la zone memoire allouable.
-UDWORD              MaxMemoryBlocs;
-
-
-// Initialisation du gestionnaire de memoire.
-void Kernel_InitMemory (void *DataMemory, UDWORD TotalMemorySize)
-{
-    UDWORD Boucle;
-    UDWORD TableBlocs;
-    UDWORD TotalBlocs;
-
-    // Alignement des bloc de memoire a un multiple de MEMORY_BLOC_SIZE
-    if ( (UDWORD)DataMemory % MEMORY_BLOC_SIZE != 0)
-    {  DataMemory = ((void*) ((((UDWORD)DataMemory) / MEMORY_BLOC_SIZE) * MEMORY_BLOC_SIZE) + MEMORY_BLOC_SIZE );  };
-
-    TotalBlocs = (((void*)TotalMemorySize) - DataMemory) / MEMORY_BLOC_SIZE;
-    TableBlocs = TotalBlocs / MEMORY_BLOC_SIZE;
-    MaxMemoryBlocs = TotalBlocs - TableBlocs;
-    BlocAllocate = (T_KernelMemoryMap *)DataMemory;
-    BaseDynAlloc = DataMemory + (TableBlocs * MEMORY_BLOC_SIZE);
-    
-    for (Boucle = 0; Boucle < MaxMemoryBlocs; Boucle++)
-    { 
-        BlocAllocate [Boucle].Used   = 0;
-        BlocAllocate [Boucle].Expand = 0;
-    }
-}
-
-
-// Alloue SIZE blocs de memoire
-void * Kernel_mballoc(UDWORD Size)
-{
-   UDWORD Counter = 0;
-   UDWORD Base    = 0;
-   UDWORD Boucle, Boucle2;
-
-   if (Size == 0) return NULL;
-
-   for (Boucle = 0; Boucle < MaxMemoryBlocs; Boucle++)
-   {
-      if (BlocAllocate[Boucle].Used == 0) { Counter++; }
-      else { Counter = 0; Base = Boucle + 1; }
-
-      if (Counter >= Size)
-      {
-         if (Base+Size > MaxMemoryBlocs) return NULL;
-         for (Boucle2=Base; Boucle2 < (Base+Size); Boucle2++)
-         {
-            BlocAllocate[Boucle2].Used   = 1;
-            if (Boucle2+1 < (Base+Size) ) { BlocAllocate[Boucle2].Expand = 1; }
-            else { BlocAllocate[Boucle2].Expand = 0; }
-        }
-        return ((void*) (BaseDynAlloc + (Base * MEMORY_BLOC_SIZE) ));
-      }
-   }
-   return NULL;
-}
-
-// Libere un bloc memoire
-int Kernel_mbfree (void *Adresse)
-{
-   UDWORD Bloc;
-
-   if (((Adresse - BaseDynAlloc) % MEMORY_BLOC_SIZE) != 0) return -1;
-   if ((((UDWORD)Adresse) % MEMORY_BLOC_SIZE) != 0) return -1;
-
-   Bloc = (Adresse - BaseDynAlloc) / MEMORY_BLOC_SIZE;
-
-   for (;  BlocAllocate[Bloc].Expand == 1; Bloc++)
-   {
-       BlocAllocate[Bloc].Used   = 0;
-       BlocAllocate[Bloc].Expand = 0;
-   }
-
-   BlocAllocate[Bloc].Used   = 0;
-   BlocAllocate[Bloc].Expand = 0;
-
-   return 0;
-};
-
-void * Kernel_mbrealloc (void *Adresse, UDWORD Size)
-{
-   UDWORD Bloc, Boucle, OldSize, CopySize;
-   void * NewAdresse;
-
-   if (((Adresse - BaseDynAlloc) % MEMORY_BLOC_SIZE) != 0) return NULL;
-   Bloc = (Adresse - BaseDynAlloc) / MEMORY_BLOC_SIZE;
-   if (BlocAllocate[Bloc].Used == 0) return NULL;
-
-   for (Boucle = Bloc; BlocAllocate[Boucle].Expand == 1; Boucle++) 
-   { if (Boucle >= MaxMemoryBlocs) break; };
-   
-   OldSize = Boucle - Bloc + 1;
-
-   // Si pas de changement de taille de bloc, ...
-   if ( Size == OldSize) return Adresse;
-
-   // Si on reduit le nombre de bloc, ...
-   if ( Size < OldSize)
-   {
-      for (Boucle = (Bloc + Size); Boucle < (Bloc + OldSize) ; Boucle++)
-      { 
-         BlocAllocate[Boucle].Used   = 0;
-         BlocAllocate[Boucle].Expand = 0;
-      }
-      BlocAllocate[Size-1].Expand = 0;
-      return Adresse;
-   }
-   
-   // Si on augmente le nombre de bloc
-   for (Boucle = (Bloc + OldSize); Boucle < (Bloc + Size) ; Boucle++)
-   {
-       // Si le bloc ne peut etre simplement agrandit, ...
-       if ( BlocAllocate[Boucle].Used == 1 )
-       {
-           NewAdresse = Kernel_mballoc (Size);
-           if (NewAdresse == NULL) return NULL;
-           CopySize = (OldSize * MEMORY_BLOC_SIZE) / sizeof (int64);
-           for (Boucle = 0; Boucle < CopySize; Boucle++)
-           { ((int64*) NewAdresse)[Boucle] = ((int64*) Adresse)[Boucle]; };
-           Kernel_mbfree (Adresse);
-           return NewAdresse;
-       }
-   }
-   
-   // Le bloc est simplement agrandit
-   for (Boucle = (Bloc + OldSize - 1); Boucle < (Bloc + Size) ; Boucle++)
-   {
-         BlocAllocate[Boucle].Used   = 1;
-         BlocAllocate[Boucle].Expand = 1;
-   }
-   BlocAllocate[Size-1].Expand = 0;
-   return Adresse;
-}
-
-#undef MAX_MEMORY_BLOCS

lib/LDT.c

@@ -1,236 +0,0 @@
-/***********************************/
-/* Librairie LDT.c                 */
-/* 23 Mars 2007                    */
-/***********************************/
-
-#include "LDT.h"
-#include "Kmemory.h"
-
-# define LDT_MANAGER_SIZE  (127)
-
-typedef struct // Structure de gestion des bloc LDT
-{
-   void   * Next;                      // Pointeur de chainage
-   UDWORD  Empty;
-   T_LDT_reg LDTdesc [LDT_MANAGER_SIZE]; // Nombre de blocs LDT
-} T_LDT_Manager;
-
-void            LDT_initalloc (void *AllocTable, UDWORD Index, UDWORD SetSize, UDWORD TotalSize);
-T_LDT_Manager * LDT_mballoc (UWORD Size);
-
-/////////////////////////////////////////////////////////////////////////
-
-T_LDT_Manager * LDT_Manager = NULL;
-
-/////////////////////////////////////////////////////////////////////////
-
-T_LDT * LDT_balloc (UWORD Size)  // Alloue un bloc de Size LDT
-{
-    UWORD Boucle;
-    UDWORD Blocs, Boucle2;
-    T_LDT_Manager * * ptr_Manager = &LDT_Manager;
-    T_LDT_Manager *   Manager     = LDT_Manager;
-
-    do
-    {
-       if (* ptr_Manager == NULL)
-       {
-          * ptr_Manager = Kernel_mballoc (1);
-          Manager = * ptr_Manager;
-          Manager->Next = NULL;
-          for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-          {
-             Manager->LDTdesc [Boucle].Adresse = NULL;
-             Manager->LDTdesc [Boucle].Size    = NULL;
-          }
-       }
-
-       for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-       {
-          if (Manager->LDTdesc [Boucle].Adresse == NULL)
-          {
-
-             Blocs = Size * sizeof(T_LDT);
-             if (Blocs % MEMORY_BLOC_SIZE == 0)
-             { Blocs /= MEMORY_BLOC_SIZE; } else { Blocs = (Blocs / MEMORY_BLOC_SIZE) + 1; }
-             Manager->LDTdesc [Boucle].Adresse = Kernel_mballoc (Blocs);
-             if (Manager->LDTdesc [Boucle].Adresse == NULL) return NULL;
-             Manager->LDTdesc [Boucle].Size    = (Blocs * MEMORY_BLOC_SIZE) / sizeof(T_LDT);
-             
-             // Mise a zero de la LDT
-             for (Boucle2 = 0; Boucle2 < Manager->LDTdesc [Boucle].Size; Boucle2++)
-             { ((int64*) Manager->LDTdesc [Boucle].Adresse)[Boucle2] = NULL; }
-
-             return Manager->LDTdesc [Boucle].Adresse;
-          }
-       }
-
-       *ptr_Manager = Manager;
-       Manager      = Manager->Next;
-    } while (1);
-}
-
-
-int LDT_bfree (void * Adresse) // Libere un bloc LDT
-{
-    UWORD  Boucle, Boucle2;
-    int    RetVal;
-    T_LDT_Manager * * ptr_Manager = &LDT_Manager;
-    T_LDT_Manager *   Manager     = LDT_Manager;
-
-    do
-    {
-       if (*ptr_Manager == NULL) { return -1; }
-       for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-       {
-          if (Manager->LDTdesc [Boucle].Adresse == Adresse)
-          {
-
-             RetVal = Kernel_mbfree(Manager->LDTdesc [Boucle].Adresse);
-             if (Boucle == 0)
-             {
-                 Kernel_mbfree (*ptr_Manager);
-                 *ptr_Manager = NULL;
-                 return RetVal;
-             }
-             else
-             {
-                for (Boucle2 = Boucle; Boucle2 < LDT_MANAGER_SIZE-1; Boucle2++)
-                { Manager->LDTdesc [Boucle2] = Manager->LDTdesc [Boucle2+1]; }
-
-                Manager->LDTdesc [Boucle2+1].Size    = NULL;
-                Manager->LDTdesc [Boucle2+1].Adresse = NULL;
-             }
-
-             Manager->LDTdesc [LDT_MANAGER_SIZE-1].Size    = NULL;
-             Manager->LDTdesc [LDT_MANAGER_SIZE-1].Adresse = NULL;
-
-             return RetVal;
-          }
-       }
-
-       *ptr_Manager = Manager;
-       Manager      = Manager->Next;
-    } while (1);
-
-}
-
-T_LDT * LDT_brealloc (T_LDT * OldLDT, UWORD NewSize)
-{
-    T_LDT * NewLDT;
-    UDWORD Blocs;
-    UWORD  Boucle;
-
-    T_LDT_Manager * * ptr_Manager = &LDT_Manager;
-    T_LDT_Manager *   Manager     = LDT_Manager;
-    Blocs = NewSize * sizeof(T_LDT);
-
-    if (Blocs % MEMORY_BLOC_SIZE == 0)
-    { Blocs /= MEMORY_BLOC_SIZE; } else { Blocs = (Blocs / MEMORY_BLOC_SIZE) + 1; }
-
-    do
-    {
-       if (*ptr_Manager == NULL) { return NULL; }
-       for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-       {
-          if (Manager->LDTdesc [Boucle].Adresse == OldLDT)
-          {
-             NewLDT = Kernel_mbrealloc (OldLDT, Blocs);
-             if (NewLDT == NULL) return NULL;
-             Manager->LDTdesc [Boucle].Adresse = NewLDT;
-             Manager->LDTdesc [Boucle].Size    = NewSize;
-             return NewLDT;
-          }
-       }
-
-       *ptr_Manager = Manager;
-       Manager      = Manager->Next;
-    } while (1);
-}
-
-///////////////////////////////////////////////////////////////////////
-
-T_LDT * LDT_AllocLDT (T_LDT *BaseLDT)
-{
-    UWORD Boucle;
-    UDWORD Boucle2;
-    UDWORD Size;
-    T_LDT_Manager * Manager = LDT_Manager;
-
-    if (BaseLDT == NULL) return NULL;
-
-    do
-    {
-       if (Manager == NULL)  { return NULL; }
-       for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-       {
-          Size = Manager->LDTdesc [Boucle].Size;
-          if (Manager->LDTdesc [Boucle].Adresse == ((void*)BaseLDT) )
-          {
-            for (Boucle2 = 1; Boucle2 < Size; Boucle2++) // Le 1e LDT reste null
-            {
-               if ( BaseLDT[Boucle2].UserDefine == 0 )
-               {
-                  BaseLDT[Boucle2].UserDefine = 1;
-                  return BaseLDT+Boucle2;
-               };
-            }
-            return NULL;
-          }
-       }
-       Manager = Manager->Next;
-    } while (1);
-}
-
-int LDT_FreeLDT (T_LDT *LDT)  // Marque le LDT comme non utilise et le met a NULL
-{
-    if ( ((UDWORD)LDT & 0x07L) != NULL)  { return -2; }
-    if (LDT->UserDefine == 0) { return -1; }
-    *((int64*)LDT) = NULL;
-    return 0;
-}
-
-///////////////////////////////////////////////////////////////////////
-
-int LDT_MapMemory (T_LDT *LDT, void * Linear, UDWORD Size, UBYTE Granularite, UBYTE DPL, UBYTE Type, UBYTE CPUMode)
-{
-   if ( ((UDWORD)LDT & 0x07L) != NULL)  { return -2; }
-
-   LDT->Adresse_0_15  = (DWORD)Linear & 0x0000FFFFL;
-   LDT->Adresse_16_23 = ((DWORD)Linear >> 16)  & 0x000000FFL;
-   LDT->Adresse_24_31 = ((DWORD)Linear >> 24) & 0x000000FFL;
-   LDT->Limite_0_15   = Size & 0x0000FFFFL;
-   LDT->Limite_16_19  = (Size >> 16) & 0x0000000FL;
-   LDT->Granularite   = Granularite;
-   LDT->Type          = Type;
-   LDT->DPL           = DPL;
-   LDT->CPUMode       = CPUMode;
-   LDT->Present       = 1;
-   LDT->UserDefine    = 1;
-   return 0;
-}
-
-int LDT_load (T_LDT *LDT)
-{
-    UWORD  Boucle;
-    T_LDT_Manager * * ptr_Manager = &LDT_Manager;
-    T_LDT_Manager *   Manager     = LDT_Manager;
-
-    do
-    {
-       if (*ptr_Manager == NULL) { return -1; }
-       for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
-       {
-          if (Manager->LDTdesc [Boucle].Adresse == LDT)
-          {
-             asm("lgdt %0\n" : : "m" (Manager->LDTdesc [Boucle]));
-             return 0;
-          }
-       }
-
-       *ptr_Manager = Manager;
-       Manager      = Manager->Next;
-    } while (1);
-}
-
-

lib/PCI/class.c

@@ -0,0 +1,196 @@
+static pciclass old[] = {
+	{0x0, "Pre-2.0 PCI Specification Device, Non-VGA"},
+	{0x1, "Pre-2.0 PCI Specification Device, VGA Compatible"},
+	{0, NULL}
+};
+
+static pciclass storage[] = {
+	{0x00, "Mass Storage Controller, SCSI"},
+	{0x01, "Mass Storage Controller, IDE"},
+	{0x02, "Mass Storage Controller, Floppy"},
+	{0x03, "Mass Storage Controller, IPI"},
+	{0x04, "Mass Storage Controller, RAID"},
+	{0x05, "Mass Storage Controller, ATA controller with single DMA"},
+	{0x06, "Mass Storage Controller, SATA"},
+	{0x07, "Mass Storage Controller, SAS"},
+	{0x08, "Mass Storage Controller, NVM"},
+	{0x80, "Mass Storage Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass network[] = {
+	{0x00, "Network Controller, Ethernet"},
+	{0x01, "Network Controller, Token Ring"},
+	{0x02, "Network Controller, FDDI"},
+	{0x03, "Network Controller, ATM"},
+	{0x04, "Network Controller, ISDN"},
+	{0x80, "Network Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass display[] = {
+	{0x00, "Display Controller, VGA"},
+	{0x01, "Display Controller, XGA"},
+	{0x02, "Display Controller, 3D"},
+	{0x80, "Display Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass multimedia[] = {
+	{0x00, "Multimedia Device, Video"},
+	{0x01, "Multimedia Device, Audio"},
+	{0x02, "Multimedia Device, Telephony"},
+	{0x03, "Multimedia Device, HDA"},
+	{0x80, "Multimedia Device, Other"},
+	{0, NULL}
+};
+
+static pciclass memory[] = {
+	{0x00, "Memory Controller, RAM"},
+	{0x01, "Memory Controller, Flash"},
+	{0x80, "Memory Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass bridge[] = {
+	{0x00, "Bridge Device, Host/PCI"},
+	{0x01, "Bridge Device, PCI/ISA"},
+	{0x02, "Bridge Device, PCI/EISA"},
+	{0x03, "Bridge Device, PCI/Micro Channel"},
+	{0x04, "Bridge Device, PCI/PCI"},
+	{0x05, "Bridge Device, PCI/PCMCIA"},
+	{0x06, "Bridge Device, PCI/NuBus"},
+	{0x07, "Bridge Device, PCI/CardBus"},
+	{0x08, "Bridge Device, PCI/RACEway"},
+	{0x09, "Bridge Device, PCI/Transparent"},
+	{0x0a, "Bridge Device, Infiniband"},
+	{0x80, "Bridge Device, Other"},
+	{0, NULL}
+};
+
+static pciclass simplecomm[] = {
+	{0x00, "Simple Communications Controller, Serial"},
+	{0x01, "Simple Communications Controller, Parallel"},
+	{0x02, "Simple Communications Controller, Multiport"},
+	{0x03, "Simple Communications Controller, Modem"},
+	{0x04, "Simple Communications Controller, GPIB"},
+	{0x05, "Simple Communications Controller, Smart Card"},
+	{0x80, "Simple Communications Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass baseperiph[] = {
+	{0x00, "Base Systems Peripheral, Interrupt Controller"},
+	{0x01, "Base Systems Peripheral, DMA"},
+	{0x02, "Base Systems Peripheral, System Timer"},
+	{0x03, "Base Systems Peripheral, Real Time Clock"},
+	{0x04, "Base Systems Peripheral, PCI Hot-plug"},
+	{0x05, "Base Systems Peripheral, SD Host Controller"},
+	{0x06, "Base Systems Peripheral, IOMMU"},
+	{0x80, "Base Systems Peripheral, Other"},
+	{0, NULL}
+};
+
+static pciclass input[] = {
+	{0x00, "Input Device, Keyboard"},
+	{0x01, "Input Device, Digitizer"},
+	{0x02, "Input Device, Mouse"},
+	{0x03, "Input Device, Scanner"},
+	{0x04, "Input Device, Game Port"},
+	{0x80, "Input Device, Other"},
+	{0, NULL}
+};
+
+static pciclass docking[] = {
+	{0x00, "Docking Station, Generic"},
+	{0x80, "Docking Station, Other"},
+	{0, NULL}
+};
+
+static pciclass processor[] = {
+	{0x00, "Processor, i386"},
+	{0x01, "Processor, i486"},
+	{0x02, "Processor, Pentium"},
+	{0x10, "Processor, Alpha"},
+	{0x20, "Processor, Power PC"},
+	{0x80, "Processor, Co-processor"},
+	{0, NULL}
+};
+
+static pciclass serial[] = {
+	{0x00, "Serial Bus Controller, Firewire"},
+	{0x01, "Serial Bus Controller, ACCESS.bus"},
+	{0x02, "Serial Bus Controller, SSA"},
+	{0x03, "Serial Bus Controller, USB"},
+	{0x04, "Serial Bus Controller, Fibre Channel"},
+	{0x05, "Serial Bus Controller, SMBus"},
+	{0x06, "Serial Bus Controller, Inifiniband"},
+	{0x07, "Serial Bus Controller, IPMI"},
+	{0, NULL}
+};
+
+static pciclass wireless[] = {
+	{0x00, "Wireless Controller, iRDA"},
+	{0x01, "Wireless Controller, IR"},
+	{0x10, "Wireless Controller, RF"},
+	{0x11, "Wireless Controller, Bluetooth"},
+	{0x12, "Wireless Controller, Broadband"},
+	{0x20, "Wireless Controller, 802.11a"},
+	{0x21, "Wireless Controller, 802.11b"},
+	{0x80, "Wireless Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass intelliio[] = {
+	{0x00, "Intelligent IO Controller, I2O"},
+	{0, NULL}
+};
+
+static pciclass satcomm[] = {
+	{0x00, "Satellite Communication Controller, TV"},
+	{0x01, "Satellite Communication Controller, Audio"},
+	{0x02, "Satellite Communication Controller, Voice"},
+	{0x03, "Satellite Communication Controller, Data"},
+	{0, NULL}
+};
+
+static pciclass crypto[] = {
+	{0x00, "Encryption/Decryption Controller, Network/computer"},
+	{0x01, "Encryption/Decryption Controller, Entertainment"},
+	{0x80, "Encryption/Decryption Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass dasp[] = {
+	{0x00, "Data Acquisition and Signal Processing Controller, DPIO"},
+	{0x01,
+	 "Data Acquisition and Signal Processing Controller, Performance Counter"},
+	{0x10,
+	 "Data Acquisition and Signal Processing Controller, Communications Synchronization"},
+	{0x20,
+	 "Data Acquisition and Signal Processing Controller, Management Card"},
+	{0x80, "Data Acquisition and Signal Processing Controller, Other"},
+	{0, NULL}
+};
+
+static pciclass *classcodes[] = {
+	old,
+	storage,
+	network,
+	display,
+	multimedia,
+	memory,
+	bridge,
+	simplecomm,
+	baseperiph,
+	input,
+	docking,
+	processor,
+	serial,
+	wireless,
+	intelliio,
+	satcomm,
+	crypto,
+	dasp,
+	[255] = NULL
+};

lib/VGA/8x16fnt.c

@@ -0,0 +1,673 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+/* Police de caractère fine 8x16 */
+static u8 font8x16[4096] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0x81, 0xBD, 0x99, 0x81, 0x7E,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7E, 0xFF, 0xDB, 0xFF, 0xFF, 0xC3, 0xE7, 0xFF,
+	0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x36, 0x7F, 0x7F, 0x7F, 0x7F, 0x3E,
+	0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E,
+	0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x3C, 0x3C, 0xE7, 0xE7,
+	0xE7, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x3C, 0x7E, 0xFF,
+	0xFF, 0x7E, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xFF, 0xFF, 0xFF, 0xFF,
+	0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+	0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0xFF, 0xFF,
+	0xFF, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0xFF, 0xFF,
+	0xFF, 0x00, 0x00,
+	0x00,
+	0x00, 0x0F, 0x07, 0x0D, 0x19, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x18,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x30, 0x70, 0xF0, 0xE0,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x63, 0x67, 0xE7, 0xE6,
+	0xC0, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x18, 0xDB, 0x3C, 0xE7, 0x3C, 0xDB, 0x18, 0x18,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x40, 0x60, 0x70, 0x7C, 0x7F, 0x7C, 0x70, 0x60, 0x40,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x01, 0x03, 0x07, 0x1F, 0x7F, 0x1F, 0x07, 0x03,
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E,
+	0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+	0x00, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7F, 0xDB, 0xDB, 0xDB, 0x7B,
+	0x1B, 0x1B, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3E, 0x63, 0x30, 0x1C, 0x36,
+	0x63, 0x63, 0x36, 0x1C, 0x06, 0x63, 0x3E, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x3C,
+	0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x18,
+	0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x0C, 0x06, 0x7F, 0x06, 0x0C, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x7F, 0x30, 0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x7F, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
+	0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42,
+	0x42, 0xFF, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x10, 0x7E, 0x90, 0x90, 0x90,
+	0x7C, 0x12, 0x12, 0x12, 0xFC, 0x10, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x61, 0x91, 0x92,
+	0x64, 0x08, 0x10, 0x26, 0x49, 0x89, 0x86, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x70, 0x88, 0x88,
+	0x88, 0x50, 0x60, 0x91, 0x8A, 0x84, 0x4A, 0x31, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x18, 0x18,
+	0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x06,
+	0x18, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 0x18, 0x06, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x60, 0x18, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x18, 0x60,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x10, 0x92, 0x54, 0x38, 0xFE, 0x38, 0x54, 0x92, 0x10,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+	0x18, 0x10,
+	0x20, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+	0x18, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
+	0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x83, 0x85, 0x89, 0x91, 0xA1, 0xC1,
+	0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C,
+	0x40, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x01, 0x02,
+	0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x02, 0x06, 0x0A, 0x12,
+	0x22, 0x42, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x80, 0x80,
+	0x80, 0xFC, 0x02, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x3C, 0x42,
+	0x81, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0xFF,
+	0x81, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x3C, 0x42, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x81, 0x42,
+	0x3C, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18,
+	0x18, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18,
+	0x18, 0x10,
+	0x20, 0x00, 0x00,
+	0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x04,
+	0x02,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10,
+	0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x38, 0x44, 0x82, 0x82, 0x04, 0x08, 0x10, 0x10,
+	0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x99, 0xA5, 0xA5, 0xA5,
+	0x9E, 0x80, 0x41, 0x3E, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x18, 0x24, 0x42, 0x81, 0x81, 0xFF,
+	0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFC, 0x42, 0x41, 0x41, 0x42,
+	0x7C, 0x42, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x81,
+	0x80, 0x80, 0x80, 0x80, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFC, 0x42, 0x41,
+	0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0xFF, 0x80,
+	0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0xFF,
+	0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x3C, 0x42, 0x81, 0x81, 0x80, 0x9F, 0x81, 0x81, 0x81, 0x42, 0x3C,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81,
+	0x81, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x38, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+	0x38, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x07, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x44,
+	0x38, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x81, 0x82, 0x84, 0x88, 0x90, 0xE0, 0x90, 0x88, 0x84, 0x82,
+	0x81,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+	0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x81, 0xC3, 0xA5, 0x99, 0x99, 0x81, 0x81, 0x81, 0x81,
+	0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x81, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x81,
+	0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81,
+	0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC,
+	0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81, 0x81, 0x81,
+	0x81, 0x81, 0x89, 0x85, 0x42, 0x3D, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFC, 0x82, 0x81, 0x81,
+	0x82, 0xFC, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x42, 0x81,
+	0x80, 0x40, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0xFE, 0x92,
+	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x81,
+	0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x99, 0x99, 0xA5, 0xA5,
+	0x42, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x81,
+	0x81, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x82, 0x82, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10,
+	0x10, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x01, 0x01, 0x02, 0x04, 0x18, 0x20, 0x40, 0x80, 0x80,
+	0xFF,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+	0x7E, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
+	0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+	0x02, 0x02, 0x7E, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x08, 0x04, 0x02, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x7C, 0x02, 0x02, 0x7E, 0x82, 0x82, 0x7D, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x80, 0x80, 0x80,
+	0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x42, 0x3C, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x01,
+	0x01, 0x01, 0x01, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0xFF, 0x80, 0x40, 0x3E,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x0E, 0x11, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10,
+	0x10, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x43, 0x3D,
+	0x01, 0x02, 0x7C,
+	0x00, 0x00,
+	0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x81,
+	0x81, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x08, 0x08, 0x00, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08,
+	0x3E,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x02, 0x02, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02,
+	0x82, 0x44, 0x38, 0x00, 0x00,
+	0x00, 0x80, 0x80, 0x80, 0x80, 0x82, 0x84, 0x88, 0x90, 0xA8,
+	0xC4, 0x82, 0x00, 0x00, 0x00, 0x00,
+	0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+	0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92,
+	0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0xC4,
+	0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3C,
+	0x42, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x80, 0x80, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x00,
+	0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0xBE, 0xC1, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x7E, 0x81, 0x80, 0x7E, 0x01, 0x81, 0x7E, 0x00,
+	0x00, 0x00, 0x00,
+	0x10,
+	0x10, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x11, 0x0E,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x43,
+	0x3D, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x42, 0x24,
+	0x18, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x92, 0xAA,
+	0x44, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42,
+	0x81,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D,
+	0x01, 0x02, 0x7C, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x02, 0x04, 0x18, 0x20,
+	0x40, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x04, 0x08, 0x10, 0x10, 0x10, 0x20, 0x10, 0x10,
+	0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10,
+	0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x40, 0x20, 0x10, 0x10, 0x10, 0x08,
+	0x10, 0x10, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x70, 0x99, 0x0E, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x08,
+	0x1C, 0x36, 0x63, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x1E, 0x33,
+	0x61, 0x60, 0x60, 0x61, 0x33, 0x1E, 0x06, 0x03, 0x3E, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x66,
+	0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x06,
+	0x0C, 0x18, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x08, 0x1C, 0x36, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x66, 0x66, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x1C, 0x36, 0x1C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x0C, 0x06,
+	0x3C,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x66, 0x66, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63,
+	0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x7F, 0x60,
+	0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x66, 0x66, 0x00, 0x38, 0x18, 0x18,
+	0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x18, 0x3C, 0x66, 0x00, 0x38, 0x18,
+	0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x60, 0x30, 0x18, 0x00, 0x38,
+	0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x63, 0x63, 0x08, 0x1C,
+	0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x1C, 0x36, 0x1C, 0x00,
+	0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x0C, 0x18, 0x30,
+	0x00, 0x7F, 0x33, 0x30, 0x3E, 0x30, 0x33, 0x7F, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x6E, 0x3B, 0x1B, 0x7E, 0xD8, 0xDC, 0x77, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x1F, 0x36, 0x66, 0x66, 0x7F, 0x66, 0x66, 0x66, 0x67, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x63, 0x63, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x18, 0x3C, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x30, 0x18, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x3F,
+	0x03, 0x06, 0x3C, 0x00, 0x00, 0x00,
+	0x00, 0x63, 0x63, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x63,
+	0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63,
+	0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x18, 0x18, 0x7E, 0xC3, 0xC0, 0xC0,
+	0xC3, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x1C, 0x36, 0x32, 0x30, 0x78,
+	0x30, 0x30, 0x30, 0x73, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0xC3, 0x66, 0x3C,
+	0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFC, 0x66, 0x66,
+	0x7C, 0x62, 0x66, 0x6F, 0x66, 0x66, 0xF3, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x0E, 0x1B,
+	0x18, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0xD8, 0x70, 0x00,
+	0x00, 0x00,
+	0x00, 0x0C,
+	0x18, 0x30, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x0C, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x0C, 0x18, 0x30, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x0C, 0x18, 0x30, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x3B, 0x6E, 0x00, 0x6E, 0x33, 0x33, 0x33, 0x33, 0x33,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x3B, 0x6E, 0x00, 0x63, 0x73, 0x7B, 0x7F, 0x6F, 0x67, 0x63, 0x63,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x63,
+	0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x60,
+	0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F,
+	0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C,
+	0x18, 0x30, 0x6E, 0xC3, 0x06, 0x0C, 0x1F, 0x00, 0x00, 0x00,
+	0x00, 0x60, 0xE0, 0x63, 0x66,
+	0x6C, 0x18, 0x33, 0x67, 0xCF, 0x1F, 0x03, 0x03, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x18,
+	0x00, 0x18, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x1B, 0x36, 0x6C, 0x36, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x6C, 0x36, 0x1B, 0x36, 0x6C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x11,
+	0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44,
+	0x11, 0x44, 0x00, 0x00,
+
+	0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55,
+	0xAA, 0x55, 0xAA, 0x00,
+	0x00,
+	0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD,
+	0x77, 0xDD, 0x77,
+	0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18,
+	0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18,
+	0x18,
+	0x18, 0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0xF8,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06,
+	0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36,
+	0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x36, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x18, 0x18,
+	0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x00, 0x00,
+
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18,
+	0x18, 0x18,
+	0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18,
+	0x18,
+	0x18, 0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30,
+	0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+	0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36,
+	0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00,
+	0x00,
+	0x36, 0x36, 0x36,
+	0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x36,
+	0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x36, 0x00, 0x00,
+
+	0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18,
+	0x18, 0x18,
+	0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36,
+	0x36,
+	0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+	0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0xFF,
+	0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00,
+	0x00,
+	0xFF, 0xFF, 0xFF,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xFF, 0x00, 0x00,
+	0xF0,
+	0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
+	0xF0, 0xF0, 0x00, 0x00,
+
+	0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
+	0x0F, 0x0F, 0x0F, 0x00,
+	0x00,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x6C, 0x6C, 0x6E, 0x3B,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3E, 0x63, 0x7E, 0x63, 0x63, 0x7E, 0x60,
+	0x60,
+	0x20, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7F, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x7F, 0x36, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7F, 0x63, 0x30, 0x18, 0x0C, 0x18, 0x30,
+	0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x6C, 0x6C,
+	0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33,
+	0x33, 0x3E, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E,
+	0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7E, 0x18, 0x3C,
+	0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x1C, 0x36,
+	0x63, 0x63, 0x7F, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x1C,
+	0x36, 0x63, 0x63, 0x63, 0x36, 0x36, 0x36, 0x77, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x1E, 0x30, 0x18, 0x0C, 0x3E, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0x00, 0x03, 0x06, 0x7E, 0xDB, 0xDB, 0xF3, 0x7E, 0x60, 0xC0,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x1C, 0x30, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x30, 0x1C,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x00, 0xFF,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00,
+	0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C,
+	0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
+	0xFF, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3B,
+	0x6E, 0x00, 0x3B, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x38, 0x6C, 0x6C,
+	0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00,
+	0x0F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x1C, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+
+	0x00, 0xD8, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x70, 0xD8, 0x30, 0x60, 0xC8, 0xF8, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x00,
+	0x00, 0x00,
+	0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00,
+	0x00, 0x00, 0x00, 0x00
+};

lib/VGA/8x8fnt.c

@@ -0,0 +1,336 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+/* Police de caractère fine 8x8 */
+static u8 font8x8[2048] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0xA5,
+	0x81,
+	0xBD, 0x99, 0x81, 0x7E,
+	0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x6C, 0xFE, 0xFE,
+	0xFE, 0x7C, 0x38, 0x10, 0x00,
+	0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x38, 0x7C,
+	0x38, 0xFE, 0xFE, 0x7C, 0x38, 0x7C,
+	0x10, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x7C, 0x00,
+	0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00,
+	0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF,
+	0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00,
+	0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3,
+	0xFF, 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78,
+	0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18,
+	0x7E, 0x18, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x70, 0xF0, 0xE0,
+	0x7F, 0x63, 0x7F, 0x63, 0x63,
+	0x67, 0xE6, 0xC0, 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99,
+	0x80, 0xE0, 0xF8, 0xFE,
+	0xF8, 0xE0, 0x80, 0x00, 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02,
+	0x00,
+	0x18, 0x3C, 0x7E,
+	0x18, 0x18, 0x7E, 0x3C, 0x18, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,
+	0x66, 0x00,
+	0x7F, 0xDB,
+	0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00, 0x3E, 0x63, 0x38, 0x6C, 0x6C,
+	0x38, 0xCC, 0x78,
+	0x00,
+	0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, 0x18, 0x3C, 0x7E, 0x18,
+	0x7E, 0x3C, 0x18, 0xFF,
+
+	0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18,
+	0x18, 0x7E, 0x3C, 0x18,
+	0x00,
+	0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60,
+	0xFE, 0x60, 0x30,
+	0x00, 0x00,
+	0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, 0x00, 0x24, 0x66,
+	0xFF, 0x66,
+	0x24, 0x00, 0x00,
+	0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+	0x7E,
+	0x3C, 0x18, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40,
+	0x40, 0x40, 0x00, 0x40, 0x00,
+	0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x50,
+	0xF8, 0x50, 0xF8, 0x50, 0x50, 0x00,
+	0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 0x00, 0xC8,
+	0xC8, 0x10, 0x20, 0x40, 0x98, 0x98, 0x00,
+	0x70, 0x88, 0x50, 0x20, 0x54, 0x88, 0x74, 0x00,
+	0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x20, 0x40, 0x80, 0x80, 0x80, 0x40, 0x20,
+	0x00, 0x20, 0x10, 0x08, 0x08, 0x08, 0x10, 0x20, 0x00,
+	0x00, 0x20, 0xA8, 0x70, 0x70, 0xA8,
+	0x20, 0x00, 0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00,
+	0x00, 0x60, 0x60, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+	0x00,
+	0x70, 0x88, 0x98,
+	0xA8, 0xC8, 0x88, 0x70, 0x00, 0x40, 0xC0, 0x40, 0x40, 0x40, 0x40,
+	0xE0, 0x00,
+	0x70, 0x88,
+	0x08, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x70, 0x88, 0x08, 0x10, 0x08,
+	0x88, 0x70, 0x00,
+	0x08,
+	0x18, 0x28, 0x48, 0xFC, 0x08, 0x08, 0x00, 0xF8, 0x80, 0x80, 0xF0,
+	0x08, 0x88, 0x70, 0x00,
+
+	0x20, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 0x00, 0xF8, 0x08, 0x10,
+	0x20, 0x40, 0x40, 0x40,
+	0x00,
+	0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 0x00, 0x70, 0x88, 0x88,
+	0x78, 0x08, 0x08,
+	0x70, 0x00,
+	0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x60,
+	0x60, 0x00,
+	0x60, 0x60, 0x20,
+	0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0xF8,
+	0x00,
+	0xF8, 0x00, 0x00, 0x00,
+	0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 0x00, 0x78, 0x84, 0x04,
+	0x08, 0x10, 0x00, 0x10, 0x00,
+	0x70, 0x88, 0x88, 0xA8, 0xB8, 0x80, 0x78, 0x00, 0x20, 0x50,
+	0x88, 0x88, 0xF8, 0x88, 0x88, 0x00,
+	0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 0x00, 0x70,
+	0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 0x00,
+	0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0x00,
+	0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0xF8, 0x00,
+	0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0x80,
+	0x00, 0x70, 0x88, 0x80, 0x80, 0x98, 0x88, 0x78, 0x00,
+	0x88, 0x88, 0x88, 0xF8, 0x88, 0x88,
+	0x88, 0x00, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00,
+	0x38, 0x10, 0x10, 0x10, 0x10,
+	0x90, 0x60, 0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 0x00,
+	0x80, 0x80, 0x80, 0x80,
+	0x80, 0x80, 0xF8, 0x00, 0x82, 0xC6, 0xAA, 0x92, 0x82, 0x82, 0x82,
+	0x00,
+	0x84, 0xC4, 0xA4,
+	0x94, 0x8C, 0x84, 0x84, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88,
+	0x70, 0x00,
+	0xF0, 0x88,
+	0x88, 0xF0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x88, 0x88, 0xA8,
+	0x90, 0x68, 0x00,
+	0xF0,
+	0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 0x00, 0x70, 0x88, 0x80, 0x70,
+	0x08, 0x88, 0x70, 0x00,
+
+	0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x88, 0x88, 0x88,
+	0x88, 0x88, 0x88, 0x70,
+	0x00,
+	0x88, 0x88, 0x88, 0x50, 0x50, 0x20, 0x20, 0x00, 0x82, 0x82, 0x82,
+	0x82, 0x92, 0x92,
+	0x6C, 0x00,
+	0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 0x00, 0x88, 0x88, 0x88,
+	0x50, 0x20,
+	0x20, 0x20, 0x00,
+	0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 0x00, 0xE0, 0x80, 0x80,
+	0x80,
+	0x80, 0x80, 0xE0, 0x00,
+	0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0xE0, 0x20, 0x20,
+	0x20, 0x20, 0x20, 0xE0, 0x00,
+	0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0xF8, 0x00,
+	0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x70, 0x08, 0x78, 0x88, 0x74, 0x00,
+	0x80, 0x80, 0xB0, 0xC8, 0x88, 0xC8, 0xB0, 0x00,
+	0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 0x00,
+	0x08, 0x08, 0x68, 0x98, 0x88, 0x98, 0x68,
+	0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x70, 0x00,
+	0x30, 0x48, 0x40, 0xE0, 0x40, 0x40,
+	0x40, 0x00, 0x00, 0x00, 0x34, 0x48, 0x48, 0x38, 0x08, 0x30,
+	0x80, 0x80, 0xB0, 0xC8, 0x88,
+	0x88, 0x88, 0x00, 0x20, 0x00, 0x60, 0x20, 0x20, 0x20, 0x70, 0x00,
+	0x10, 0x00, 0x30, 0x10,
+	0x10, 0x10, 0x90, 0x60, 0x80, 0x80, 0x88, 0x90, 0xA0, 0xD0, 0x88,
+	0x00,
+	0xC0, 0x40, 0x40,
+	0x40, 0x40, 0x40, 0xE0, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92,
+	0x92, 0x00,
+	0x00, 0x00,
+	0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x70, 0x88, 0x88,
+	0x88, 0x70, 0x00,
+	0x00,
+	0x00, 0xB0, 0xC8, 0xC8, 0xB0, 0x80, 0x80, 0x00, 0x00, 0x68, 0x98,
+	0x98, 0x68, 0x08, 0x08,
+
+	0x00, 0x00, 0xB0, 0xC8, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x78,
+	0x80, 0x70, 0x08, 0xF0,
+	0x00,
+	0x40, 0x40, 0xE0, 0x40, 0x40, 0x50, 0x20, 0x00, 0x00, 0x00, 0x88,
+	0x88, 0x88, 0x98,
+	0x68, 0x00,
+	0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x00, 0x00, 0x00, 0x82,
+	0x82, 0x92,
+	0x92, 0x6C, 0x00,
+	0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x88,
+	0x88,
+	0x98, 0x68, 0x08, 0x70,
+	0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x10, 0x20, 0x20,
+	0x40, 0x20, 0x20, 0x10, 0x00,
+	0x40, 0x40, 0x40, 0x00, 0x40, 0x40, 0x40, 0x00, 0x40, 0x20,
+	0x20, 0x10, 0x20, 0x20, 0x40, 0x00,
+	0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00,
+	0x3E, 0x60, 0xC0, 0x60, 0x3E, 0x08, 0x04, 0x18,
+	0x00, 0x48, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
+	0x18, 0x20, 0x00, 0x78, 0xCC, 0xFC, 0xC0,
+	0x78, 0x10, 0x28, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
+	0x00, 0x48, 0x00, 0x78, 0x0C, 0x7C,
+	0xCC, 0x76, 0x30, 0x08, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
+	0x48, 0x30, 0x00, 0x78, 0x0C,
+	0x7C, 0xCC, 0x76, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x10, 0x08, 0x30,
+	0x30, 0x48, 0x84, 0x78,
+	0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x78, 0xCC, 0xFC, 0xC0,
+	0x78,
+	0x30, 0x08, 0x00,
+	0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x30, 0x30, 0x30,
+	0x30, 0x30,
+	0x30, 0x48,
+	0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x60, 0x10, 0x00, 0x30, 0x30,
+	0x30, 0x30, 0x30,
+	0x48,
+	0x00, 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0x30, 0x48, 0x30, 0x48,
+	0x84, 0xFC, 0x84, 0x84,
+
+	0x18, 0x20, 0x00, 0xF8, 0x80, 0xF0, 0x80, 0xF8, 0x00, 0x00, 0x00,
+	0x66, 0x19, 0x77, 0x88,
+	0x77,
+	0x00, 0x00, 0x00, 0x0F, 0x14, 0x3E, 0x44, 0x87, 0x30, 0x48, 0x84,
+	0x78, 0xCC, 0xCC,
+	0xCC, 0x78,
+	0x00, 0x48, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x60, 0x10, 0x00,
+	0x78, 0xCC,
+	0xCC, 0xCC, 0x78,
+	0x30, 0x48, 0x84, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x60, 0x10, 0x00,
+	0xCC,
+	0xCC, 0xCC, 0xCC, 0x76,
+	0x48, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0x44, 0x00, 0x38,
+	0x6C, 0xC6, 0xC6, 0x6C, 0x38,
+	0x24, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x08,
+	0x1C, 0x28, 0x28, 0x1C, 0x08, 0x00,
+	0x1C, 0x22, 0x20, 0x70, 0x20, 0x22, 0x5C, 0x00, 0x44,
+	0x28, 0x10, 0x10, 0x38, 0x10, 0x38, 0x10,
+	0xF0, 0x88, 0x8A, 0xF7, 0x82, 0x82, 0x83, 0x00,
+	0x06, 0x08, 0x08, 0x3C, 0x10, 0x10, 0x60, 0x00,
+	0x18, 0x20, 0x00, 0x78, 0x0C, 0x7C, 0xCC,
+	0x76, 0x18, 0x20, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
+	0x18, 0x20, 0x00, 0x78, 0xCC, 0xCC,
+	0xCC, 0x78, 0x18, 0x20, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
+	0x80, 0x78, 0x04, 0xF8, 0xCC,
+	0xCC, 0xCC, 0xCC, 0x80, 0x7E, 0x01, 0xC6, 0xE6, 0xD6, 0xCE, 0xC6,
+	0x00, 0x78, 0x0C, 0x7C,
+	0xCC, 0x76, 0x00, 0xFE, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00,
+	0xFC,
+	0x00, 0x00, 0x18,
+	0x18, 0x30, 0x60, 0x66, 0x3C, 0xFF, 0x80, 0x80, 0x80, 0x00, 0x00,
+	0x00, 0x00,
+	0xFF, 0x01,
+	0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC4, 0x48, 0x50, 0x26,
+	0x49, 0x82, 0x07,
+	0x40,
+	0xC4, 0x48, 0x50, 0x26, 0x4A, 0x9F, 0x02, 0x00, 0x30, 0x00, 0x30,
+	0x30, 0x30, 0x30, 0x30,
+
+	0x00, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x00, 0x48, 0x24,
+	0x12, 0x09, 0x12, 0x24,
+	0x48,
+	0x49, 0x00, 0x92, 0x00, 0x49, 0x00, 0x92, 0x00, 0x6D, 0x00, 0xB6,
+	0x00, 0x6D, 0x00,
+	0xB6, 0x00,
+	0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0x10, 0x10, 0x10,
+	0x10, 0x10,
+	0x10, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+	0xF0,
+	0x10, 0xF0, 0x10, 0x10,
+	0x28, 0x28, 0x28, 0x28, 0xE8, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00,
+	0x00, 0xF8, 0x28, 0x28, 0x28,
+	0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x28, 0x28,
+	0x28, 0xE8, 0x08, 0xE8, 0x28, 0x28,
+	0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x00,
+	0x00, 0x00, 0xF8, 0x08, 0xE8, 0x28, 0x28,
+	0x28, 0x28, 0x28, 0xE8, 0x08, 0xF8, 0x00, 0x00,
+	0x28, 0x28, 0x28, 0x28, 0xF8, 0x00, 0x00, 0x00,
+	0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0x10, 0x1F, 0x00,
+	0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0xFF,
+	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10,
+	0x00, 0x00, 0x00, 0x00,
+	0xFF, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10,
+	0x10,
+	0x10, 0x10, 0x10,
+	0x1F, 0x10, 0x1F, 0x10, 0x10, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x28,
+	0x28, 0x28,
+	0x28, 0x28,
+	0x28, 0x2F, 0x20, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x20,
+	0x2F, 0x28, 0x28,
+	0x28,
+	0x28, 0x28, 0xEF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+	0x00, 0xEF, 0x28, 0x28,
+
+	0x28, 0x28, 0x28, 0x2F, 0x20, 0x2F, 0x28, 0x28, 0x00, 0x00, 0x00,
+	0xFF, 0x00, 0xFF, 0x00,
+	0x00,
+	0x28, 0x28, 0x28, 0xEF, 0x00, 0xEF, 0x28, 0x28, 0x10, 0x10, 0x10,
+	0xFF, 0x00, 0xFF,
+	0x00, 0x00,
+	0x28, 0x28, 0x28, 0x28, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xFF, 0x00,
+	0xFF, 0x10, 0x10,
+	0x00, 0x00, 0x00, 0x00, 0xFF, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+	0x28,
+	0x3F, 0x00, 0x00, 0x00,
+	0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x1F, 0x10, 0x1F, 0x10, 0x10,
+	0x00, 0x00, 0x00, 0x00, 0x3F, 0x28, 0x28, 0x28, 0x28, 0x28,
+	0x28, 0x28, 0xFF, 0x28, 0x28, 0x28,
+	0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+	0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
+	0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+	0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x02, 0x34,
+	0x4C, 0x4C, 0x32, 0x00, 0x5C, 0x22, 0x22, 0x3C, 0x44, 0x44, 0x78,
+	0x7E, 0x42, 0x42, 0x40,
+	0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x02, 0x7C, 0xA8, 0x28, 0x28,
+	0x44,
+	0x00, 0x7E, 0x61,
+	0x30, 0x18, 0x08, 0x10, 0x20, 0x00, 0x00, 0x08, 0x7F, 0x88, 0x88,
+	0x88, 0x70,
+	0x00, 0x00,
+	0x00, 0x22, 0x44, 0x44, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x7C, 0x10,
+	0x10, 0x10, 0x10,
+	0x00,
+	0x1C, 0x08, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x00, 0x38, 0x44,
+	0x44, 0x7C, 0x44, 0x44,
+
+	0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0x66, 0x24, 0x66, 0x0C, 0x10, 0x08,
+	0x1C, 0x22, 0x22, 0x22,
+	0x1C,
+	0x00, 0x00, 0x00, 0x00, 0x6C, 0x92, 0x92, 0x6C, 0x00, 0x01, 0x1A,
+	0x26, 0x2A, 0x32,
+	0x2C, 0x40,
+	0x00, 0x18, 0x20, 0x20, 0x30, 0x20, 0x20, 0x18, 0x00, 0x3C, 0x42,
+	0x42, 0x42,
+	0x42, 0x42, 0x42,
+	0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x08, 0x08,
+	0x3E,
+	0x08, 0x08, 0x00, 0x3E,
+	0x00, 0x10, 0x08, 0x04, 0x08, 0x10, 0x00, 0x3E, 0x00, 0x04, 0x08,
+	0x10, 0x08, 0x04, 0x00, 0x3E,
+	0x00, 0x06, 0x09, 0x09, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
+	0x08, 0x08, 0x08, 0x48, 0x48, 0x30,
+	0x00, 0x00, 0x08, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x00,
+	0x60, 0x92, 0x0C, 0x60, 0x92, 0x0C, 0x00,
+	0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x30, 0x78, 0x30, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+	0x00, 0x00, 0x03, 0x04, 0x04, 0xC8, 0x28, 0x10, 0x00,
+	0x00, 0x00, 0x00, 0x7C, 0x42, 0x42,
+	0x42, 0x00, 0x18, 0x24, 0x08, 0x10, 0x3C, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x3E, 0x3E,
+	0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};

lib/VGA/ansi.c

@@ -0,0 +1,33 @@
+static u8 ansilogo[] = "\
+\033[0m\033[1m\
+\xDA\033[0m\xC4\xC4\033[1;30m\xC4\033[0m\xC4\033[1;30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\033[37m \033[0;31mC\033[1;37m \033[31m\x4F\033[37m \033[33mS\033[37m  \033[36m2\033[37m \033[0;36m0\033[1;37m \033[34m0\033[37m \033[0;34m0\033[1;37m \033[0mV2.2.1\033[1m \033[30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xBF\r\n\
+\033[0m\xB3\033[77C\033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\xDB\xDB\xDB\xDB\xDF\033[0;36m\xDF\033[1m\xDF\xDB\033[0;36m\xDF\033[1m\xDF\033[0;36m\xDF\xDF\xDF\xDF\xDF\033[1;37m\xDC\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\xDC\033[0;36m\xDF\xDF\xDF\033[1;37m\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\033[0;36m\xDF\xDF\033[37m   \033[36m\xDF\xDF\033[1;37m\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\033[0m \033[36m\xDF\xDF\xDF\xDF\xDF\033[1m\xDF\033[0;36m\xDF\033[1m\xDB\xDF\033[0;36m\xDF\033[1m\xDF\xDB\xDB\xDB\xDB\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\xDB\xDF\033[0m\033[5C\033[1;36m\xFA    \033[37m\xDC\033[47m\xDF\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m  \033[1;36m  \033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[6C\033[1;36m\xDE    \xDF\xDB\xDB\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\033[0m\033[7C\033[1;36m\xFE   \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[47;37m\xDB\033[0m\xDB\xDB\033[1;47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[36m \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD  \033[0m \033[1;30m  \033[36m\xFE\033[0m\033[6C\033[1;36m\xDB\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDE\033[0m\033[10C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF  \033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\033[1;47;30m\xDC\033[40m\xDF\033[37m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m \033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[12C\033[1;36m\xDE\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xFE\033[0m\033[9C\033[1m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[6C\033[1m\xDF\033[0m\xDF\033[1;30m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\033[1;30m\xDB  \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m  \033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[30m\xDC\033[40m\xDF\xDF\033[0m\033[13C\033[1;36m\xFA\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[9C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\033[1;30m\xDB  \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m \033[1;30m \033[37m\xDC\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[16C\033[1;36m\xFE\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[6C\033[1m\xDC\033[0m\xDC\033[1;30m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[37m\xDC\033[47m\xDF\033[0m\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[17C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[14C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC  \033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\033[1;47;30m\xDE\033[40m\xDD\033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[16C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[15C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[37m\xDB\033[0m\xDB\033[1;47;30m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[15C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[16C\033[1m\xDF\033[47m\xDC\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\xDC\033[40m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m  \033[1;47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m\033[16C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[19C\033[1m\xDF\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\xDF\033[0m   \033[1m\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\033[0m\033[5C\033[1m\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\033[0m\033[18C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1;30m\xDC\xDC\033[0m\xDC\033[1;30m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m    \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m   \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m   \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m\033[14C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[19C\033[1;30m\xB1\xDB\033[37m\xDB\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1   \033[37m\xDB\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1   \033[37m\xDB\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1   \033[37m\xDB\xDB\xDB\033[0m\033[14C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1;30m\xB0\xB0\xB0\xB0\xB0 \xB0\xB2\033[47;37m\xB2\033[40m\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m  \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m\033[14C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1;30m\xB0\xB0\xB0\xB0\xB0\xB0 \xB1\033[47;37m\xB1\xB2\033[40m\xDB\033[0m \033[1;30m \033[47;37m\xB2\033[40m\xDB\xDB\033[30m\xB1  \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m  \033[47;37m\xB2\033[40m\xDB\xDB\033[30m\xB1  \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m \033[0m \033[1;47m\xB2\033[40m\xDB\xDB\033[30m\xB1  \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m \033[0m\033[13C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[20C\xDC\033[1;47m\xB0\xB1\xB2\033[0m \033[1;30m \033[47;37m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m  \033[47;37m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m \033[0m \033[1;47m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m \033[0m\033[13C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\xDC\033[1;47m\xB1\xB2\xB1\xB2\xDB\xB2\xB1\xB0\033[0m\xDF  \033[1;30m\xB0\033[47;37m\xB0\xB1\xB2\033[0m  \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[0m  \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\033[0m \033[1;47m\xB0\xB1\xB2\033[0m  \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[13C\033[1;47m\xB1\xB2\033[40m\xDB\033[30m\xB1\033[0m\033[6C\033[1;30m\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\033[0m \xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDD\033[0m\033[9C\033[1;47m\xB2\033[40m\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\xB0\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\033[0m \033[1;47;30m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\033[0m\033[9C\033[1m\xDB\xDB\xDB\033[30m\xDB\xB1\033[0m\033[8C\033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB  \033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB  \033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB\033[10C\033[1;36m\xDB\033[0m   \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\xDC\033[0m\033[9C\033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1;30m\xDF\033[0m\xDF\033[1;30m\xDF\xDF\xDF\033[0m   \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m   \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m   \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m\033[9C\033[1;36m\xDC\xDB\xDB\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m   \033[1;36m\xDB\xDB\xDB\xDC\033[0;36m\xDC\033[1m\xDC\xDC\033[0;36m\xDC\033[1m\xDC\033[0;36m\xDC\xDC\xDC\xDC\xDC\xDC\xDC\033[37m    \033[36m\xDC\xDC\xDC\033[37m\033[17C\033[36m\xDC\xDC\xDC\xDC\033[37m\033[13C\033[36m\xDC\xDC\xDC\033[1m\xDC\033[0;36m\xDC\033[1m\xDC\xDC\033[0;36m\xDC\033[1m\xDC\xDC\xDB\xDB\xDB\xDB\xDB\033[0m  \033[1;30m\xB3\r\n\
+\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[6C\033[1mF1-F8\033[30m Consoles virtuelles \033[37mF9\033[30m Debug \033[37mF10\033[30m Mode graphique \033[37mF11\033[30m Aide\033[0m\033[9C\033[1;30m\xB3\r\n\
+\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
+\xB3\033[0m   Developpe par \033[5;1;47mMrNop\033[0m\033[55C\xB3\r\n\
+\xC0\033[1;30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\033[0m\xC4\033[1;30m\xC4\033[0m\xC4\xC4\033[1m\xD9\033[0m\r\n\r\n";

lib/VGA/modes.c

@@ -0,0 +1,130 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+/* definition des registres de la carte VGA pour differents modes */
+
+static capabilities vgacapabilities[] = {
+	{0x00, 80, 25, false, 4, 0},
+	{0x01, 80, 50, false, 4, 0},
+	{0x80, 640, 480, true, 1, 0},
+	{0x81, 320, 200, true, 2, 0},
+	{0x82, 640, 480, true, 4, 0},
+	{0x83, 320, 200, true, 8, 0},
+	{0x84, 320, 400, true, 8, 0},
+	{0x85, 320, 480, true, 8, 0},
+	{0x86, 360, 480, true, 8, 0},
+	{0xFF, 000, 000, false, 0, 0},
+};
+
+
+static vgamode modes[] = {
+
+	/*80*25 16 couleurs mode 0x00 */
+	{{0x67},
+	 {0x03, 0x00, 0x03, 0x00, 0x02},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
+	  0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00,
+	  0x9C, 0x0E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A,
+	  0x3B,
+	  0x3C, 0x3D, 0x3E, 0x3F,
+	  0x0C, 0x00, 0x0F, 0x08, 0x00}},
+
+	/*80*50 16 couleurs mode 0x01 */
+	{{0x63},
+	 {0x03, 0x01, 0x03, 0x05, 0x02},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
+	  0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
+	  0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A,
+	  0x3B,
+	  0x3C, 0x3D, 0x3E, 0x3F,
+	  0x0C, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*640*480 n&b mode 0x80 */
+	{{0xE3},
+	 {0x03, 0x01, 0x0F, 0x00, 0x06},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
+	  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0xEA, 0x0C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
+	  0x3B,
+	  0x3C, 0x3D, 0x3E, 0x3F,
+	  0x01, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*320*200 4 couleurs mode 0x81 */
+	{{0x63},
+	 {0x03, 0x09, 0x03, 0x00, 0x02},
+	 {0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00,
+	  0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x9C, 0x0E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x02, 0x00, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
+	  0x3B,
+	  0x3C, 0x3D, 0x3E, 0x3F,
+	  0x01, 0x00, 0x03, 0x00, 0x00}},
+
+	/*640*480 16 couleurs mode 0x82 */
+	{{0xE3},
+	 {0x03, 0x01, 0x0F, 0x00, 0x06},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x53, 0x9F, 0x0B, 0x3E, 0x00,
+	  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0xE9, 0x8B, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
+	  0x3B,
+	  0x3C, 0x3D, 0x3E, 0x3F,
+	  0x01, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*320*200 256 couleurs RAPIDE mode 0x83 */
+	{{0x63},
+	 {0x03, 0x01, 0x0F, 0x00, 0x0E},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
+	  0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x9C, 0x0E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+	  0x0B,
+	  0x0C, 0x0D, 0x0E, 0x0F,
+	  0x41, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*320*400 256 couleurs mode 0x84 */
+	{{0x63},
+	 {0x03, 0x01, 0x0F, 0x00, 0x06},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
+	  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+	  0x0B,
+	  0x0C, 0x0D, 0x0E, 0x0F,
+	  0x41, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*320*480 256 couleurs mode 0x85 */
+	{{0xE3},
+	 {0x03, 0x01, 0x0F, 0x00, 0x06},
+	 {0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
+	  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0xEA, 0xAC, 0xDF, 0x28, 0x00, 0xE7, 0x06, 0xE3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+	  0x0B,
+	  0x0C, 0x0D, 0x0E, 0x0F,
+	  0x41, 0x00, 0x0F, 0x00, 0x00}},
+
+	/*360*480 256 couleurs mode 0x86 */
+	{{0xE7},
+	 {0x03, 0x01, 0x0F, 0x00, 0x06},
+	 {0x6B, 0x59, 0x5A, 0x8E, 0x5E, 0x8A, 0x0D, 0x3E, 0x00,
+	  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0xEA, 0xAC, 0xDF, 0x2D, 0x00, 0xE7, 0x06, 0xE3, 0xFF},
+	 {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
+	 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+	  0x0B,
+	  0x0C, 0x0D, 0x0E, 0x0F,
+	  0x41, 0x00, 0x0F, 0x00, 0x00}},
+};

lib/cpu.c

@@ -1,217 +1,337 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
 #include "cpu.h"
-#include "cpuid.h"
 #include "memory.h"
 #include "string.h"
+#include "asm.h"
+#include "gdt.h"
+#include "process.h"
 
+/* Technologies supportées */
 
-
-static u8 *msg[] =
-{
-  "mmx",
-  "mmx2",
-  "sse",
-  "sse2",
-  "sse3",
-  "fpu",  
-  "3dNow!",
-  "3dNow Extended!",
-  "HyperThreading",
-  "apic",
+static u8 *msg[] = {
+	"mmx",
+	"mmx2",
+	"sse",
+	"sse2",
+	"sse3",
+	"fpu",
+	"3dNow!",
+	"3dNow Extended!",
+	"HyperThreading",
+	"apic",
+	"64bits",
+	"syscall",
+	"msr",
+	"sse4a",
+	"vmx",
+	"sse41",
+	"sse42",
+	"apic2"
 };
 
-static u8 space[]=" ";
+static u8 space[] = " ";
 
-bool cansetflag (u32 flag)
+/******************************************************************************/
+/* Affiche une erreur CPU et fige l'ordinateur */
+
+void cpuerror(const u8 * src, const regs * dump, bool returnto)
 {
-u32 r1, r2;
-asm("pushfl\n"
-"popl %0\n"
-"movl %0, %1\n"
-"xorl %2, %0\n"
-"pushl %0\n"
-"popfl\n"
-"pushfl\n"
-"popl %0\n"
-"pushl %1\n"
-"popfl\n"
-: "=&r" (r1), "=&r" (r2)
-: "ir" (flag)
-);
-return ((r1 ^ r2) & flag) != 0;
+	process *aprocess=findcurrentprocess();
+	if (!aprocess->iskernel && !returnto)
+	{
+		printf("\033[31m*** ERREUR CPU, KILLING PROCESS %u : %s *** \r\n", aprocess->pid, src);
+		deleteprocess(aprocess->pid);
+	}
+	else
+		printf("\033[31m*** ERREUR CPU : %s *** \r\n", src);
+	if (dump != NULL)
+		show_cpu(dump);
+	print("<Appuyer une touche pour continuer>\033[0m\r\n");
+	sti();
+	waitascii();
+	if (!returnto)
+	{
+		print("Retour en force au SHELL\r\n");
+		initselectors(getinitretry());
+
+	}
 }
 
-void cpuid(u32 op, u32 *eax, u32 *ebx,u32 *ecx, u32 *edx)
+/******************************************************************************/
+/* Annule les FLAGs CPU */
+
+bool cansetflag(u32 flag)
 {
-	asm("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)	: "a" (op) : "cc");
+	u32     r1, r2;
+      asm("pushfl\n" "popl %0\n" "movl %0, %1\n" "xorl %2, %0\n" "pushl %0\n" "popfl\n" "pushfl\n" "popl %0\n" "pushl %1\n" "popfl\n": "=&r"(r1), "=&r"(r2):"ir"(flag));
+	return ((r1 ^ r2) & flag) != 0;
 }
 
-u8 getcpuinfos(cpuinfo *proc)
+/******************************************************************************/
+/* Lance l'instruction CPUID */
+
+void cpuid(u32 op, u32 * eax, u32 * ebx, u32 * ecx, u32 * edx)
 {
-u32 i,maxfunction,maxextended,unused,regeax,regebx,regecx,regedx;
-bool *boolean;
-      
-if (!cansetflag (0x00040000)) return 1; /*386 processor - no cpuid*/
-if (!cansetflag (0x00200000)) return 2; /*486 processor with no cpuid*/
-
-    cpuid(0, &maxfunction, &unused, &unused, &unused);
-    maxfunction &= 0xffff;
-    cpuid(0x80000000, &maxextended, &unused, &unused, &unused);
-    maxextended &= 0xffff;
-    if (maxfunction >= 1)
-    {
-         cpuid(1, &regeax, &regebx, &regecx, &regedx);
-         proc->stepping = (regeax & 0x0000000F); 
-         proc->models = ((regeax>>4) & 0x0000000F); 
-         proc->family = ((regeax>>8) & 0x0000000F); 
-         proc->types = ((regeax>>12) & 0x00000003); 
-         proc->emodels = ((regeax>>16) & 0x0000000F); 
-         proc->efamily = ((regeax>>20) & 0x000000FF); 
-                
-         proc->brandid = (regeax & 0xF); 
-         proc->linesize = ((regeax>>8) & 0xF); 
-         proc->count = ((regeax>>16) & 0xF); 
-         proc->apicid = ((regeax>>24) & 0xF); 
-                
-         proc->mmx=((regedx>>23) & 0x00000001);
-         proc->sse=((regedx>>25) & 0x00000001);
-         proc->sse2=((regedx>>26) & 0x00000001);
-         proc->sse3=(regecx & 0x00000001);
-         proc->fpu=(regedx & 0x00000001);
-         proc->htt=((regedx>>28) & 0x00000001);
-
-    }  
-    if (maxextended >= 1)
-    {
-         cpuid(0x80000001, &regeax, &regebx, &regecx, &regedx);    
-         proc->mmx2=((regedx>>22) & 0x00000001);        
-         proc->apic=((regedx>>9) & 0x00000001);         
-         proc->now3d=((regedx>>30) & 0x00000001);
-         proc->now3d2=((regedx>>31) & 0x00000001);         
-     } 
-     if (maxextended >= 4)
-     {
-         int i;
-         for(i=0;i<3;i++)
-         {
-            cpuid(0x80000002+i, &regeax, &regebx, &regecx, &regedx);    
-            memcpy(&regeax,&proc->detectedname[0+i*16],4,1); 
-            memcpy(&regebx,&proc->detectedname[4+i*16],4,1); 
-            memcpy(&regecx,&proc->detectedname[8+i*16],4,1); 
-            memcpy(&regedx,&proc->detectedname[12+i*16],4,1);   
-         }
-    }    
-    boolean=&proc->mmx;
-    i=0;
-
-    for(i=0;i<10;i++)
-        if (*(boolean++)==1) 
-        {
-            strcat(msg[i],&proc->techs); 
-            strcat(space,&proc->techs); 
-        }
-    return 0;
+      asm("cpuid": "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx): "a"(op):"cc");
 }
 
-u32 viewstack(u32 number)
+/******************************************************************************/
+/* Retourne les informations sur le CPU dans une structure cpuinfo */
+
+u8 getcpuinfos(cpuinfo * proc)
 {
- u32 stack = 0;
-  asm (
-         "movl %[a1],%%esi;"
-         "addl %%esp,%%esi;"
-         "movl (%%esi), %[a1] ;"
-         :[result] "=r" (stack)
-         :[a1] "r" (number)
-         :"%esi"
-         );
-    return stack;
+	u32     i, maxfunction, maxextended, unused, regeax, regebx,
+		regecx, regedx;
+	bool   *boolean;
+
+	if (!cansetflag(0x00040000))
+		return 1;	/*386 processor - no cpuid */
+	if (!cansetflag(0x00200000))
+		return 2;	/*486 processor with no cpuid */
+
+	cpuid(0, &maxfunction, &unused, &unused, &unused);
+	maxfunction &= 0xffff;
+	cpuid(0x80000000, &maxextended, &unused, &unused, &unused);
+	maxextended &= 0xffff;
+	if (maxfunction >= 1)
+	{
+		cpuid(1, &regeax, &regebx, &regecx, &regedx);
+		proc->stepping = (regeax & 0x0000000F);
+		proc->models = ((regeax >> 4) & 0x0000000F);
+		proc->family = ((regeax >> 8) & 0x0000000F);
+		proc->types = ((regeax >> 12) & 0x00000003);
+		proc->emodels = ((regeax >> 16) & 0x0000000F);
+		proc->efamily = ((regeax >> 20) & 0x000000FF);
+
+		proc->brandid = (regeax & 0xF);
+		proc->linesize = ((regeax >> 8) & 0xF);
+		proc->count = ((regeax >> 16) & 0xF);
+		proc->apicid = ((regeax >> 24) & 0xF);
+
+		proc->mmx = ((regedx >> 23) & 0x00000001);
+		proc->sse = ((regedx >> 25) & 0x00000001);
+		proc->sse2 = ((regedx >> 26) & 0x00000001);
+		proc->sse3 = (regecx & 0x00000001);
+		proc->fpu = (regedx & 0x00000001);
+		proc->htt = ((regedx >> 28) & 0x00000001);
+		proc->vmx = ((regecx >> 5) & 0x00000001);
+		proc->sse41 = ((regecx >> 19) & 0x00000001);
+		proc->sse42 = ((regecx >> 20) & 0x00000001);
+		proc->apic2 = ((regecx >> 21) & 0x00000001);
+	}
+	if (maxextended >= 1)
+	{
+		cpuid(0x80000001, &regeax, &regebx, &regecx, &regedx);
+		proc->mmx2 = ((regedx >> 22) & 0x00000001);
+		proc->apic = ((regedx >> 9) & 0x00000001);
+		proc->now3d = ((regedx >> 30) & 0x00000001);
+		proc->now3d2 = ((regedx >> 31) & 0x00000001);
+		proc->bits64 = ((regedx >> 29) & 0x00000001);
+		proc->syscall = ((regedx >> 11) & 0x00000001);
+		proc->msr = ((regedx >> 5) & 0x00000001);
+		proc->sse4a = ((regecx >> 6) & 0x00000001);
+	}
+	if (maxextended >= 4)
+	{
+		int     i;
+		for (i = 0; i < 3; i++)
+		{
+			cpuid(0x80000002 + i, &regeax, &regebx, &regecx,
+			      &regedx);
+			memcpy(&regeax, &proc->detectedname[0 + i * 16], 4,
+			       1);
+			memcpy(&regebx, &proc->detectedname[4 + i * 16], 4,
+			       1);
+			memcpy(&regecx, &proc->detectedname[8 + i * 16], 4,
+			       1);
+			memcpy(&regedx, &proc->detectedname[12 + i * 16],
+			       4, 1);
+		}
+	}
+	boolean = &proc->mmx;
+	i = 0;
+	proc->techs[0] = '\000';
+	for (i = 0; i < sizeof(msg); i++)
+		if (*(boolean++) == 1)
+		{
+			strcat(msg[i], &proc->techs);
+			strcat(space, &proc->techs);
+		}
+	return 0;
 }
 
-void dump_regs()
+/******************************************************************************/
+/* Affiche les registres CPU */
+
+void show_lightcpu(regs * stack)
 {
-  u32 eax = 0;
-  u32 ebx = 0;
-  u32 ecx = 0;
-  u32 edx = 0;
-  u32 esi = 0;
-  u32 edi = 0;
-  u32 ebp = 0;
-  u32 esp = 0;
-  u16 cs = 0;
-  u16 ds = 0;
-  u16 es = 0;
-  u16 fs = 0;
-  u16 gs = 0;
-  u16 ss = 0;
-  u32 flags = 0;
-  asm (
-         "movl %%eax, %[a1] ;"
-         "movl %%ebx, %[b1] ;"
-         "movl %%ecx, %[c1] ;"
-         "movl %%edx, %[d1] ;"
-         "movl %%esi, %[e1] ;"
-         "movl %%edi, %[f1] ;"
-         "movl %%esp, %[g1] ;"
-         "movl %%ebp, %[h1] ;"
-         "movw %%cs, %[i1] ;"
-         "movw %%ds, %[j1] ;"
-         "movw %%es, %[k1] ;"
-         "movw %%fs, %[l1] ;"
-         "movw %%gs, %[m1] ;"
-         "movw %%ss, %[n1] ;"
-         :
-         [a1] "=m" (eax), [b1] "=m" (ebx), [c1] "=m" (ecx), [d1] "=m" (edx), [e1] "=m" (esi), [f1] "=m" (edi), 
-         [g1] "=m" (ebp), [h1] "=m" (esp), [i1] "=m" (cs), [j1] "=m" (ds), [k1] "=m" (es), [l1] "=m" (fs), [m1] "=m" (gs), [n1] "=m" (ss)
-         );
-
-    printf("eax=%x      ebx=%x         ecx=%x        eax=%x\r\n", eax,ebx,ecx,edx);
-    printf("esi=%x      edi=%x\r\n", esi,edi);
-    printf("cs=%x       ds=%x          es=%x         fs=%x       gs=%x\r\n", cs,ds,es,fs,gs);
-    printf("ss=%x       esp=%x         ebp=%x\r\n",ss,esp,ebp);
-
-    asm (
-         "pushf      ;"
-         "pop %[f1] ;"
-         :
-         [f1] "=m" (flags)
-         );
-
-    printf("FLAGS");
-
-    if(flags & (1 << 0)) // Carry
-        printf(" (C1"); 
-    else
-        printf(" (C0");
-
-    if(flags & (1 << 2)) // Parity
-        printf(" P1");
-    else
-        printf(" P0");
-
-    if(flags & (1 << 4)) // Adjust
-        printf(" A1");
-    else
-        printf(" A0");
-
-    if(flags & (1 << 6)) // Zero
-        printf(" Z1");
-    else
-        printf(" Z0");
-
-    if(flags & (1 << 7)) // Sign
-        printf(" S1");
-    else
-        printf(" S0");
-
-    if(flags & (1 << 11)) // Overflow
-        printf(" O1)\n");
-    else
-        printf(" O0)\n");
-
-  printf("STACK\r\n");
-  for(u8 i=0;i<25;i++)
-        printf("+%d\t\t%x\r\n",i,viewstack(i*4));
+	u32     i;
+	printf("\33[0mEAX=%Y EBX=%Y ECX=%Y EDX=%Y\r\n", stack->eax,
+	       stack->ebx, stack->ecx, stack->edx);
+	printf("ESI=%Y EDI=%Y ESP=%Y EBP=%Y\r\n", stack->esi, stack->edi,
+	       stack->esp, stack->ebp);
+	printf("EIP=%Y EFL=%Y [%c%c%c%c%c%c%c%c%c]\r\n", stack->eip,
+	       stack->eflags, (stack->eflags & (1 << 11)) ? 'O' : '-',
+	       (stack->eflags & (1 << 10)) ? 'D' : '-',
+	       (stack->eflags & (1 << 9)) ? 'I' : '-',
+	       (stack->eflags & (1 << 8)) ? 'T' : '-',
+	       (stack->eflags & (1 << 7)) ? 'S' : '-',
+	       (stack->eflags & (1 << 6)) ? 'Z' : '-',
+	       (stack->eflags & (1 << 4)) ? 'A' : '-',
+	       (stack->eflags & (1 << 2)) ? 'P' : '-',
+	       (stack->eflags & (1 << 0)) ? 'C' : '-');
+	printf("CS =%hY DS =%hY SS =%hY ES =%hY FS =%hY GS =%hY\r\n",
+	       stack->cs, stack->ds, stack->ss, stack->es, stack->fs,
+	       stack->gs);
+	printf("CR0=%Y CR2=%Y CR3=%Y CR4=%Y\r\n\r\n\r\n", stack->cr0,
+	       stack->cr2, stack->cr3, stack->cr4);
 
+	u8     *size;
+	u8     *pointer;
+	for (i = 20; i < 50; i++)
+	{
+		pointer = stack->eip - i;
+		size = pointer;
+		size += 50;
+		while (pointer < size)
+		{
+			pointer += disasm(pointer, NULL, false);
+			if (pointer == stack->eip)
+				break;
+		}
+		if (pointer == stack->eip)
+			break;
+	}
+	if (pointer == stack->eip)
+		pointer = stack->eip - i;
+	else
+		pointer = stack->eip;
+	size = pointer;
+	size += 50;
+	while (pointer < size)
+	{
+		if (pointer == stack->eip)
+			print("\33[41m\33[1m");
+		else
+			print("\33[40m\33[0m");
+		pointer += disasm(pointer, NULL, true);
+	}
 
+	printf("\33[0m\r\n\r\n\r\nSTACK\r\n");
+	if (abs(KERNEL_STACK_ADDR - stack->esp) > 0x10000)
+		printf("Pile invalide !");
+	else
+	{
+		i = 0;
+		for (u32 * pointer = stack->esp;
+		     pointer < KERNEL_STACK_ADDR; pointer++)
+		{
+			if (i > 0 && i % 10 == 0)
+				print("\033[10A");
+			if (i >= 10)
+				print("\033[25C");
+			printf("+%d:%Y - %Y\r\n", i++, pointer,
+			       (u32) (*pointer));
+		}
+		for (u32 j = 0; j < 10 - (i % 10); j++)
+			print("\033[01B");
+	}
 }
 
+/******************************************************************************/
+/* Affiche les registres CPU */
+
+void show_cpu(regs * stack)
+{
+	printf("EAX=%Y EBX=%Y ECX=%Y EDX=%Y\r\n", stack->eax, stack->ebx,
+	       stack->ecx, stack->edx);
+	printf("ESI=%Y EDI=%Y ESP=%Y EBP=%Y\r\n", stack->esi, stack->edi,
+	       stack->esp, stack->ebp);
+	printf("EIP=%Y EFL=%Y [%c%c%c%c%c%c%c%c%c]\r\n", stack->eip,
+	       stack->eflags, (stack->eflags & (1 << 11)) ? 'O' : '-',
+	       (stack->eflags & (1 << 10)) ? 'D' : '-',
+	       (stack->eflags & (1 << 9)) ? 'I' : '-',
+	       (stack->eflags & (1 << 8)) ? 'T' : '-',
+	       (stack->eflags & (1 << 7)) ? 'S' : '-',
+	       (stack->eflags & (1 << 6)) ? 'Z' : '-',
+	       (stack->eflags & (1 << 4)) ? 'A' : '-',
+	       (stack->eflags & (1 << 2)) ? 'P' : '-',
+	       (stack->eflags & (1 << 0)) ? 'C' : '-');
+	printf("CS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->cs,
+	       getdesbase(stack->cs), getdeslimit(stack->cs),
+	       getdesdpl(stack->cs), getdestype(stack->cs),
+	       getdessize(stack->cs), getdesbit3(stack->cs),
+	       getdesbit2(stack->cs), getdesbit1(stack->cs),
+	       getdesalign(stack->cs));
+	printf("DS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->ds,
+	       getdesbase(stack->ds), getdeslimit(stack->ds),
+	       getdesdpl(stack->ds), getdestype(stack->ds),
+	       getdessize(stack->ds), getdesbit3(stack->ds),
+	       getdesbit2(stack->ds), getdesbit1(stack->ds),
+	       getdesalign(stack->ds));
+	printf("SS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->ss,
+	       getdesbase(stack->ss), getdeslimit(stack->ss),
+	       getdesdpl(stack->ss), getdestype(stack->ss),
+	       getdessize(stack->ss), getdesbit3(stack->ss),
+	       getdesbit2(stack->ss), getdesbit1(stack->ss),
+	       getdesalign(stack->ss));
+	printf("ES =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->es,
+	       getdesbase(stack->es), getdeslimit(stack->es),
+	       getdesdpl(stack->es), getdestype(stack->es),
+	       getdessize(stack->es), getdesbit3(stack->es),
+	       getdesbit2(stack->es), getdesbit1(stack->es),
+	       getdesalign(stack->es));
+	printf("FS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->fs,
+	       getdesbase(stack->fs), getdeslimit(stack->fs),
+	       getdesdpl(stack->fs), getdestype(stack->fs),
+	       getdessize(stack->fs), getdesbit3(stack->fs),
+	       getdesbit2(stack->fs), getdesbit1(stack->fs),
+	       getdesalign(stack->fs));
+	printf("GS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->gs,
+	       getdesbase(stack->gs), getdeslimit(stack->gs),
+	       getdesdpl(stack->gs), getdestype(stack->gs),
+	       getdessize(stack->gs), getdesbit3(stack->gs),
+	       getdesbit2(stack->gs), getdesbit1(stack->gs),
+	       getdesalign(stack->gs));
+	u32     tss;
+	str(tss);
+	printf("TR =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->gs,
+	       getdesbase(tss), getdeslimit(tss), getdesdpl(tss),
+	       getdestype(tss), getdessize(tss), getdesbit3(tss),
+	       getdesbit2(tss), getdesbit1(tss), getdesalign(tss));
+	struct gdtr gdtreg;
+	sgdt(gdtreg);
+	printf("GDT=     %Y %Y\r\n", gdtreg.base, gdtreg.limite);
+	struct idtr idtreg;
+	sidt(idtreg);
+	printf("IDT=     %Y %Y\r\n", idtreg.base, idtreg.limite);
+	printf("CR0=%Y CR2=%Y CR3=%Y CR4=%Y\r\n", stack->cr0, stack->cr2,
+	       stack->cr3, stack->cr4);
+	printf("DR0=%Y DR1=%Y DR2=%Y DR3=%Y\r\n", stack->dr0, stack->dr1,
+	       stack->dr2, stack->dr3);
+	printf("DR6=%Y DR7=%Y\r\n", stack->dr6, stack->dr7);
+	printf("EFER=%lY\r\n", stack->efer);
+	printf("STACK\r\n");
+	if (abs(KERNEL_STACK_ADDR - stack->esp) > 0x10000)
+		printf("Pile invalide !");
+	else
+	{
+		u32     i = 0;
+		for (u32 * pointer = stack->esp;
+		     pointer < KERNEL_STACK_ADDR; pointer++)
+		{
+			if (i > 0 && i % 10 == 0)
+				print("\033[10A");
+			if (i >= 10)
+				print("\033[25C");
+			printf("+%d:%Y - %Y\r\n", i++, pointer,
+			       (u32) (*pointer));
+		}
+		for (u32 j = 0; j < 10 - (i % 10); j++)
+			print("\033[01B");
+	}
+}
+/*******************************************************************************/

lib/cramfs.c

@@ -0,0 +1,325 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+/* Quelques portions modifiée proviennent de cramfsck - check a cramfs file system
+ *
+ * Copyright (C) 2000-2002 Transmeta Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * 1999/12/03: Linus Torvalds    (cramfs tester and unarchive program)
+ * 2000/06/03: Daniel Quinlan    (CRC and length checking program)
+ * 2000/06/04: Daniel Quinlan    (merged programs, added options, support
+ *                               for special files, preserve permissions and
+ *                               ownership, cramfs superblock v2, bogus mode
+ *                               test, pathname length test, etc.)
+ * 2000/06/06: Daniel Quinlan    (support for holes, pretty-printing,
+ *                               symlink size test)
+ * 2000/07/11: Daniel Quinlan    (file length tests, start at offset 0 or 512,
+ *                               fsck-compatible exit codes)
+ * 2000/07/15: Daniel Quinlan    (initial support for block devices)
+ * 2002/01/10: Daniel Quinlan    (additional checks, test more return codes,
+ *                               use read if mmap fails, standardize messages)
+ * 2015/06/09: Yves-Noel Weweler (support for ignoring errors, when
+ *                               extracting obscure cramfs files) */
+
+#include "types.h"
+#include "cramfs.h"
+#include "boot.h"
+#include "memory.h"
+
+u8* initrambloc;
+u8 start;
+cramfs_super* super;
+extern bootparams* allparams;
+
+/*******************************************************************************/
+/* Copie l'initram CRAMFS vers un malloc */
+void remap_initram()
+{
+	virtual_range_use_kernel(allparams->ramdiskaddr, allparams->ramdiskaddr, allparams->ramdisksize, PAGE_NOFLAG);
+	initrambloc=vmalloc(allparams->ramdisksize);
+	memcpy(allparams->ramdiskaddr,initrambloc,allparams->ramdisksize,0);
+	virtual_range_free_kernel(allparams->ramdiskaddr,allparams->ramdisksize);
+}
+
+/*******************************************************************************/
+/* Lit l'inode et renvoie un pointeur grâce à vmalloc */
+
+cramfs_inode *cramfs_iget(cramfs_inode * i)
+{
+	cramfs_inode *inode = vmalloc(sizeof(cramfs_inode));
+	if (!inode) 
+		return NULL;
+	*inode = *i;
+	return inode;
+}
+
+/*******************************************************************************/
+/* Lit l'inode principal */
+
+cramfs_inode *read_super(void)
+{
+	u32 offset = super.root.offset << 2;
+
+	if (!S_ISDIR(super.root.mode))
+		return NULL; /* fichier */
+	if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && ((offset != sizeof(cramfs_super)) &&
+	     (offset != PAD_SIZE + sizeof(cramfs_super))))
+		return NULL ; /*offset erronée */
+	return cramfs_iget(&super.root);
+}
+
+
+
+static int uncompress_block(void *src, int len)
+{
+	int err;
+
+	stream.next_in = src;
+	stream.avail_in = len;
+
+	stream.next_out = (unsigned char *) outbuffer;
+	stream.avail_out = PAGE_CACHE_SIZE*2;
+
+	inflateReset(&stream);
+
+	if (len > PAGE_CACHE_SIZE*2) {
+		die(FSCK_UNCORRECTED, 0, "data block too large");
+	}
+	err = inflate(&stream, Z_FINISH);
+	if (err != Z_STREAM_END) {
+		die(FSCK_UNCORRECTED, 0, "decompression error %p(%d): %s",
+		    zError(err), src, len);
+	}
+	return stream.total_out;
+}
+
+static void do_uncompress(char *path, int fd, unsigned long offset, unsigned long size)
+{
+	unsigned long curr = offset + 4 * ((size + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE);
+
+	do {
+		unsigned long out = PAGE_CACHE_SIZE;
+		unsigned long next = *(u32 *) romfs_read(offset);
+
+		if (next > end_data) {
+			end_data = next;
+		}
+
+		offset += 4;
+		if (curr == next) {
+			if (opt_verbose > 1) {
+				printf("  hole at %ld (%d)\n", curr, PAGE_CACHE_SIZE);
+			}
+			if (size < PAGE_CACHE_SIZE)
+				out = size;
+			memset(outbuffer, 0x00, out);
+		}
+		else {
+			if (opt_verbose > 1) {
+				printf("  uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr);
+			}
+			out = uncompress_block(romfs_read(curr), next - curr);
+		}
+		if (size >= PAGE_CACHE_SIZE) {
+			if (out != PAGE_CACHE_SIZE) {
+				die(FSCK_UNCORRECTED, 0, "non-block (%ld) bytes", out);
+			}
+		} else {
+			if (out != size) {
+				die(FSCK_UNCORRECTED, 0, "non-size (%ld vs %ld) bytes", out, size);
+			}
+		}
+		size -= out;
+		if (opt_extract) {
+			if (write(fd, outbuffer, out) < 0) {
+				die(FSCK_ERROR, 1, "write failed: %s", path);
+			}
+		}
+		curr = next;
+	} while (size);
+}
+
+tatic void change_file_status(char *path, struct cramfs_inode *i)
+{
+	struct utimbuf epoch = { 0, 0 };
+
+	if (euid == 0) {
+		if (lchown(path, i->uid, i->gid) < 0) {
+			die(FSCK_ERROR, 1, "lchown failed: %s", path);
+		}
+		if (S_ISLNK(i->mode))
+			return;
+		if ((S_ISUID | S_ISGID) & i->mode) {
+			if (chmod(path, i->mode) < 0) {
+				die(FSCK_ERROR, 1, "chown failed: %s", path);
+			}
+		}
+	}
+	if (S_ISLNK(i->mode))
+		return;
+	if (utime(path, &epoch) < 0) {
+		die(FSCK_ERROR, 1, "utime failed: %s", path);
+	}
+}
+
+static void do_directory(char *path, struct cramfs_inode *i)
+{
+	int pathlen = strlen(path);
+	int count = i->size;
+	unsigned long offset = i->offset << 2;
+	char *newpath = malloc(pathlen + 256);
+
+	if (!newpath) {
+		die(FSCK_ERROR, 1, "malloc failed");
+	}
+	if (offset == 0 && count != 0) {
+		die(FSCK_UNCORRECTED, 0, "directory inode has zero offset and non-zero size: %s", path);
+	}
+	if (offset != 0 && offset < start_dir) {
+		start_dir = offset;
+	}
+	/* TODO: Do we need to check end_dir for empty case? */
+	memcpy(newpath, path, pathlen);
+	newpath[pathlen] = '/';
+	pathlen++;
+	if (opt_verbose) {
+		print_node('d', i, path);
+	}
+	if (opt_extract) {
+		if (mkdir(path, i->mode) < 0) {
+			die(FSCK_ERROR, 1, "mkdir failed: %s", path);
+		}
+		change_file_status(path, i);
+	}
+	while (count > 0) {
+		struct cramfs_inode *child = iget(offset);
+		int size;
+		int newlen = child->namelen << 2;
+
+		size = sizeof(struct cramfs_inode) + newlen;
+		count -= size;
+
+		offset += sizeof(struct cramfs_inode);
+
+		memcpy(newpath + pathlen, romfs_read(offset), newlen);
+		newpath[pathlen + newlen] = 0;
+		if (newlen == 0) {
+			die(FSCK_UNCORRECTED, 0, "filename length is zero");
+		}
+		if ((pathlen + newlen) - strlen(newpath) > 3) {
+			die(FSCK_UNCORRECTED, 0, "bad filename length");
+		}
+		expand_fs(newpath, child);
+
+		offset += newlen;
+
+		if (offset <= start_dir) {
+			die(FSCK_UNCORRECTED, 0, "bad inode offset");
+		}
+		if (offset > end_dir) {
+			end_dir = offset;
+		}
+		iput(child); /* free(child) */
+	}
+	free(newpath);
+}
+
+void do_file(u8 *path, cramfs_inode *i)
+{
+	u32 offset = i->offset << 2;
+	if (offset == 0 && i->size != 0)
+		return /*null de taille non nulle */
+	if (i->size == 0 && offset != 0) 
+		return /*non null de taille nulle */
+	if (offset != 0 && offset < start_data)
+		start_data = offset;
+	fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, i->mode);
+	if (i->size)
+	do_uncompress(path, fd, offset, i->size);
+	close(fd);
+	change_file_status(path, i);
+}
+
+void expand_fs(u8 *path, cramfs_inode *inode)
+{
+	if (S_ISDIR(inode->mode)) {
+		do_directory(path, inode);
+	}
+	else if (S_ISREG(inode->mode)) {
+		do_file(path, inode);
+	}
+	else if (S_ISLNK(inode->mode)) {
+		/*do_symlink(path, inode);*/
+	}
+	else {
+		/*do_special_inode(path, inode);*/
+	}
+}
+
+/*******************************************************************************/
+/* Vérification d'une image cramfs */
+/* ERREURS :
+/* 1=taille du super bloc trop petite */
+/* 2=pas de magic */
+/* 3=pas géré */
+/* 4=superbloc trop petit */
+/* 5=aucune fichier */
+/* 6=taille entrée des fichiers trop petite */
+/* 7=taille entrée des fichiers trop grande */
+/* 8=version de cramfs non supportée */
+/* 9=crc erroné */
+
+u32 test_super(u8 *src, u32 length) {
+	super=(cramfs_super*)src;
+	start = 0xFF;
+	if (length < sizeof(cramfs_super)) {
+		return 1;
+	}
+	if (super->magic == CRAMFS_MAGIC) {
+		start = 0;
+	}
+	else if (length >= (PAD_SIZE + sizeof(super))) {
+		if (super->magic == CRAMFS_MAGIC) {
+			start = PAD_SIZE; 
+		}
+	}
+	else
+		return 2;
+	if (super->flags & ~CRAMFS_SUPPORTED_FLAGS)
+		return 3;
+	if (super->size < PAGE_CACHE_SIZE)
+		return 4;
+	if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) {
+		if (super->fsid.files == 0) 
+			return 5;
+		if (length < super->size)
+			return 6;
+		else if (length > super->size)
+			return 7;
+	}
+	else
+		return 8;
+	u32 oldcrc=super->fsid.crc;
+	super->fsid.crc = crc32(0, 0, 0);
+	u32 newcrc=crc32(0,src+*start,super->size-*start);
+	super->fsid.crc = oldcrc; 
+	if (newcrc!=oldcrc)
+		return 9;
+	return NULL;
+}
+
+

lib/gdt.c

@@ -0,0 +1,240 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "gdt.h"
+#include "asm.h"
+#include "types.h"
+#include "memory.h"
+
+ /* registre gdt */
+static struct gdtr gdtreg;
+
+/* table de GDT */
+static gdtdes gdt[GDT_SIZE];
+
+/* TSS */
+static struct tss tss0;
+
+/*******************************************************************************/
+/* Créé un descripteur GDT */
+
+void makegdtdes(u32 base, u32 limite, u8 acces, u8 flags, gdtdes * desc)
+{
+	desc->lim0_15 = (limite & 0xffff);
+	desc->base0_15 = (base & 0xffff);
+	desc->base16_23 = (base & 0xff0000) >> 16;
+	desc->acces = acces;
+	desc->lim16_19 = (limite & 0xf0000) >> 16;
+	desc->flags = (flags & 0xf);
+	desc->base24_31 = (base & 0xff000000) >> 24;
+	return;
+}
+
+/*******************************************************************************/
+/* Initialise la GDT */
+
+void initgdt(u32 offset)
+{
+	makegdtdes(0x0, 0x00000, 0x00, 0x00, &gdt[0]);	/* descripteur nul         */
+	makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_CODE | SEG_RING0 | SEG_READ | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[1]);	/* code -> SEL_KERNEL_CODE */
+	makegdtdes(0x0, 0x00000, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING0 | SEG_EXPAND_DOWN | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[2]);	/* pile -> SEL_KERNEL_STACK */
+	makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_CODE | SEG_RING3 | SEG_CONFORMING | SEG_READ | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[3]);	/* code -> SEL_USER_CODE */
+	makegdtdes(0x0, 0x00000, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING3 | SEG_EXPAND_DOWN | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[4]);	/* pile -> SEL_USER_STACK */
+	makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING0 | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[5]);	/* data -> SEL_KERNEL_DATA */
+	makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING3 | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[6]);	/* data -> SEL_USER_DATA */
+
+	tss0.trapflag = 0x00;
+	tss0.iomap = 0x00;
+	tss0.esp0 = 0x6000;
+	tss0.ss0 = SEL_TSS;
+
+	makegdtdes(&tss0, 0x67, SEG_PRESENT | SEG_CODE | SEG_RING3 | SEG_ACCESSED, 0x00, &gdt[7]);	/* descripteur de tss */
+
+	/* initialise le registre gdt */
+	gdtreg.limite = GDT_SIZE * sizeof(gdtdes);
+	gdtreg.base = GDT_ADDR;
+	/* recopie de la GDT a son adresse */
+	memcpy(&gdt, (u8 *) gdtreg.base, gdtreg.limite, 1);
+	/* chargement du registre GDT */
+	lgdt(gdtreg);
+	/* initialisation des segments */
+	initselectors(offset);
+}
+
+/*******************************************************************************/
+/* Initialise les selecteurs avec la GDT */
+
+void initselectors(u32 executingoffset)
+{
+	asm("	movw %[data], %%ax	\n \
+            movw %%ax, %%ds	\n \
+            movw %%ax, %%es	\n \
+            movw %%ax, %%fs	\n \
+            movw %%ax, %%gs   \n \
+            movw %[stack], %%ax \n \
+            movl %[offset], %%ebx \n \
+            movw %%ax, %%ss \n \
+            movl %[stackoff], %%esp \n \
+            pushl %%ebx \n \
+            ljmp %[code],$raz \n \
+raz:\n \
+		xor %%eax,%%eax\n\
+		xor %%ebx,%%ebx\n\
+		xor %%ecx,%%ecx\n\
+		xor %%edx,%%edx\n\
+		xor %%esi,%%esi\n\
+		xor %%edi,%%edi\n\
+		xor %%ebp,%%ebp\n\
+		ret"::[data] "i"(SEL_KERNEL_DATA),[code] "i"(SEL_KERNEL_CODE),[stack] "i"(SEL_KERNEL_STACK),[stackoff] "i"(KERNEL_STACK_ADDR),[offset] "m"(executingoffset));
+}
+
+/*******************************************************************************/
+/* Change le TSS courant */
+
+void setTSS(u32 ss, u32 sp)
+{
+
+	tss0.trapflag = 0x00;
+	tss0.iomap = 0x00;
+	tss0.ss0 = SEL_TSS;
+	tss0.esp0 = sp;
+	tss0.ss0 = ss;
+}
+
+/*******************************************************************************/
+/* Initialise le registre de tâche (TSR) */
+
+void inittr(void)
+{
+	ltr(SEL_TSS);
+}
+
+/*******************************************************************************/
+/* récupère la base d'un descripteur GDT */
+
+u32 getdesbase(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	return (entry[index].base0_15 + (entry[index].base16_23 << 16) +
+		(entry[index].base24_31 << 24));
+}
+
+/*******************************************************************************/
+/* récupère la limite d'un descripteur GDT */
+
+u32 getdeslimit(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	return (entry[index].lim0_15 + (entry[index].lim16_19 << 16));
+}
+
+/*******************************************************************************/
+/* récupère la limite d'un descripteur GDT */
+
+u32 getdesdpl(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	return (entry[index].acces >> 5 & 0x03);
+}
+
+/*******************************************************************************/
+/* récupère le type d'un descripteur GDT */
+
+u8 getdestype(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	if (((entry[index].acces & 0x14) == 0)
+	    && ((entry[index].acces & 0x08) > 0)
+	    && ((entry[index].acces & 0x01) > 0)
+	    && ((entry[index].flags & 0x06) == 0))
+		return 'T';
+	else
+		return (((entry[index].acces & 0x08) > 0) ? 'C' : 'D');
+}
+
+/*******************************************************************************/
+/* récupère l'info 1 d'un descripteur GDT */
+
+u8 getdesbit1(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	if (((entry[index].acces & 0x14) == 0)
+	    && ((entry[index].acces & 0x08) > 0)
+	    && ((entry[index].acces & 0x01) > 0)
+	    && ((entry[index].flags & 0x06) == 0))
+		return (((entry[index].acces & 0x04) > 0) ? 'B' : '-');
+	else
+		return (((entry[index].acces & 0x01) > 0) ? 'A' : '-');
+}
+
+/*******************************************************************************/
+/* récupère l'info 2 d'un descripteur GDT */
+
+u8 getdesbit2(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	if (((entry[index].acces & 0x20) == 0)
+	    && ((entry[index].acces & 0x08) > 0)
+	    && ((entry[index].acces & 0x01) > 0)
+	    && ((entry[index].flags & 0x06) == 0))
+		return (((entry[index].flags & 0x01) > 0) ? 'U' : '-');
+	else if ((entry[index].acces & 0x8) > 0)
+		return (((entry[index].acces & 0x02) > 0) ? 'R' : '-');
+	else
+		return (((entry[index].acces & 0x02) > 0) ? 'W' : 'R');
+}
+
+/*******************************************************************************/
+/* récupère l'info 3 d'un descripteur GDT */
+
+u8 getdesbit3(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	if ((entry[index].acces & 0x08) > 0)
+		return (((entry[index].acces & 0x04) > 0) ? 'C' : '-');
+	else
+		return (((entry[index].acces & 0x04) > 0) ? 'D' : 'U');
+}
+
+/*******************************************************************************/
+/* récupère l'alignement d'un descripteur GDT */
+
+u16 getdesalign(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	return (((entry[index].flags & 0x08) > 0) ? 4096 : 1);
+}
+
+/*******************************************************************************/
+/* récupère si descripteur GDT est valide */
+
+bool isdesvalid(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	return ((entry[index].acces & 0x80) > 0);
+}
+
+/*******************************************************************************/
+/* récupère la dimension d'un descripteur GDT */
+
+u32 getdessize(u16 sel)
+{
+	gdtdes *entry = GDT_ADDR;
+	u8      index = sel / sizeof(gdtdes);
+	if (((entry[index].acces & 0x14) == 0)
+	    && ((entry[index].acces & 0x08) > 0)
+	    && ((entry[index].acces & 0x01) > 0)
+	    && ((entry[index].flags & 0x06) == 0))
+		return 32;
+	else
+		return (((entry[index].flags & 0x08) > 0) ? 32 : 16);
+}

lib/graph.c

@@ -1,58 +0,0 @@
-#include "types.h"
-#include "vga.h"
-#include "video.h"
-#include "graph.h"
-#include "math.h"                                        
-
-/******************************************************************************/
-
-/* Affiche une ligne entre les points spécifiés */
-
-void line(u32 x1, u32 y1, u32 x2, u32 y2, u8 color)
-{
-  s32 dx,dy,sdx,sdy;
-  u32 i,dxabs,dyabs,x,y,px,py;
-
-  dx=x2-x1;      /*  distance horizontale de la line */
-  dy=y2-y1;      /* distance verticale de la line **/
-  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);
-    }
-  }
-}
-

lib/handlers.c

@@ -0,0 +1,341 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "interrupts.h"
+#include "types.h"
+#include "asm.h"
+#include "memory.h"
+#include "video.h"
+#include "gdt.h"
+#include "system.h"
+#include "debug.h"
+#include "process.h"
+
+/******************************************************************************/
+/* Déclenché lors de l'appel d'une interruption */
+
+__attribute__ ((noreturn)) void interruption_handler(regs *dump)
+{
+	u32 interruption=dump->eip;
+	exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
+	bool noerror,user;
+	if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
+	{
+		noerror=true;
+		dump->eip = caller->eip;
+		dump->cs = caller->cs;
+		dump->eflags = caller->eflags;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack_noerror);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
+			user=true;
+		}
+	}
+	else
+	{
+		noerror=false;
+		dump->eip = ((exception_stack*)caller)->eip;
+		dump->cs = ((exception_stack*)caller)->cs;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_user*) caller)->ss;
+			user=true;
+		}
+	}
+	switch (interruption)
+	{
+		case 20:
+			show_lightcpu(dump);
+			break;
+		default:
+			print("Appel d'une interruption\r\n");
+	}
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			setESP(dump);
+			restcpu_kernel();
+		}
+		else
+		{
+			setESP(dump);
+			restcpu_user();
+			iret();
+		}
+}
+
+/******************************************************************************/
+/* Les expections */
+
+static u8 ex14_errors1[] =
+	"Supervisory process tried to read a non-present page entry";
+static u8 ex14_errors2[] =
+	"Supervisory process tried to read a page and caused a protection fault";
+static u8 ex14_errors3[] =
+	"Supervisory process tried to write to a non-present page entry";
+static u8 ex14_errors4[] =
+	"Supervisory process tried to write a page and caused a protection fault";
+static u8 ex14_errors5[] =
+	"User process tried to read a non-present page entry";
+static u8 ex14_errors6[] =
+	"User process tried to read a page and caused a protection fault";
+static u8 ex14_errors7[] =
+	"User process tried to write to a non-present page entry";
+static u8 ex14_errors8[] =
+	"User process tried to write a page and caused a protection fault";
+static u8 *ex14_errors[] =
+	{ &ex14_errors1, &ex14_errors2, &ex14_errors3, &ex14_errors4,
+	&ex14_errors5, &ex14_errors6, &ex14_errors7, &ex14_errors8
+};
+
+__attribute__ ((noreturn)) void exception_handler(regs *dump)
+{
+	u32 exception=dump->eip;
+	exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
+	bool noerror,user;
+	if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
+	{
+		noerror=true;
+		dump->eip = caller->eip;
+		dump->cs = caller->cs;
+		dump->eflags = caller->eflags;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack_noerror);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
+			user=true;
+		}
+	}
+	else
+	{
+		noerror=false;
+		dump->eip = ((exception_stack*)caller)->eip;
+		dump->cs = ((exception_stack*)caller)->cs;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_user*) caller)->ss;
+			user=true;
+		}
+	}
+	switch (exception)
+	{
+		case 0:
+			cpuerror("#DE Divide error", dump, false);
+		case 1:
+			changevc(6);
+			clearscreen();
+			show_lightcpu(dump);
+			printf("\r\n\033[7m[P]\033[0m PAS A PAS \033[7m D \033[0m PAS A PAS DETAILLE \033[7m C \033[0m CONTINUER \033[7m S \033[0m STOPPER \033[7m V \033[0m VOIR \033[7m S \033[0m SCINDER");
+			sti();
+			u8      ascii = waitascii();
+			cli();
+			if (ascii == 'P' || ascii == 'p')
+				setdebugreg(0,
+					    caller->eip + disasm(caller->eip, NULL, false),
+					    DBG_EXEC);
+			else if (ascii == 'D' || ascii == 'd')
+				setdebugreg(0, 0, DBG_CLEAR);
+			else if (ascii == 'C' || ascii == 'c')
+				setdebugreg(0, 0, DBG_CLEAR);
+			else if (ascii == 'S' || ascii == 's')
+			{
+				changevc(0);
+				sti();
+				initselectors(getinitretry());
+			}
+			changevc(0);
+			goto endofexception;
+		case 2:
+			cpuerror("NMI Non-maskable hardware interrupt", dump, false);
+		case 3:
+			cpuerror("#BP INT3 instruction", dump, true);
+			iret();
+		case 4:
+			cpuerror("#OF INTO instruction detected overflow", dump, false);
+		case 5:
+			cpuerror("#BR BOUND instruction detected overrange", dump, false);
+		case 6:
+			cpuerror("#UD Invalid instruction opcode", dump, false);
+		case 7:
+			cpuerror("#NM No coprocessor", dump, false);
+		case 8:
+			cpuerror("#DF Double fault", dump, false);
+		case 9:
+			cpuerror("Coprocessor segment overrun", dump, false);	
+		case 10:
+			cpuerror("#TS Invalid task state segment (TSS)", dump, false);
+		case 11:
+			cpuerror("#NP Segment not present", dump, false);
+		case 12:
+			cpuerror("#SS Stack fault", dump, false);
+		case 13:
+			cpuerror("#GP General protection fault (GPF)", dump, false);
+		case 14:
+			if (dump->cr2 >= USER_CODE && dump->cr2 < USER_STACK)
+			{
+				virtual_range_new(findcurrentprocess()->pdd,
+						  (u8 *) (dump->cr2 & 0xFFFFF000),
+						  PAGESIZE, PAGE_ALL);
+			}
+			else
+			{
+				printf("Page fault - %s at adress %Y cs:eip - %Y:%Y\r\n",
+					 ex14_errors[((exception_stack*) caller)->error_code & 0xF], dump->cr2,
+					 dump->cs, dump->eip);
+				cpuerror("#PGF Page fault", dump, false);
+			}
+			goto endofexception;
+		case 15:
+			cpuerror("(reserved)", dump, false);
+		case 16:
+			cpuerror("#MF Coprocessor error", dump, false);
+		case 17:
+			cpuerror("#AC Alignment check", dump, false);
+		case 18: 
+			cpuerror("#MC Machine check", dump, false);
+	}
+	endofexception:
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			setESP(dump);
+			restcpu_kernel();
+		}
+		else
+		{
+			setESP(dump);
+			restcpu_user();
+			iret();
+		}
+}
+
+/******************************************************************************/
+/* Les IRQ par défaut */
+
+__attribute__((interrupt)) void irq0(exception_stack_noerror *caller)
+{	
+	print("irq 0");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq1(exception_stack_noerror *caller)
+{
+	print("irq 1");
+	while ((inb(0x64) & 1) == 0);
+	inb(0x60);
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq2(exception_stack_noerror *caller)
+{	print("irq 2");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq3(exception_stack_noerror *caller)
+{
+	print("irq 3");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq4(exception_stack_noerror *caller)
+{
+	print("irq 4");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq5(exception_stack_noerror *caller)
+{
+	print("irq 5");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq6(exception_stack_noerror *caller)
+{
+	print("irq 6");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq7(exception_stack_noerror *caller)
+{
+	print("irq 7");
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq8(exception_stack_noerror *caller)
+{
+	print("irq 8");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq9(exception_stack_noerror *caller)
+{
+	print("irq 9");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq10(exception_stack_noerror *caller)
+{
+	print("irq 10");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq11(exception_stack_noerror *caller)
+{
+	print("irq 11");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq12(exception_stack_noerror *caller)
+{
+	print("irq 12");
+	while ((inb(0x64) & 1) == 0);
+	inb(0x60);
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq13(exception_stack_noerror *caller)
+{
+	print("irq 13");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq14(exception_stack_noerror *caller)
+{
+	print("irq 14");
+	irqendslave();
+	irqendmaster();
+}
+
+__attribute__((interrupt)) void irq15(exception_stack_noerror *caller)
+{
+	print("irq 15");
+	irqendslave();
+	irqendmaster();
+}

lib/handlers_asm.S

@@ -0,0 +1,120 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+.section .text
+
+.macro  exception num
+.global wrapper_exception\num
+wrapper_exception\num:
+pushl %ss
+pushl %esp
+pushf 
+pushl %cs
+pushl $\num
+jmp exception_suite
+.endm
+
+.macro  semidumpcpu
+cli
+pushl %ds
+pushl %es
+pushl %fs
+pushl %gs
+pushl %eax
+pushl %ebx
+pushl %ecx
+pushl %edx
+pushl %esi
+pushl %edi
+pushl %ebp
+mov %cr0, %eax 
+pushl %eax
+mov %cr2, %eax 
+pushl %eax
+mov %cr3, %eax 
+pushl %eax
+mov %cr4, %eax 
+pushl %eax 
+mov %dr0, %eax 
+pushl %eax
+mov %dr1, %eax 
+pushl %eax
+mov %dr2, %eax 
+pushl %eax
+mov %dr3, %eax 
+pushl %eax
+mov %dr6, %eax 
+pushl %eax
+mov %dr7, %eax 
+pushl %eax
+mov $0xC0000080, %ecx 
+rdmsr 
+pushl %edx 
+pushl %eax
+pushl %esp
+.endm
+
+exception 0
+exception 1
+exception 2
+exception 3
+exception 4
+exception 5
+exception 6
+exception 7
+exception 8
+exception 9
+exception 10
+exception 11
+exception 12
+exception 13
+exception 14
+exception 15
+exception 16
+exception 17
+exception 18
+
+exception_suite:
+semidumpcpu
+call exception_handler
+
+.global wrapper_sysenter
+wrapper_sysenter:
+pushl %ss
+pushl %esp
+pushf 
+pushl %cs
+pushl $0x00
+semidumpcpu
+call sysenter_handler
+
+.global wrapper_interruption20
+wrapper_interruption20:
+pushl %ss
+pushl %esp
+pushf 
+pushl %cs
+pushl $0x14
+semidumpcpu
+call interruption_handler
+
+.global wrapper_interruption
+wrapper_interruption:
+pushl %ss
+pushl %esp
+pushf 
+pushl %cs
+pushl $0x00
+semidumpcpu
+call interruption_handler
+
+.global wrapper_timer
+wrapper_timer:
+pushl %ss
+pushl %esp
+pushf 
+pushl %cs
+pushl $0x00
+semidumpcpu
+call timer_handler

lib/idt.c

@@ -1,511 +0,0 @@
-#include "idt.h"
-#include "types.h"
-#include "asm.h"
-#include "memory.h"
-#include "video.h"
-
- /* registre idt */
-static struct dtr idtreg;
-
-/* table de IDT */
-static idtdes idt[256];
-
-
-void initpic(void)
-{
-	/* MASTER */
-	/* Initialisation de ICW1 */
-	outb(0x20,0x11);
-	nop();
-	/* Initialisation de ICW2 - vecteur de depart = 32 */
-	outb(0x21,0x20);    
- 	nop();        
-	/* Initialisation de ICW3 */
-	outb(0x21,0x04);
-	nop();
-	/* Initialisation de ICW4 */
-	outb(0x21,0x01);
-	nop();
-	/* masquage des interruptions */
-	outb(0x21,0xFF);
-	nop();
-	/* SLAVE */
-	/* Initialisation de ICW1 */
-	outb(0xA0,0x11);
-	nop();
-	/* Initialisation de ICW2 - vecteur de depart = 96 */
-	outb(0xA1,0x60);   
-	nop();   
-	/* Initialisation de ICW3 */
-	outb(0xA1,0x02);
-	nop();
-	/* Initialisation de ICW4 */
-	outb(0xA1,0x01);
-	nop();
-	/* masquage des interruptions */
-	outb(0xA1,0xFF);
-	nop();
-	/* Demasquage des irqs sauf clavier
-	outb(0x21,0xFD);
-	nop();
-	*/
-}
-
-void enableirq(u8 irq)
-{
-u16 port;
-cli();
-port = (((irq & 0x08) << 4) + 0x21);
-outb(port,inb(port) & ~(1 << (irq & 7)));
-sti();
-}
-
-void disableirq(u8 irq)
-{
-u16 port;
-cli();
-port = (((irq & 0x08) << 4) + 0x21);
-outb(port,inb(port) | (1 << (irq & 7)));
-sti();
-}
-
-void makeidtdes(u32 offset, u16 select, u16 type, idtdes* desc) 
-{
-	desc->offset0_15 = (offset & 0xffff);
-	desc->select = select;
-	desc->type = type;
-	desc->offset16_31 = (offset & 0xffff0000) >> 16;
-	return;
-}
-
-void setidt(u32 offset, u16 select, u16 type,u16 index) 
-{
-cli();
-idtdes *desc;
-desc=idtreg.base;
-	desc[index].offset0_15 = (offset & 0xffff);
-	desc[index].select = select;
-	desc[index].type = type;
-	desc[index].offset16_31 = (offset & 0xffff0000) >> 16;
-sti();
-}
-
-void putidt(u32 offset, u16 select, u16 type,u16 index) 
-{
-idtdes temp;
-makeidtdes(offset,select,type,&temp);
-idt[index]=temp;
-}
-
-void cpuerror(const u8 *src)
-{
- print("\033[31m***** ERREUR CPU ****\r\n -");
- print(src);
- dump_regs();
- while(1)
- {
-    nop();
- }
-}
-
-void interruption()
-{
-    cli();
-    pushf();
-    pushad();
-	print("Appel d'une interruption\r\n");
-    popad();
-    popf();
-    sti();
-	iret();
-}
-
-void exception0() 
-{
-	print("divide error\r\n");
- }
-
-void exception1() 
-{
-	cpuerror("debug exception\r\n");
-  }
-
-void exception2()
- {
-	cpuerror("non-maskable hardware interrupt\r\n");
-  }
-
-void exception3() 
-{
-	cpuerror("INT3 instruction\r\n");
-  }
-
-void exception4()
- {
-	cpuerror("INTO instruction detected overflow\r\n");
-  }
-
-void exception5()
- {
-	print("BOUND instruction detected overrange\r\n");
-  }
-
-void exception6() 
-{
-	cpuerror("invalid instruction opcode\r\n");
-  }
-
-void exception7()
- {
-	cpuerror("no coprocessor\r\n");
-  }
-
-void exception8() 
-{
-	cpuerror("double fault\r\n");
-  }
-
-void exception9()
- {
-	cpuerror("coprocessor segment overrun\r\n");
-  }
-
-void exception10() 
-{
-	cpuerror("invalid task state segment (TSS)\r\n");
-  }
-
-void exception11()
- {
-	cpuerror("segment not present\r\n");
-  }
-
-void exception12() 
-{
-	cpuerror("stack fault");
-  }
-
-void exception13()
- {
-    cpuerror("general protection fault (GPF)\r\n");
-  }
-
-void exception14()
- {
-	cpuerror("page fault\r\n");
-  }
-
-void exception15() 
-{
-	cpuerror("(reserved)\r\n");
-  }
-  
-void exception16()
- {
-	cpuerror("coprocessor error\r\n");
-  }
-
-void exception17() 
-{
-	cpuerror("alignment check\r\n");
-  }
-
-void exception18()
- {
-	cpuerror("machine check");
-  }
-
-void irq0()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 0");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-  void irq1()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 1");
-	while ((inb(0x64)&1)==0);
-    inb(0x60);
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-  void irq2()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 2");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-  void irq3()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 3");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-  void irq4()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 4");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-  void irq5()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 5");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-  void irq6()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 6");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-void irq7()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 7");
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-void irq8()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 8");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-void irq9()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 9");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-void irq10()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 10");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-void irq11()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 11");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-void irq12()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 12");
-	while ((inb(0x64)&1)==0);
-        inb(0x60);
- 	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-  void irq13()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 13");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-  
-void irq14()
- {
-    cli();
-    pushf();
-    pushad();
-	print("irq 14");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }
-
-void irq15()
- {
-   cli();
-	print("irq 15");
-	irqendslave();
-	irqendmaster();
-    popad();
-    popf();
-	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
-  }  
-
- void initidt(void)
-{
-u16 i;
-	putidt((u32)exception0, 0x20, INTGATE, 0);
-	putidt((u32)exception1, 0x20, INTGATE, 1);
-	putidt((u32)exception2, 0x20, INTGATE, 2);
-	putidt((u32)exception3, 0x20, INTGATE, 3);
-	putidt((u32)exception4, 0x20, INTGATE, 4);
-	putidt((u32)exception5, 0x20, INTGATE, 5);
-	putidt((u32)exception6, 0x20, INTGATE, 6);
-	putidt((u32)exception7, 0x20, INTGATE, 7);
-	putidt((u32)exception8, 0x20, INTGATE, 8);
-	putidt((u32)exception9, 0x20, INTGATE, 9);
-	putidt((u32)exception10, 0x20, INTGATE, 10);
-	putidt((u32)exception11, 0x20, INTGATE, 11);
-	putidt((u32)exception12, 0x20, INTGATE, 12);
-	putidt((u32)exception13, 0x20, INTGATE, 13);
-	putidt((u32)exception14, 0x20, INTGATE, 14);
-	putidt((u32)exception15, 0x20, INTGATE, 15);
-	putidt((u32)exception16, 0x20, INTGATE, 16);
-	putidt((u32)exception17, 0x20, INTGATE, 17);
-	putidt((u32)exception18, 0x20, INTGATE, 18);
-	for(i=19;i<32;i++)
-  {
-	putidt((u32)interruption, 0x20, INTGATE, i);  
-  } 
-	putidt((u32)irq0, 0x20, INTGATE, 32);
-	putidt((u32)irq1, 0x20, INTGATE, 33);
-	putidt((u32)irq2, 0x20, INTGATE, 34);
-	putidt((u32)irq3, 0x20, INTGATE, 35);
-	putidt((u32)irq4, 0x20, INTGATE, 36);
-	putidt((u32)irq5, 0x20, INTGATE, 37);
-	putidt((u32)irq6, 0x20, INTGATE, 38);
-	putidt((u32)irq7, 0x20, INTGATE, 39);
-	for(i=40;i<96;i++)
-  {
-	putidt((u32)interruption, 0x20, INTGATE, i);  
-  } 
-	putidt((u32)irq8, 0x20, INTGATE, 96);
-	putidt((u32)irq9, 0x20, INTGATE, 97);
-	putidt((u32)irq10, 0x20, INTGATE, 98);
-	putidt((u32)irq11, 0x20, INTGATE, 99);
-	putidt((u32)irq12, 0x20, INTGATE, 100);
-	putidt((u32)irq13, 0x20, INTGATE, 101);
-	putidt((u32)irq14, 0x20, INTGATE, 102);
-	putidt((u32)irq15, 0x20, INTGATE, 103);  
-	for(i=104;i<255;i++)
-  {
-	putidt((u32)interruption, 0x20, INTGATE, i);  
-  } 
-  /* initialise le registre idt */
-	idtreg.limite = 256*8;
-	idtreg.base = 0x0000000;
-	/* recopie de la IDT a son adresse */
-	memcpy(&idt, (u8*)idtreg.base, idtreg.limite,1);
-	/* chargement du registre IDTR */
-	lidt(&idtreg);
-
-}
-

lib/interrupts.c

@@ -0,0 +1,276 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "interrupts.h"
+#include "types.h"
+#include "asm.h"
+#include "memory.h"
+#include "video.h"
+#include "gdt.h"
+#include "system.h"
+#include "debug.h"
+#include "process.h"
+#include "handlers.h"
+
+#define IDT_SIZE		256	/* nombre de descripteurs */
+
+ /* registre idt */
+static struct idtr idtreg;
+
+/* table de IDT */
+static idtdes idt[IDT_SIZE];
+
+static u32 retry_address;
+
+extern wrapper_exception0;
+extern wrapper_exception1;
+extern wrapper_exception2;
+extern wrapper_exception3;
+extern wrapper_exception4;
+extern wrapper_exception5;
+extern wrapper_exception6;
+extern wrapper_exception7;
+extern wrapper_exception8;
+extern wrapper_exception9;
+extern wrapper_exception10;
+extern wrapper_exception11;
+extern wrapper_exception12;
+extern wrapper_exception13;
+extern wrapper_exception14;
+extern wrapper_exception15;
+extern wrapper_exception16;
+extern wrapper_exception17;
+extern wrapper_exception18;
+extern wrapper_interruption;
+/******************************************************************************/
+/* Initialise la reprise après erreur */
+
+void initretry(u32 address)
+{
+	retry_address = address;
+}
+
+/******************************************************************************/
+/* Récupère l'adresse de reprise après erreur */
+
+u32 getinitretry(void)
+{
+	return retry_address;
+}
+
+/******************************************************************************/
+/* Initialise le controleur d'interruption 8259A */
+
+void initpic(void)
+{
+	/* MASTER */
+	/* Initialisation de ICW1 */
+	outb(PIC1_CMD, ICW1_INIT + ICW1_ICW4);
+	nop();
+	/* Initialisation de ICW2 - vecteur de depart = 32 */
+	outb(PIC1_DATA, 0x20);
+	nop();
+	/* Initialisation de ICW3 */
+	outb(PIC1_DATA, 0x04);
+	nop();
+	/* Initialisation de ICW4 */
+	outb(PIC1_DATA, ICW4_8086);
+	nop();
+	/* masquage des interruptions */
+	outb(PIC1_DATA, 0xFF);
+	nop();
+	/* SLAVE */
+	/* Initialisation de ICW1 */
+	outb(PIC2_CMD, ICW1_INIT + ICW1_ICW4);
+	nop();
+	/* Initialisation de ICW2 - vecteur de depart = 96 */
+	outb(PIC2_DATA, 0x60);
+	nop();
+	/* Initialisation de ICW3 */
+	outb(PIC2_DATA, 0x02);
+	nop();
+	/* Initialisation de ICW4 */
+	outb(PIC2_DATA, ICW4_8086);
+	nop();
+	/* masquage des interruptions */
+	outb(PIC2_DATA, 0xFF);
+	nop();
+	/* Demasquage des irqs sauf clavier
+	   outb(PIC1_DATA,0xFD);
+	   nop();
+	 */
+}
+
+/******************************************************************************/
+/* Active une IRQ */
+
+void enableirq(u8 irq)
+{
+	u16     port;
+	cli();
+	port = (((irq & 0x08) << 4) + PIC1_DATA);
+	outb(port, inb(port) & ~(1 << (irq & 7)));
+	sti();
+}
+
+/******************************************************************************/
+/* Désactive une IRQ */
+
+void disableirq(u8 irq)
+{
+	u16     port;
+	cli();
+	port = (((irq & 0x08) << 4) + PIC1_DATA);
+	outb(port, inb(port) | (1 << (irq & 7)));
+	sti();
+}
+
+/******************************************************************************/
+
+/* Créé un descripteur pour l'IDT */
+
+void makeidtdes(u32 offset, u16 select, u16 type, idtdes * desc)
+{
+	desc->offset0_15 = (offset & 0xffff);
+	desc->select = select;
+	desc->type = type;
+	desc->offset16_31 = (offset & 0xffff0000) >> 16;
+	return;
+}
+
+/******************************************************************************/
+/* Change une entrée dans l'IDT */
+
+void setidt(u32 offset, u16 select, u16 type, u16 index)
+{
+	cli();
+	idtdes *desc;
+	desc = idtreg.base;
+	desc[index].offset0_15 = (offset & 0xffff);
+	desc[index].select = select;
+	desc[index].type = type;
+	desc[index].offset16_31 = (offset & 0xffff0000) >> 16;
+	sti();
+}
+
+/******************************************************************************/
+/* Met une entrée dans l'IDT */
+
+void putidt(u32 offset, u16 select, u16 type, u16 index)
+{
+	idtdes  temp;
+	makeidtdes(offset, select, type, &temp);
+	idt[index] = temp;
+}
+
+/******************************************************************************/
+/* Initialise une IDT */
+
+void initidt(void)
+{
+	u16     i;
+	putidt((u32) &wrapper_exception0, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 0);
+	putidt((u32) &wrapper_exception1, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 1);
+	putidt((u32) &wrapper_exception2, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 2);
+	putidt((u32) &wrapper_exception3, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 3);
+	putidt((u32) &wrapper_exception4, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 4);
+	putidt((u32) &wrapper_exception5, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 5);
+	putidt((u32) &wrapper_exception6, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 6);
+	putidt((u32) &wrapper_exception7, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 7);
+	putidt((u32) &wrapper_exception8, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 8);
+	putidt((u32) &wrapper_exception9, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 9);
+	putidt((u32) &wrapper_exception10, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 10);
+	putidt((u32) &wrapper_exception11, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 11);
+	putidt((u32) &wrapper_exception12, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 12);
+	putidt((u32) &wrapper_exception13, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 13);
+	putidt((u32) &wrapper_exception14, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 14);
+	putidt((u32) &wrapper_exception15, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 15);
+	putidt((u32) &wrapper_exception16, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 16);
+	putidt((u32) &wrapper_exception17, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 17);
+	putidt((u32) &wrapper_exception18, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 18);
+	for (i = 19; i < 32; i++)
+	{
+		putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
+		       ENTRY_PRESENT | ENTRY_RING3 | TRAPGATE, i);
+	}
+	putidt((u32) irq0, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 32);
+	putidt((u32) irq1, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 33);
+	putidt((u32) irq2, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 34);
+	putidt((u32) irq3, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 35);
+	putidt((u32) irq4, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 36);
+	putidt((u32) irq5, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 37);
+	putidt((u32) irq6, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 38);
+	putidt((u32) irq7, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 39);
+	for (i = 40; i < 96; i++)
+	{
+		putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
+		       ENTRY_PRESENT | ENTRY_RING3 | TRAPGATE, i);
+	}
+	putidt((u32) irq8, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 96);
+	putidt((u32) irq9, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 97);
+	putidt((u32) irq10, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 98);
+	putidt((u32) irq11, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 99);
+	putidt((u32) irq12, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 100);
+	putidt((u32) irq13, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 101);
+	putidt((u32) irq14, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 102);
+	putidt((u32) irq15, SEL_KERNEL_CODE,
+	       ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 103);
+	for (i = 104; i < IDT_SIZE; i++)
+	{
+		putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
+		       ENTRY_PRESENT | ENTRY_RING0 | TRAPGATE, i);
+	}
+	/* initialise le registre idt */
+	idtreg.limite = IDT_SIZE * sizeof(idtdes);
+	idtreg.base = IDT_ADDR;
+	/* recopie de la IDT a son adresse */
+	memcpy(&idt, (u8 *) idtreg.base, idtreg.limite, 1);
+	/* chargement du registre IDTR */
+	lidt(idtreg);
+}
+
+/******************************************************************************/
+/* 8253/8254 PIT (Programmable Interval Timer) Timer ajustable */
+
+void inittimer(void)
+{
+	u32     divisor = TIMER_FREQ / HZ;
+	outb(TIMER_MODE, RATE_GENERATOR);
+	outb(TIMER0, (u8) divisor);
+	outb(TIMER0, (u8) (divisor >> 8));
+}
+/*******************************************************************************/

lib/keyboard.c

@@ -1,310 +1,381 @@
-#include "idt.h"
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "interrupts.h"
 #include "types.h"
 #include "asm.h"
 #include "memory.h"
 #include "keyboard.h"
-
+#include "vga.h"
 #include "video.h"
 
-static u8 bufferscan[256]={0};
-static u8 bufferascii[256]={0};
-static u8 ptrscan=0;
-static u8 ptrascii=0;
-static u16 kbdstatus,breakcode ;
+static u8 bufferscan[256] = { 0 };
+static u8 bufferascii[256] = { 0 };
 
-static const u8 set1_normal[] =
-{
-0,	0x1B,	'&',	'é',	'\"',	'\'',	'(',	'-',
-  'è',	'_',	'ç',	'à',	')',	'=',	'\b',	'\t',
-  'a',	'z',	'e',	'r',	't',	'y',	'u',	'i',
-  'o',	'p',	'^',	'$',	'\r',	0,	'q',	's',
-'d',	'f',	'g',	'h',	'j',	'k',	'l',	'm',
-'ù',	'²',	0,	'*',	'w',	'x',	'c',	'v',
-'b',	'n',	',',	';',	':',	'!',	0,	'*',
-0,	' ',	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0, 0,	0,	'7',
-'8',	'9','-',	'4','5','6',	'+',	'1',
-'2',	'3','0','.',0,	0,	'<',	0,
-0
+static u8 ptrscan = 0;
+static u8 ptrascii = 0;
+static u16 kbdstatus, breakcode;
+
+/******************************************************************************/
+/* Tables clavier */
+
+static const u8 set1_normal[] = {
+	0, 0x1B, '&', 'é', '\"', '\'', '(', '-',
+	'è', '_', 'ç', 'à', ')', '=', '\b', '\t',
+	'a', 'z', 'e', 'r', 't', 'y', 'u', 'i',
+	'o', 'p', '^', '$', '\r', 0, 'q', 's',
+	'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm',
+	'ù', '²', 0, '*', 'w', 'x', 'c', 'v',
+	'b', 'n', ',', ';', ':', '!', 0, '*',
+	0, ' ', 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '7',
+	'8', '9', '-', '4', '5', '6', '+', '1',
+	'2', '3', '0', '.', 0, 0, '<', 0,
+	0
 };
 
-static const u8 set1_shift[] =
-{
-0,	0x1B,	'1',	'2',	'3',	'4',	'5',	'6',
-  '7',	'8',	'9',	'0',	'°',	'+',	'\b',	'\t',
-  'A',	'Z',	'E',	'R',	'T',	'Y',	'U',	'I',
-  'O',	'P',	'¨',	'£',	'\r',	0,	'Q',	'S',
-'D',	'F',	'G',	'H',	'J',	'K',	'L',	'M',
-'%',	0,	0,	'µ',	'W',	'X',	'C',	'V',
-'B',	'N',	'?',	'.',	'/',	'§',	0,	'*',
-0,	' ',	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,0,	0,	'7',
-'8',	'9','-',	'4','5','6',	'+',	'1',
-'2',	'3','0','.',0,	0,	'>',	0,
-0
+static const u8 set1_shift[] = {
+	0, 0x1B, '1', '2', '3', '4', '5', '6',
+	'7', '8', '9', '0', '°', '+', '\b', '\t',
+	'A', 'Z', 'E', 'R', 'T', 'Y', 'U', 'I',
+	'O', 'P', '¨', '£', '\r', 0, 'Q', 'S',
+	'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M',
+	'%', 0, 0, 'µ', 'W', 'X', 'C', 'V',
+	'B', 'N', '?', '.', '/', '§', 0, '*',
+	0, ' ', 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '7',
+	'8', '9', '-', '4', '5', '6', '+', '1',
+	'2', '3', '0', '.', 0, 0, '>', 0,
+	0
 };
 
-static const u8 set1_alt[] =
-{
-0,	0x1B,	0,	0,	0,	0,	0,	0,
-  0,	0,	0,	0,	0,	0,	0,	0,
-  0,	0,	0,	0,	0,	0,	0,	0,
-  0,	0,	0,	0,	'\r',	0,	0,	0,
-0,	0,	0,0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,	0,	0,	'*',
-0,	' ',	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,0,	0,	'7',
-'8',	'9','-',	'4','5','6',	'+',	'1',
-'2',	'3','0','.',0,	0,	0,	0,
-0
+static const u8 set1_alt[] = {
+	0, 0x1B, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, '\r', 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '*',
+	0, ' ', 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '7',
+	'8', '9', '-', '4', '5', '6', '+', '1',
+	'2', '3', '0', '.', 0, 0, 0, 0,
+	0
 };
 
-
-static const u8 set1_altgr[] =
-{
-0,	0x1B,	0,	'~',	'#',	'{',	'[',	'|',
-  '`',	'\\',	'^',	'@',	']',	'}',	'\b',	'\t',
-  0,	0,	0,	0,	0,	0,	0,	0,
-  0,	0,	0,	'¤',	'\r',	0,	0,	0,
-0,	0,	0,0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,	0,	0,	'*',
-0,	' ',	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,0,	0,	'7',
-'8',	'9','-',	'4','5','6',	'+',	'1',
-'2',	'3','0','.',0,	0,	0,	0,
-0
+static const u8 set1_altgr[] = {
+	0, 0x1B, 0, '~', '#', '{', '[', '|',
+	'`', '\\', '^', '@', ']', '}', '\b', '\t',
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, '¤', '\r', 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '*',
+	0, ' ', 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '7',
+	'8', '9', '-', '4', '5', '6', '+', '1',
+	'2', '3', '0', '.', 0, 0, 0, 0,
+	0
 };
 
-static const u8 set1_ctrl[] =
-{
-0,	0x1B,	0,	0,0,	0,	0x1B,	0,
-  0,	0x1C,	0,	0,	0x1D,	0,	0,	0x1F,
-  0x01,	0x1A,	0x05,	0x012,	0x14,	0x19,	0x15,	0x09,
-  0x0F,	0x10,	0x1E,	0,	0,	0,	0x11,	0x13,
-0x04,	0x06,	0x07,0x08,	0x0A,	0x0B,	0x0C,	0x0D,
-0,	0,	0,	0,	0x17,	0x18,	0x03,	0x16,
-0x02,	0x0E,	0,	0,	0,	0,	0,	'*',
-0,	' ',	0,	0,	0,	0,	0,	0,
-0,	0,	0,	0,	0,0,	0,	'7',
-'8',	'9','-',	'4','5','6',	'+',	'1',
-'2',	'3','0','.',0,	0,	0,	0,
-0
+static const u8 set1_ctrl[] = {
+	0, 0x1B, 0, 0, 0, 0, 0x1B, 0,
+	0, 0x1C, 0, 0, 0x1D, 0, 0, 0x1F,
+	0x01, 0x1A, 0x05, 0x012, 0x14, 0x19, 0x15, 0x09,
+	0x0F, 0x10, 0x1E, 0, 0, 0, 0x11, 0x13,
+	0x04, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C, 0x0D,
+	0, 0, 0, 0, 0x17, 0x18, 0x03, 0x16,
+	0x02, 0x0E, 0, 0, 0, 0, 0, '*',
+	0, ' ', 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, '7',
+	'8', '9', '-', '4', '5', '6', '+', '1',
+	'2', '3', '0', '.', 0, 0, 0, 0,
+	0
 };
+
 /******************************************************************************/
 
-u8 waitascii()
+/* Attend une chaine de caractère de taille max */
+
+u8     *getstring(u8 * temp)
 {
-u8 oldptrscan=ptrscan;
-u8 oldptrascii=ptrascii;
-while((oldptrascii==ptrascii));/*(oldptrscan==ptrscan)&&*/
-return bufferascii[ptrascii];
+	u8      maxwidth = strlen(temp);
+	u8     *pointer = temp;
+	u8      ascii = 0;
+	while (ascii != '\r')
+	{
+		ascii = waitascii();
+		if (ascii == '\b' && pointer > temp)
+		{
+			pointer--;
+			putchar(ascii);
+		}
+		else if (ascii > 31 && pointer <= temp + 80)
+		{
+			*pointer++ = ascii;
+			putchar(ascii);
+		}
+	}
+	*pointer = '\000';
+	return temp;
 }
 
 /******************************************************************************/
+/* Fonction qui attend l'appuie d'une touche générant un code ASCII puis le retourne */
+/* SYSCALL 
+{
+"ID":1,
+"LIBRARY":"libsys",
+"NAME":"waitkey",
+"INTERNALNAME":"waitascii",
+"DESCRIPTION":"Wait for user to press a key and return the ascii code pressed",
+"ARGS": [],
+"RETURN":"u8"
+}
+END-SYSCALL */
+
+u8 waitascii(void)
+{
+	u8      oldptrascii = ptrascii;
+	while ((oldptrascii == ptrascii));
+	return bufferascii[ptrascii];
+}
+
+/******************************************************************************/
+/* Envoi d'une commande vers le contrôleur de clavier */
 
 void outkbd(u8 port, u8 data)
 {
-	u32 timeout;
-	u8 state;
+	u32     timeout;
+	u8      state;
 
 /* timeout */
-	for(timeout = 500000L; timeout != 0; timeout--)
+	for (timeout = 500000L; timeout != 0; timeout--)
 	{
 		state = inb(0x64);
 /* vide le buffer du 8042 */
-		if((state & 0x02) == 0) break;
+		if ((state & 0x02) == 0)
+			break;
 	}
-	if(timeout != 0)
+	if (timeout != 0)
 		outb(port, data);
 }
 
 /******************************************************************************/
-static void reboot(void)
+/* Redemarre l'ordinateur */
+
+void reboot(void)
 {
-	u8 temp;
+	u8      temp;
 	cli();
 /* vide le 8042 */
 	do
 	{
 		temp = inb(0x64);
-		if((temp & 0x01) != 0)
+		if ((temp & 0x01) != 0)
 		{
-			(void)inb(0x60);
+			(void) inb(0x60);
 			continue;
 		}
-	} while((temp & 0x02) != 0);
+	}
+	while ((temp & 0x02) != 0);
 /* active le reset CPU */
 	outb(0x64, 0xFE);
-	while(1)
-		/* boucle infinie */;
+	while (1)
+		/* boucle infinie */ ;
 }
 
 /******************************************************************************/
+/* Converti un scancode vers une code ASCII */
+
 unsigned convert(u32 keypressed)
 {
-	u8 temp,key,lastscan;
+	u8      temp, key, lastscan;
 /* garde le dernier pointeur du buffer scan */
-   lastscan=ptrscan;
+	lastscan = ptrscan;
 /* incrémente le pointeur est assigne au buffer le dernier scancode */
-   ptrscan++;
-   if (ptrscan==255) ptrscan==0;
-   bufferscan[ptrscan]=keypressed;
+	ptrscan++;
+	if (ptrscan == 255)
+		ptrscan == 0;
+	bufferscan[ptrscan] = keypressed;
 /* break key (touche relaché) ? */
-	if(keypressed >= 0x80) breakcode = 1;
-  key = (keypressed&0x7F);
+	if (keypressed >= 0x80)
+		breakcode = 1;
+	key = (keypressed & 0x7F);
 /* Mise a jour des flags lors du relachement de touches de controle */
-	if(breakcode)
+	if (breakcode)
 	{
-		if(key == SCAN_ALT)
-		 {
+		if (key == SCAN_ALT)
+		{
 			kbdstatus &= ~STATUS_ALT;
 			/* si ALT GR (E01D) alors activer aussi control */
-	    if (bufferscan[lastscan]==0xE0) kbdstatus &= ~STATUS_CTRL;	
-     } 
-  	else if(key == SCAN_CTRL)
+			if (bufferscan[lastscan] == 0xE0)
+				kbdstatus &= ~STATUS_CTRL;
+		}
+		else if (key == SCAN_CTRL)
 			kbdstatus &= ~STATUS_CTRL;
-		else if(key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
+		else if (key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
 			kbdstatus &= ~STATUS_SHIFT;
 		breakcode = 0;
 		return 0;
 	}
 /* Mise a jour des flags lors de l'appuie de touches de controle */
-	if(key == SCAN_ALT)
+	if (key == SCAN_ALT)
 	{
 		kbdstatus |= STATUS_ALT;
-				/* si ALT GR (E01D) alors desactiver aussi control */
-    if (bufferscan[lastscan]==0xE0) kbdstatus |= STATUS_CTRL;	  
-  	return 0;
+		/* si ALT GR (E01D) alors desactiver aussi control */
+		if (bufferscan[lastscan] == 0xE0)
+			kbdstatus |= STATUS_CTRL;
+		return 0;
 	}
-	if(key == SCAN_CTRL)
+	else if (key == SCAN_CTRL)
 	{
 		kbdstatus |= STATUS_CTRL;
 		return 0;
 	}
-	if(key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
+	else if (key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
 	{
 		kbdstatus |= STATUS_SHIFT;
 		return 0;
 	}
 
-	if ((key >= SCAN_F1) && (key <= SCAN_F8))
+	else if ((key >= SCAN_F1) && (key <= SCAN_F8))
 	{
-  changevc(key-SCAN_F1);
-  }
+		changevc(key - SCAN_F1);
+	}
+
+	else if (key == SCAN_F9)
+	{
+		int20;
+	}
+
+	else if (key == SCAN_F10)
+	{
+		apply_nextvideomode();
+	}
 
 /* Scroll Lock, Num Lock, and Caps Lock mise a jour des leds */
-	if(key == SCAN_SCROLLLOCK)
+	else if (key == SCAN_SCROLLLOCK)
 	{
 		kbdstatus ^= STATUS_SCRL;
 		goto LEDS;
 	}
-	if(key == SCAN_NUMLOCK)
+	else if (key == SCAN_NUMLOCK)
 	{
 		kbdstatus ^= STATUS_NUM;
 		goto LEDS;
 	}
-	if(key == SCAN_CAPSLOCK)
+	else if (key == SCAN_CAPSLOCK)
 	{
 		kbdstatus ^= STATUS_CAPS;
-LEDS:		
-       outkbd(0x60, 0xED);	/* "mise a jour des LEDS */
-		 temp = 0;
-		if(kbdstatus & STATUS_SCRL)
+	      LEDS:
+		outkbd(0x60, 0xED);	/* "mise a jour des LEDS */
+		temp = 0;
+		if (kbdstatus & STATUS_SCRL)
 			temp |= 1;
-		if(kbdstatus & STATUS_NUM)
+		if (kbdstatus & STATUS_NUM)
 			temp |= 2;
-		if(kbdstatus & STATUS_CAPS)
+		if (kbdstatus & STATUS_CAPS)
 			temp |= 4;
 		outkbd(0x60, temp);	/* 3 bits de poids faible pour les LEDs */
 		return 0;
 	}
-/* est ce un code etendu */
-if ((bufferscan[lastscan]==0xE0)||((kbdstatus & STATUS_NUM)&&(key>=0x47)&&(key<=0x53)&&(key!=0x4A)&&(key!=0x4e)))
-   /* exceptions */
- {
- /* '/' (E035) */
- if (key==0x35) return '/';
-  /* '\r' (E01C) 2ème enter numérique*/
- if (key==0x1C) return '\r';
- /* 0x11 (E048) device control 1)*/
- if (key==0x48) return 0x11;
-  /* 0x12 (E050) device control 2)*/
-  if (key==0x50) return 0x12;
-  /* 0x13 (E04b) device control 3)*/
- if (key==0x4b) return 0x13;
- /* 0x14 (E04d) device control 4)*/
- if (key==0x4d) return 0x14;
-  /* 0x02 (E049) start of text)*/
- if (key==0x49) return 0x2;
-  /* 0x03 (E051) end of text)*/
- if (key==0x51) return 0x3;
- /* 0x10 (E047) Line feed)*/
- if (key==0x47) return '\n';
- /* 0x1A (E052) Substitution)*/
- if (key==0x52) return 0x1A;
- /* 0x18 (E053) Cancel)*/
- if (key==0x53) return 0x18;
- /* 0x19 (E04f) End of medium)*/
- if (key==0x4f) return 0x19;
- return 0x00;
- } 
- else
- {
-/* detecte les SCANCODES invalides */
-	if(key >= sizeof(set1_normal) / sizeof(set1_normal[0])) return 0;
-/* converti le scancode en code ASCII en fonction du statut*/
-  if (kbdstatus & STATUS_SHIFT||kbdstatus & STATUS_CAPS)
-  	temp = set1_shift[key];
-  else if ((kbdstatus & STATUS_ALT)&&(kbdstatus & STATUS_CTRL))
- 	temp = set1_altgr[key];
-  else if (kbdstatus & STATUS_CTRL)
- 	temp = set1_ctrl[key]; 	
- 	else if (kbdstatus & STATUS_ALT)
- 	temp = set1_alt[key]; 	
-  	else
-  temp = set1_normal[key];
- }
-  
-/* si scancode non reconnu fin de fonction */
-	if(temp == 0) return temp;
 /* Appuie de CRTL + ALT + SUPR ? */
-	if((kbdstatus & STATUS_CTRL) && (kbdstatus & STATUS_ALT) &&
-		(key == 76))
+	if ((kbdstatus & STATUS_CTRL) && (kbdstatus & STATUS_ALT)
+	    && (key == 73))
 	{
 		print("redemarrage du systeme");
 		reboot();
 	}
+/* est ce un code etendu */
+	if ((bufferscan[lastscan] == 0xE0)
+	    || ((kbdstatus & STATUS_NUM) && (key >= 0x47) && (key <= 0x53)
+		&& (key != 0x4A) && (key != 0x4e)))
+		/* exceptions */
+	{
+		/* '/' (E035) */
+		if (key == 0x35)
+			return '/';
+		/* '\r' (E01C) 2ème enter numérique */
+		if (key == 0x1C)
+			return '\r';
+		/* 0x11 (E048) device control 1) */
+		if (key == 0x48)
+			return 0x11;
+		/* 0x12 (E050) device control 2) */
+		if (key == 0x50)
+			return 0x12;
+		/* 0x13 (E04b) device control 3) */
+		if (key == 0x4b)
+			return 0x13;
+		/* 0x14 (E04d) device control 4) */
+		if (key == 0x4d)
+			return 0x14;
+		/* 0x02 (E049) start of text) */
+		if (key == 0x49)
+			return 0x2;
+		/* 0x03 (E051) end of text) */
+		if (key == 0x51)
+			return 0x3;
+		/* 0x10 (E047) Line feed) */
+		if (key == 0x47)
+			return '\n';
+		/* 0x1A (E052) Substitution) */
+		if (key == 0x52)
+			return 0x1A;
+		/* 0x18 (E053) Cancel) */
+		if (key == 0x53)
+			return 0x18;
+		/* 0x19 (E04f) End of medium) */
+		if (key == 0x4f)
+			return 0x19;
+		return 0x00;
+	}
+	else
+	{
+/* detecte les SCANCODES invalides */
+		if (key >= sizeof(set1_normal) / sizeof(set1_normal[0]))
+			return 0;
+/* converti le scancode en code ASCII en fonction du statut*/
+		if (kbdstatus & STATUS_SHIFT || kbdstatus & STATUS_CAPS)
+			temp = set1_shift[key];
+		else if ((kbdstatus & STATUS_ALT)
+			 && (kbdstatus & STATUS_CTRL))
+			temp = set1_altgr[key];
+		else if (kbdstatus & STATUS_CTRL)
+			temp = set1_ctrl[key];
+		else if (kbdstatus & STATUS_ALT)
+			temp = set1_alt[key];
+		else
+			temp = set1_normal[key];
+	}
+/* si scancode non reconnu fin de fonction */
+	if (temp == 0)
+		return temp;
 /* Renvoie le Code ascii */
 	return temp;
 }
 
-
 /******************************************************************************/
+/* Handler d'interruption IRQ 1 pour le clavier */
 
-void keyboard()
+__attribute__((interrupt)) void keyboard_handler(exception_stack_noerror *caller)
 {
-cli();
-pushf();
-pushad();
-u8 scancode,ascii;
-cli();
-while ((inb(0x64)&1)==0);
-scancode=inb(0x60);
-ascii = convert(scancode);
-if(ascii != 0) 
-{
-ptrascii++;
-if (ptrascii==255) ptrascii==0;
-bufferascii[ptrascii]=ascii;
-}
-irqendmaster();
- popad();
-    popf();
+	cli();
+	u8      scancode, ascii;
+	while ((inb(0x64) & 1) == 0);
+	scancode = inb(0x60);
+	ascii = convert(scancode);
+	if (ascii != 0)
+	{
+		ptrascii++;
+		if (ptrascii == 255)
+			ptrascii == 0;
+		bufferascii[ptrascii] = ascii;
+	}
+	irqendmaster();
 	sti();
-    asm("addl  $0x01C, %esp;");
-    iret();
 }
 
 /******************************************************************************/

lib/makefile

@@ -1,16 +1,61 @@
-CC=gcc -O0 -g -nostdinc -ffreestanding -fno-builtin -fomit-frame-pointer -Wall -w -m32 -F pe-i386 -I ../include
+CC=gcc -O0 -g -nostdinc -ffreestanding -fno-builtin -Wall -w -m32 -F elf_i386 -fno-pie -no-pie -I ../include -c
+ASM=gcc -nostdinc -ffreestanding -fno-builtin -m32 -c -fno-pie -no-pie
 LINK=ld -m elf_i386 -r -o
-OBJS=memory.o vga.o port.o video.o mouse.o idt.o timer.o keyboard.o types.o string.o graph.o 3d.o math.o cpu.o
+SRCS= $(wildcard *.c)
+OBJS= $(SRCS:.c=.o)
+SRCASM= $(wildcard *.S)
+OBJASM= $(SRCASM:.S=.o)
+CONVERT=dos2unix
+INDENT=indent -nhnl -l75 -ppi3 -ts8 -bls -nbc -di8 -nbad -nbap -nsob -i8 -bl -bli0 -ncdw -nce -cli8 -cbi0 -npcs -cs -saf -sai -saw -nprs -lp -npsl
+REMOVE=rm -f
+CHANGEPERM=chmod 644
+SYNC=sync
 
-all: makeall
+all: libs.o
+	$(SYNC)
 
-makeall: libs.o
+togit: clean indent
 
-libs.o:$(OBJS)
-	$(LINK) libs.o $(OBJS)
+libs.o:$(OBJS) $(OBJASM)
+	$(LINK) libs.o $(OBJS) $(OBJASM)
 
+.o: .S
+		$(ASM) $^
+
+handlers.o:handlers.c
+		$(CC) -mgeneral-regs-only $^
+
+keyboard.o:keyboard.c
+		$(CC) -mgeneral-regs-only $^
+
+mouse.o:mouse.c
+		$(CC) -mgeneral-regs-only $^
+
+syscall.o:syscall.c
+		$(CC) -fomit-frame-pointer $^
 .o: .c 
 	$(CC) $^
-clean:
-	rm -f *.o
+
+clean:
+	$(REMOVE) *.o
+	$(REMOVE) *.c~
+	$(REMOVE) */*.c~
+	$(REMOVE) ../include/*.h~
+	$(REMOVE) ./TEST/*.c
+	$(SYNC)
+
+indent:
+	$(CHANGEPERM) *.c
+	$(CONVERT) *.c
+	$(INDENT) *.c
+	$(REMOVE) *.c~
+	$(CHANGEPERM) ./*/*.c
+	$(CONVERT) ./*/*.c
+	$(INDENT) ./*/*.c
+	$(REMOVE) */*.c~
+	$(CHANGEPERM) ../include/*.h
+	$(CONVERT) ../include/*.h
+	$(INDENT) ../include/*.h
+	$(REMOVE) ../include/*.h~
+	$(SYNC)
 

lib/math.c

@@ -1,7 +1,312 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
+#include "timer.h"
+#include "math.h"
+
+/*******************************************************************************/
+/* Calcule un checksum 32 bits  */
+
+u32 crc32(u32 inCrc32, u8 *buf, u32 size)
+{
+    static const u32 crcTable[256] = {
+   0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,
+   0x9E6495A3,0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,
+   0xE7B82D07,0x90BF1D91,0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,
+   0x6DDDE4EB,0xF4D4B551,0x83D385C7,0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,
+   0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,0x3B6E20C8,0x4C69105E,0xD56041E4,
+   0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,0x35B5A8FA,0x42B2986C,
+   0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,0x26D930AC,
+   0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,
+   0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,
+   0xB6662D3D,0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,
+   0x9FBFE4A5,0xE8B8D433,0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,
+   0x086D3D2D,0x91646C97,0xE6635C01,0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,
+   0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,0x65B0D9C6,0x12B7E950,0x8BBEB8EA,
+   0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,0x4DB26158,0x3AB551CE,
+   0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB,0x4369E96A,
+   0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,
+   0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,
+   0xCE61E49F,0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,
+   0xB7BD5C3B,0xC0BA6CAD,0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,
+   0x9DD277AF,0x04DB2615,0x73DC1683,0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,
+   0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,0xF00F9344,0x8708A3D2,0x1E01F268,
+   0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7,0xFED41B76,0x89D32BE0,
+   0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,0xD6D6A3E8,
+   0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,
+   0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,
+   0x4669BE79,0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,
+   0x220216B9,0x5505262F,0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,
+   0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,
+   0x9C0906A9,0xEB0E363F,0x72076785,0x05005713,0x95BF4A82,0xE2B87A14,0x7BB12BAE,
+   0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,0x86D3D2D4,0xF1D4E242,
+   0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,0x88085AE6,
+   0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45,
+   0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,
+   0x3E6E77DB,0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,
+   0x47B2CF7F,0x30B5FFE9,0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,
+   0xCDD70693,0x54DE5729,0x23D967BF,0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,
+   0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D };
+    u32 crc32;
+    u8 *byteBuf;
+    u32 i;
+    crc32 = inCrc32 ^ 0xFFFFFFFF;
+    byteBuf = (u8*) buf;
+    for (i=0; i < size; i++) {
+        crc32 = (crc32 >> 8) ^ crcTable[ (crc32 ^ byteBuf[i]) & 0xFF ];
+    }
+    return( crc32 ^ 0xFFFFFFFF );
+}
+
+/*******************************************************************************/
+/* Arithmétique 64 bits  */
+
+unsigned long long __udivdi3(unsigned long long num,
+			     unsigned long long den)
+{
+	unsigned long long quot, qbit;
+	quot = 0;
+	qbit = 1;
+	if (den == 0)
+	{
+		return 0;
+	}
+	while ((long long) den >= 0)
+	{
+		den <<= 1;
+		qbit <<= 1;
+	}
+	while (qbit)
+	{
+		if (den <= num)
+		{
+			num -= den;
+			quot += qbit;
+		}
+		den >>= 1;
+		qbit >>= 1;
+	}
+	return quot;
+}
+
+unsigned long long __umoddi3(unsigned long long n, unsigned long long d)
+{
+	return n - d * __udivdi3(n, d);
+}
+
+/******************************************************************************/
+/* Fonctions qui retournent le sinus et cosinus */
+
+double cos(double x)
+{
+	if (x < 0.0)
+		x = -x;
+	while (M_PI < x)
+		x -= M_2_PI;
+	double  result =
+		1.0 - (x * x / 2.0) * (1.0 -
+				       (x * x / 12.0) * (1.0 -
+							 (x * x / 30.0) *
+							 (1.0 -
+							  x * x / 56.0)));
+	return result;
+}
+
+double sin(double x)
+{
+	return cos(x - M_PI_2);
+}
+
+float cosf(float x)
+{
+	if (x < 0.0f)
+		x = -x;
+	while (M_PI < x)
+		x -= M_2_PI;
+	float   result =
+		1.0f - (x * x / 2.0f) * (1.0f -
+					 (x * x / 12.0f) * (1.0f -
+							    (x * x /
+							     30.0f) *
+							    (1.0f -
+							     x * x /
+							     56.0f)));
+	return result;
+}
+
+float sinf(float x)
+{
+	return cosf(x - M_PI_2);
+}
+
+/******************************************************************************/
+/* Fonction qui retourne la valeur absolue */
+
+float fabsf(float n)
+{
+	return (*((int *) &n) &= 0x7fffffff);
+}
+
+double fabs(double n)
+{
+	return (*(((int *) &n) + 1) &= 0x7fffffff);
+}
+
+/******************************************************************************/
+/* Fonction qui retourne la racine */
+
+float sqrtf(float n)
+{
+	float   x = n;
+	float   y = 1;
+	double  e = 0.000001;
+	while (x - y > e)
+	{
+		x = (x + y) / 2;
+		y = n / x;
+	}
+	return x;
+}
+
+double sqrt(double n)
+{
+	double  x = n;
+	double  y = 1;
+	double  e = 0.000001;
+	while (x - y > e)
+	{
+		x = (x + y) / 2;
+		y = n / x;
+	}
+	return x;
+}
+
+/******************************************************************************/
+/* Fonction qui retourne l'inverse de la racine */
+
+float rsqrtf(float n)
+{
+	return 1 / sqrt(n);
+}
+
+double rsqrt(double n)
+{
+	return 1 / sqrt(n);
+}
+
+/******************************************************************************/
+/* Fonction qui retourne la puissance n de a */
+
+u32 pow(u32 a, u8 n)
+{
+	u32     r = 1;
+	while (n > 0)
+	{
+		if (n & 1)
+			r *= a;
+		a *= a;
+		n >>= 1;
+	}
+	return r;
+}
+
+/******************************************************************************/
+/* Fonction qui retourne le logarithme 2 */
+
+u8 log2(u64 n)
+{
+	if (n == 0)
+		return 0;
+	int     logValue = -1;
+	while (n)
+	{
+
+		logValue++;
+
+		n >>= 1;
+
+	}
+	return logValue + 1;
+}
+
+/******************************************************************************/
+/* Fonction qui retourne le logarithme 10 */
+
+u8 log10(u64 n)
+{
+
+	return (n >= 10000000000000000000u) ? 19 : (n >=
+						    100000000000000000u) ?
+		18 : (n >= 100000000000000000u) ? 17 : (n >=
+							10000000000000000u)
+		? 16 : (n >= 1000000000000000u) ? 15 : (n >=
+							100000000000000u) ?
+		14 : (n >= 10000000000000u) ? 13 : (n >=
+						    1000000000000u) ? 12
+		: (n >= 100000000000u) ? 11 : (n >=
+					       10000000000u) ? 10 : (n >=
+								     1000000000u)
+		? 9 : (n >= 100000000u) ? 8 : (n >= 10000000u) ? 7 : (n >=
+								      1000000u)
+		? 6 : (n >= 100000u) ? 5 : (n >= 10000u) ? 4 : (n >=
+								1000u) ? 3
+		: (n >= 100u) ? 2 : (n >= 10u) ? 1u : 0u;
+
+}
+
+
+/******************************************************************************/
+/* Fonction qui retourne la valeur absolue */
 
 u32 abs(int x)
 {
-if (x<0) x=-x;
-return (u32)x;
+	if (x < 0)
+
+		x = -x;
+
+	return (u32) x;
 }
+
+/******************************************************************************/
+/* Fonction qui initialise le générateur de nombre aléatoire */
+
+static u32 seed = 0x12341234;
+
+void randomize(void)
+{
+	seed = gettimer();
+}
+
+
+/******************************************************************************/
+/* Fonction qui renvoie un nombre aléatoire */
+
+u32 rand(void)
+{
+	u32     next = seed;
+	int     result;
+	next *= 1103515245;
+	next += 12345;
+	result = (unsigned int) (next / 65536) % 2048;
+	next *= 1103515245;
+	next += 12345;
+	result <<= 10;
+	result ^= (unsigned int) (next / 65536) % 1024;
+	next *= 1103515245;
+	next += 12345;
+	result <<= 10;
+	result ^= (unsigned int) (next / 65536) % 1024;
+	seed = next;
+	return result;
+}
+
+/******************************************************************************/
+/* Fonction qui renvoie un nombre aléatoire borné */
+
+u32 random(u32 lower, u32 upper)
+{
+	return (rand() % (upper - lower + 1)) + lower;
+}
+
+/*******************************************************************************/

lib/matrix.c

@@ -0,0 +1,653 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "matrix.h"
+#include "types.h"
+#include "math.h"
+
+/*******************************************************************************/
+/* Affiche un vecteur de 4 composantes */
+
+void vector4_show(vector4 src)
+{
+	printf("vecteur: X=%f Y=%f Z=%f W=%f \r\n", src.x, src.y, src.z,
+	       src.w);
+}
+
+/*******************************************************************************/
+/* Créé un vecteur de 4 composantes */
+
+void vector4_create(float x, float y, float z, float w, vector4 * dst)
+{
+	dst->x = x;
+	dst->y = y;
+	dst->z = z;
+	dst->w = w;
+}
+
+/*******************************************************************************/
+/* Copie un vecteur de 4 composantes */
+
+void vector4_copy(vector4 src, vector4 * dst)
+{
+	vector4_create(src.x, src.y, src.z, src.w, dst);
+}
+
+/*******************************************************************************/
+/* Ajoute deux vecteurs de 4 composantes */
+
+void vector4_add(vector4 v1, vector4 v2, vector4 * dst)
+{
+	dst->x = v1.x + v2.x;
+	dst->y = v1.y + v2.y;
+	dst->z = v1.z + v2.z;
+}
+
+/*******************************************************************************/
+/* Soustrait un vecteur de 4 composantes depuis un autre*/
+
+void vector4_sub(vector4 v1, vector4 v2, vector4 * dst)
+{
+	dst->x = v1.x - v2.x;
+	dst->y = v1.y - v2.y;
+	dst->z = v1.z - v2.z;
+}
+
+/*******************************************************************************/
+/* Redimensionne un vecteur de 4 composantes */
+
+void vector4_scale(vector4 * dst, float factor)
+{
+	dst->x *= factor;
+	dst->y *= factor;
+	dst->z *= factor;
+	dst->w *= factor;
+}
+
+/*******************************************************************************/
+/* Calcule le produit vectoriel de deux vecteurs de 4 composantes */
+
+void vector4_crossproduct(vector4 v1, vector4 v2, vector4 * dst)
+{
+	dst->x = v1.y * v2.z - v1.z * v2.y;
+	dst->y = v1.z * v2.x - v1.x * v2.z;
+	dst->z = v1.x * v2.y - v1.y * v2.x;
+}
+
+/*******************************************************************************/
+/* Normalise un vecteur de 4 composantes */
+
+void vector4_normalize(vector4 * dst)
+{
+	float   len;
+	float   norm;
+	norm = vector4_norm(*dst);
+	if (norm != 0)
+	{
+		len = 1 / norm;
+		dst->x = dst->x * len;
+		dst->y = dst->y * len;
+		dst->z = dst->z * len;
+		dst->w = 0;
+	}
+}
+
+/*******************************************************************************/
+/* Divise un vecteur de 4 composantes depuis un autre*/
+
+void vector4_divide(vector4 * v1, vector4 v2, vector4 * dst)
+{
+	dst->x = v1->x / v2.x;
+	dst->y = v1->y / v2.y;
+	dst->z = v1->z / v2.z;
+}
+
+/*******************************************************************************/
+/* Détermine le 3ème vecteur perpendiculaire au 2 autres */
+
+void vector4_perpendicular(vector4 v1, vector4 v2, vector4 * dst)
+{
+	float   dot = vector4_dotproduct(v1, v2);
+	dst->x = v1.x - dot * v2.x;
+	dst->y = v1.y - dot * v2.y;
+	dst->z = v1.z - dot * v2.z;
+}
+
+/*******************************************************************************/
+/* Tourne un vecteur à 4 composantes autour de X */
+
+void vector4_rotate_x(vector4 * dst, float angle)
+{
+	vector4 origin;
+	float   sinus, cosinus;
+	sinus = sinf(angle);
+	cosinus = cosf(angle);
+	origin.x = dst->x;
+	origin.y = dst->y;
+	origin.z = dst->z;
+	dst->y = cosinus * origin.y + sinus * origin.z;
+	dst->z = cosinus * origin.z - sinus * origin.y;
+}
+
+/*******************************************************************************/
+/* Tourne un vecteur à 4 composantes autour de Y */
+
+void vector4_rotate_y(vector4 * dst, float angle)
+{
+	vector4 origin;
+	float   sinus, cosinus;
+	sinus = sinf(angle);
+	cosinus = cosf(angle);
+	origin.x = dst->x;
+	origin.y = dst->y;
+	origin.z = dst->z;
+	dst->x = cosinus * origin.x + sinus * origin.z;
+	dst->z = cosinus * origin.z - sinus * origin.x;
+}
+
+/*******************************************************************************/
+/* Tourne un vecteur à 4 composantes autour de Z */
+
+void vector4_rotate_z(vector4 * dst, float angle)
+{
+	vector4 origin;
+	float   sinus, cosinus;
+	sinus = sinf(angle);
+	cosinus = cosf(angle);
+	origin.x = dst->x;
+	origin.y = dst->y;
+	origin.z = dst->z;
+	dst->x = cosinus * origin.x + sinus * origin.y;
+	dst->y = cosinus * origin.y - sinus * origin.x;
+}
+
+/*******************************************************************************/
+/* Donne la longueur d'un vecteur à 4 composantes */
+
+float vector4_len(vector4 src)
+{
+	return sqrtf((src.x * src.x) + (src.y * src.y) + (src.z * src.z));
+}
+
+/*******************************************************************************/
+/* Retourne le produit scalaire de deux vecteurs à 4 composantes */
+
+float vector4_dotproduct(vector4 v1, vector4 v2)
+{
+	return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
+}
+
+/*******************************************************************************/
+/* Retourne la norme d'un vecteur à 4 composantes */
+
+float vector4_norm(vector4 src)
+{
+	return sqrtf((src.x * src.x) + (src.y * src.y) + (src.z * src.z));
+}
+
+/*******************************************************************************/
+/* Retourne la distance de deux vecteurs à 4 composantes */
+
+float vector4_distance(vector4 v1, vector4 v2)
+{
+	return sqrt(pow(v2.x - v1.x, 2) + pow(v2.y - v1.y, 2) +
+		    pow(v2.z - v1.z, 2));
+}
+
+/*******************************************************************************/
+/* Compare deux vecteurs à 4 composantes */
+
+int vector4_isequals(vector4 v1, vector4 v2)
+{
+	float   x, y, z;
+	x = fabsf(v1.x - v2.x);
+	y = fabsf(v1.y - v2.y);
+	z = fabsf(v1.z - v2.z);
+	return (x < 0.000001 && y < 0.000001 && z < 0.000001);
+}
+
+/*******************************************************************************/
+/* Définie le plan normal à 3 vecteurs à 4 composantes */
+
+void vector4_planenormal(vector4 v1, vector4 v2, vector4 v3, vector4 * dst)
+{
+	vector4 temp1, temp2;
+	vector4_sub(v2, v1, &temp1);
+	vector4_sub(v3, v1, &temp2);
+	vector4_crossproduct(temp1, temp2, dst);
+	vector4_normalize(dst);
+}
+
+/*******************************************************************************/
+/* Créé une matrice d'identité */
+
+void matrix44_homogen(matrix44 * matrix)
+{
+	vector4_create(1, 0, 0, 0, &matrix->V[0]);
+	vector4_create(0, 1, 0, 0, &matrix->V[1]);
+	vector4_create(0, 0, 1, 0, &matrix->V[2]);
+	vector4_create(0, 0, 0, 1, &matrix->V[3]);
+}
+
+/*******************************************************************************/
+/* Créé une matrice vide */
+
+void matrix44_empty(matrix44 * matrix)
+{
+	vector4_create(0, 0, 0, 0, &matrix->V[0]);
+	vector4_create(0, 0, 0, 0, &matrix->V[1]);
+	vector4_create(0, 0, 0, 0, &matrix->V[2]);
+	vector4_create(0, 0, 0, 0, &matrix->V[3]);
+}
+
+/*******************************************************************************/
+/* Créé une matrice de redimensionnement (par un vecteur) */
+
+void matrix44_scaling(vector4 v, matrix44 * dst)
+{
+	matrix44_homogen(dst);
+	dst->V[0].x = v.x;
+	dst->V[1].y = v.y;
+	dst->V[2].z = v.z;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de déplacement */
+
+void matrix44_translation(vector4 v, matrix44 * dst)
+{
+	matrix44_homogen(dst);
+	dst->V[0].x = v.x;
+	dst->V[1].y = v.y;
+	dst->V[2].z = v.z;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de redimensionnement (par un facteur) */
+
+void matrix44_scale(matrix44 * dst, float factor)
+{
+	vector4_scale(&dst->V[0], factor);
+	vector4_scale(&dst->V[1], factor);
+	vector4_scale(&dst->V[2], factor);
+	vector4_scale(&dst->V[3], factor);
+}
+
+/*******************************************************************************/
+/* Créé une matrice de redimensionnement et de déplacement */
+
+void matrix44_scale_translation(vector4 scale, vector4 translation,
+				matrix44 * dst)
+{
+	matrix44_homogen(dst);
+	dst->V[0].x = scale.x;
+	dst->V[1].y = scale.y;
+	dst->V[2].z = scale.z;
+	dst->V[3].x = translation.x;
+	dst->V[3].y = translation.y;
+	dst->V[3].z = translation.z;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de rotation autour de X */
+
+void matrix44_rotation_x(float angle, matrix44 * dst)
+{
+	float   sinus, cosinus;
+	cosinus = cosf(angle);
+	sinus = sinf(angle);
+	matrix44_empty(dst);
+	dst->V[0].x = 1;
+	dst->V[1].y = cosinus;
+	dst->V[1].z = sinus;
+	dst->V[2].y = -1 * sinus;
+	dst->V[2].z = cosinus;
+	dst->V[3].w = 1;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de rotation autour de Y */
+
+void matrix44_rotation_y(float angle, matrix44 * dst)
+{
+	float   sinus, cosinus;
+	cosinus = cosf(angle);
+	sinus = sinf(angle);
+	matrix44_empty(dst);
+	dst->V[0].x = cosinus;
+	dst->V[0].z = -1 * sinus;
+	dst->V[1].y = 1;
+	dst->V[2].x = sinus;
+	dst->V[2].z = cosinus;
+	dst->V[3].w = 1;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de rotation autour de Z */
+
+void matrix44_rotation_z(float angle, matrix44 * dst)
+{
+	float   sinus, cosinus;
+	cosinus = cosf(angle);
+	sinus = sinf(angle);
+	matrix44_empty(dst);
+	dst->V[0].x = cosinus;
+	dst->V[0].y = sinus;
+	dst->V[1].x = -1 * sinus;
+	dst->V[1].y = cosinus;
+	dst->V[2].z = 1;
+	dst->V[3].w = 1;
+}
+
+/*******************************************************************************/
+/* Créé une matrice de rotation multiple */
+
+void matrix44_rotation(vector4 axis, float angle, matrix44 * dst)
+{
+	float   cosinus, sinus, minuscos;
+	sinus = sinf(angle);
+	cosinus = cosf(angle);
+	vector4_normalize(&axis);
+	minuscos = 1 - cosinus;
+
+	dst->V[0].x = (minuscos * axis.x * axis.x) + cosinus;
+	dst->V[0].y = (minuscos * axis.x * axis.y) - (axis.z * sinus);
+	dst->V[0].z = (minuscos * axis.z * axis.x) + (axis.y * sinus);
+	dst->V[0].w = 0;
+
+	dst->V[1].x = (minuscos * axis.x * axis.y) + (axis.z * sinus);
+	dst->V[1].y = (minuscos * axis.y * axis.y) + cosinus;
+	dst->V[1].z = (minuscos * axis.y * axis.z) - (axis.x * sinus);
+	dst->V[1].w = 0;
+
+	dst->V[2].x = (minuscos * axis.z * axis.x) - (axis.y * sinus);
+	dst->V[2].y = (minuscos * axis.y * axis.z) + (axis.x * sinus);
+	dst->V[2].z = (minuscos * axis.z * axis.z) + cosinus;
+	dst->V[2].w = 0;
+
+	dst->V[3].x = 0;
+	dst->V[3].y = 0;
+	dst->V[3].z = 0;
+	dst->V[3].w = 1;
+}
+
+/*******************************************************************************/
+/* Multiplie deux matrices */
+
+void matrix44_multiply(matrix44 * m1, matrix44 * m2, matrix44 * dst)
+{
+	dst->V[0].x =
+		(m1->V[0].x * m2->V[0].x + m1->V[0].y * m2->V[1].x +
+		 m1->V[0].z * m2->V[2].x + m1->V[0].w * m2->V[3].x);
+	dst->V[0].y =
+		(m1->V[0].x * m2->V[0].y + m1->V[0].y * m2->V[1].y +
+		 m1->V[0].z * m2->V[2].y + m1->V[0].w * m2->V[3].y);
+	dst->V[0].z =
+		(m1->V[0].x * m2->V[0].z + m1->V[0].y * m2->V[1].z +
+		 m1->V[0].z * m2->V[2].z + m1->V[0].w * m2->V[3].z);
+	dst->V[0].w =
+		(m1->V[0].x * m2->V[0].w + m1->V[0].y * m2->V[1].w +
+		 m1->V[0].z * m2->V[2].w + m1->V[0].w * m2->V[3].w);
+	dst->V[1].x =
+		(m1->V[1].x * m2->V[0].x + m1->V[1].y * m2->V[1].x +
+		 m1->V[1].z * m2->V[2].x + m1->V[1].w * m2->V[3].x);
+	dst->V[1].y =
+		(m1->V[1].x * m2->V[0].y + m1->V[1].y * m2->V[1].y +
+		 m1->V[1].z * m2->V[2].y + m1->V[1].w * m2->V[3].y);
+	dst->V[1].z =
+		(m1->V[1].x * m2->V[0].z + m1->V[1].y * m2->V[1].z +
+		 m1->V[1].z * m2->V[2].z + m1->V[1].w * m2->V[3].z);
+	dst->V[1].w =
+		(m1->V[1].x * m2->V[0].w + m1->V[1].y * m2->V[1].w +
+		 m1->V[1].z * m2->V[2].w + m1->V[1].w * m2->V[3].w);
+	dst->V[2].x =
+		(m1->V[2].x * m2->V[0].x + m1->V[2].y * m2->V[1].x +
+		 m1->V[2].z * m2->V[2].x + m1->V[2].w * m2->V[3].x);
+	dst->V[2].y =
+		(m1->V[2].x * m2->V[0].y + m1->V[2].y * m2->V[1].y +
+		 m1->V[2].z * m2->V[2].y + m1->V[2].w * m2->V[3].y);
+	dst->V[2].z =
+		(m1->V[2].x * m2->V[0].z + m1->V[2].y * m2->V[1].z +
+		 m1->V[2].z * m2->V[2].z + m1->V[2].w * m2->V[3].z);
+	dst->V[2].w =
+		(m1->V[2].x * m2->V[0].w + m1->V[2].y * m2->V[1].w +
+		 m1->V[2].z * m2->V[2].w + m1->V[2].w * m2->V[3].w);
+	dst->V[3].x =
+		(m1->V[3].x * m2->V[0].x + m1->V[3].y * m2->V[1].x +
+		 m1->V[3].z * m2->V[2].x + m1->V[3].w * m2->V[3].x);
+	dst->V[3].y =
+		(m1->V[3].x * m2->V[0].y + m1->V[3].y * m2->V[1].y +
+		 m1->V[3].z * m2->V[2].y + m1->V[3].w * m2->V[3].y);
+	dst->V[3].z =
+		(m1->V[3].x * m2->V[0].z + m1->V[3].y * m2->V[1].z +
+		 m1->V[3].z * m2->V[2].z + m1->V[3].w * m2->V[3].z);
+	dst->V[3].w =
+		(m1->V[3].x * m2->V[0].w + m1->V[3].y * m2->V[1].w +
+		 m1->V[3].z * m2->V[2].w + m1->V[3].w * m2->V[3].w);
+}
+
+/*******************************************************************************/
+/* Transforme une matrice avec un vecteur à 4 composantes */
+
+void matrix44_transform(matrix44 * matrix, vector4 * dst)
+{
+	vector4 origin;
+	origin.x = dst->x;
+	origin.y = dst->y;
+	origin.z = dst->z;
+	origin.w = dst->w;
+	dst->x = origin.x * matrix->V[0].x + origin.y * matrix->V[1].x +
+		origin.z * matrix->V[2].x + origin.w * matrix->V[3].x;
+	dst->y = origin.x * matrix->V[0].y + origin.y * matrix->V[1].y +
+		origin.z * matrix->V[2].y + origin.w * matrix->V[3].y;
+	dst->z = origin.x * matrix->V[0].z + origin.y * matrix->V[1].z +
+		origin.z * matrix->V[2].z + origin.w * matrix->V[3].z;
+	dst->w = origin.x * matrix->V[0].w + origin.y * matrix->V[1].w +
+		origin.z * matrix->V[2].w + origin.w * matrix->V[3].w;
+}
+
+/*******************************************************************************/
+/* Calcule le déterminant d'une matrice */
+
+float matrix44_determinant(matrix44 * matrix)
+{
+	float   a, b, c, d;
+	a = matrix->V[0].x * todeterminant(matrix->V[1].y, matrix->V[2].y,
+					   matrix->V[3].y, matrix->V[1].z,
+					   matrix->V[2].z, matrix->V[3].z,
+					   matrix->V[1].w, matrix->V[2].w,
+					   matrix->V[3].w);
+	b = matrix->V[0].y * todeterminant(matrix->V[1].x, matrix->V[2].x,
+					   matrix->V[3].x, matrix->V[1].z,
+					   matrix->V[2].z, matrix->V[3].z,
+					   matrix->V[1].w, matrix->V[2].w,
+					   matrix->V[3].w);
+	c = matrix->V[0].z * todeterminant(matrix->V[1].x, matrix->V[2].x,
+					   matrix->V[3].x, matrix->V[1].y,
+					   matrix->V[2].y, matrix->V[3].y,
+					   matrix->V[1].w, matrix->V[2].w,
+					   matrix->V[3].w);
+	d = matrix->V[0].w * todeterminant(matrix->V[1].x, matrix->V[2].x,
+					   matrix->V[3].x, matrix->V[1].y,
+					   matrix->V[2].y, matrix->V[3].y,
+					   matrix->V[1].z, matrix->V[2].z,
+					   matrix->V[3].z);
+	return a - b + c - d;
+}
+
+float todeterminant(float a1, float a2, float a3, float b1, float b2,
+		    float b3, float c1, float c2, float c3)
+{
+	return (a1 * ((b2 * c3) - (b3 * c2))) -
+		(b1 * ((a2 * c3) - (a3 * c2))) +
+		(c1 * ((a2 * b3) - (a3 * b2)));
+}
+
+/*******************************************************************************/
+/* Crée une matrice adjointe */
+
+void matrix44_adjoint(matrix44 * matrix)
+{
+	float   a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3,
+		d4;
+	a1 = matrix->V[0].x;
+	b1 = matrix->V[0].y;
+	c1 = matrix->V[0].z;
+	d1 = matrix->V[0].w;
+
+	a2 = matrix->V[1].x;
+	b2 = matrix->V[1].y;
+	c2 = matrix->V[1].z;
+	d2 = matrix->V[1].w;
+
+	a3 = matrix->V[2].x;
+	b3 = matrix->V[2].y;
+	c3 = matrix->V[2].z;
+	d3 = matrix->V[2].w;
+
+	a4 = matrix->V[3].x;
+	b4 = matrix->V[3].y;
+	c4 = matrix->V[3].z;
+	d4 = matrix->V[3].w;
+
+	matrix->V[0].x = todeterminant(b2, b3, b4, c2, c3, c4, d2, d3, d4);
+	matrix->V[1].x =
+		-todeterminant(a2, a3, a4, c2, c3, c4, d2, d3, d4);
+	matrix->V[2].x = todeterminant(a2, a3, a4, b2, b3, b4, d2, d3, d4);
+	matrix->V[3].x =
+		-todeterminant(a2, a3, a4, b2, b3, b4, c2, c3, c4);
+
+	matrix->V[0].y =
+		-todeterminant(b1, b3, b4, c1, c3, c4, d1, d3, d4);
+	matrix->V[1].y = todeterminant(a1, a3, a4, c1, c3, c4, d1, d3, d4);
+	matrix->V[2].y =
+		-todeterminant(a1, a3, a4, b1, b3, b4, d1, d3, d4);
+	matrix->V[3].y = todeterminant(a1, a3, a4, b1, b3, b4, c1, c3, c4);
+
+	matrix->V[0].z = todeterminant(b1, b2, b4, c1, c2, c4, d1, d2, d4);
+	matrix->V[1].z =
+		-todeterminant(a1, a2, a4, c1, c2, c4, d1, d2, d4);
+	matrix->V[2].z = todeterminant(a1, a2, a4, b1, b2, b4, d1, d2, d4);
+	matrix->V[3].z =
+		-todeterminant(a1, a2, a4, b1, b2, b4, c1, c2, c4);
+
+	matrix->V[0].w =
+		-todeterminant(b1, b2, b3, c1, c2, c3, d1, d2, d3);
+	matrix->V[1].w = todeterminant(a1, a2, a3, c1, c2, c3, d1, d2, d3);
+	matrix->V[2].w =
+		-todeterminant(a1, a2, a3, b1, b2, b3, d1, d2, d3);
+	matrix->V[3].w = todeterminant(a1, a2, a3, b1, b2, b3, c1, c2, c3);
+}
+
+/*******************************************************************************/
+/* Affiche une matrice */
+
+void matrix44_show(matrix44 * matrix)
+{
+	printf("Matrice: X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
+	       matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
+	printf("         X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
+	       matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
+	printf("         X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
+	       matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
+}
+
+/*******************************************************************************/
+/* Inverse une matrice */
+
+void matrix44_invert(matrix44 * matrix)
+{
+	float   det;
+	det = matrix44_determinant(matrix);
+	if (fabs(det) < EPSILON)
+	{
+		matrix44_homogen(matrix);
+	}
+	else
+	{
+		matrix44_adjoint(matrix);
+		matrix44_scale(matrix, 1.0 / det);
+	}
+}
+
+/*******************************************************************************/
+/* Transpose une matrice */
+
+void matrix44_transpose(matrix44 * matrix)
+{
+	float   f;
+	f = matrix->V[0].y;
+	matrix->V[0].y = matrix->V[1].x;
+	matrix->V[1].x = f;
+
+	f = matrix->V[0].z;
+	matrix->V[0].z = matrix->V[2].x;
+	matrix->V[2].x = f;
+
+	f = matrix->V[0].w;
+	matrix->V[0].w = matrix->V[3].x;
+	matrix->V[3].x = f;
+
+	f = matrix->V[1].z;
+	matrix->V[1].z = matrix->V[2].y;
+	matrix->V[2].y = f;
+
+	f = matrix->V[1].w;
+	matrix->V[1].w = matrix->V[3].y;
+	matrix->V[3].y = f;
+
+	f = matrix->V[2].w;
+	matrix->V[2].w = matrix->V[3].z;
+	matrix->V[3].z = f;
+}
+
+/*******************************************************************************/
+/* Crée une matrice de camera */
+
+void matrix44_lookat(vector4 eye, vector4 dst, vector4 up,
+		     matrix44 * matrix)
+{
+	vector4 xaxis, yaxis, zaxis, negeye;
+	vector4_sub(dst, eye, &zaxis);
+	vector4_normalize(&zaxis);
+
+	vector4_crossproduct(zaxis, up, &xaxis);
+	vector4_normalize(&xaxis);
+
+	vector4_crossproduct(xaxis, zaxis, &yaxis);
+
+	vector4_copy(xaxis, &matrix->V[0]);
+	vector4_copy(yaxis, &matrix->V[1]);
+	vector4_copy(zaxis, &matrix->V[2]);
+
+	matrix->V[2].x = -matrix->V[2].x;
+	matrix->V[2].y = -matrix->V[2].y;
+	matrix->V[2].z = -matrix->V[2].z;
+
+	vector4_create(0, 0, 0, 1, &matrix->V[3]);
+
+	matrix44_transpose(matrix);
+	vector4_create(-eye.x, -eye.y, -eye.z, 1, &negeye);
+
+	matrix44_transform(matrix, &negeye);
+	vector4_copy(negeye, &matrix->V[3]);
+}
+
+/*******************************************************************************/
+/* Vérifie que deux matrices sont égales */
+
+int matrix44_isequals(matrix44 * m1, matrix44 * m2)
+{
+	return vector4_isequals(m1->V[0], m2->V[0])
+		&& vector4_isequals(m1->V[1], m2->V[1])
+		&& vector4_isequals(m1->V[2], m2->V[2])
+		&& vector4_isequals(m1->V[3], m2->V[3]);
+}
+
+/*******************************************************************************/
+/* Transforme une matrice en tableau */
+
+float  *toarray(matrix44 * m)
+{
+	return &m->v;
+}

lib/memory.c

@@ -1,45 +1,718 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
+#include "memory.h"
+#include "queue.h"
+#include "asm.h"
+#include "boot.h"
+
+static u8 *kernelcurrentheap = NULL;	/* pointeur vers le heap noyau */
+static u8 bitmap[MAXMEMPAGE / 8];	/* bitmap */
+static vrange_t vrange_head;
+static u64 memorysize=0;
+
+extern bootparams* allparams;
 
 /*******************************************************************************/
+/* Erreur fatale */
 
-/* Copie un octet une ou plusieurs fois en mémoire */
-void memset(void *dst, u8 val, u32 count,u32 size)
+void panic(u8 * string)
 {
-	u8 *temp;
-	for(temp = (u8 *)dst; count != 0; count--)
+	printf("KERNEL PANIC: %s\r\nSysteme arrete...\n");
+	halt();
+}
+
+/*******************************************************************************/
+/* Alloue plusieurs pages virtuelles (size) pour le heap du noyau */
+
+tmalloc *mallocpage(u64 size)
+{
+	tmalloc *chunk;
+	u8     *paddr;
+	u16     nbpages = size / PAGESIZE;
+	u64     realsize = nbpages * PAGESIZE;
+	if (size % PAGESIZE != 0)
+		realsize += PAGESIZE;
+	if ((kernelcurrentheap - KERNEL_HEAP + realsize) > MAXHEAPSIZE)
+		panic("Plus de memoire noyau heap disponible a allouer !\n");
+	chunk = (tmalloc *) kernelcurrentheap;
+	virtual_range_new_kernel(kernelcurrentheap, realsize);
+	kernelcurrentheap += realsize;
+	chunk->size = realsize;
+	chunk->used = 0;
+	return chunk;
+}
+
+/*******************************************************************************/
+/* Retourne le nombre de blocs dynamiques (heap) */
+
+u32 getmallocnb(void)
+{
+	u32     realsize = 0;
+	tmalloc *chunk;
+	chunk = KERNEL_HEAP;
+	while (chunk < (tmalloc *) kernelcurrentheap)
 	{
-		temp+=size;
-		*temp = val;
+		realsize++;
+		chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
+	}
+	return realsize;
+}
+
+
+/*******************************************************************************/
+/* Retourne la mémoire virtuelle utilisée de façon dynamique (heap) */
+
+u32 getmallocused(void)
+{
+	u32     realsize = 0;
+	tmalloc *chunk;
+	chunk = KERNEL_HEAP;
+	while (chunk < (tmalloc *) kernelcurrentheap)
+	{
+		if (chunk->used)
+			realsize += chunk->size;
+		chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
+	}
+	return realsize;
+}
+
+/*******************************************************************************/
+/* Retourne la mémoire virtuelle libre de façon dynamique (heap) */
+
+u32 getmallocfree(void)
+{
+	u32     realsize = 0;
+	tmalloc *chunk;
+	chunk = KERNEL_HEAP;
+	while (chunk < (tmalloc *) kernelcurrentheap)
+	{
+		if (!chunk->used)
+			realsize += chunk->size;
+		chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
+	}
+	return realsize;
+}
+
+/*******************************************************************************/
+/* Retourne la mémoire virtuelle non allouée de façon dynamique (heap) */
+
+u32 getmallocnonallocated(void)
+{
+	return VESA_FBMEM - ((u32) kernelcurrentheap);
+}
+
+/*******************************************************************************/
+/* Alloue de la mémoire virtuelle au noyau de façon dynamique (heap) */
+
+void   *vmalloc(u32 size)
+{
+	u32     realsize;
+	tmalloc *chunk, *new;
+	realsize = sizeof(tmalloc) + size;
+	if (realsize < MALLOC_MINIMUM)
+		realsize = MALLOC_MINIMUM;
+	chunk = KERNEL_HEAP;
+	while (chunk->used || chunk->size < realsize)
+	{
+		if (chunk->size == 0)
+			panic(sprintf
+			      ("Element du heap %x defectueux avec une taille nulle (heap %x) !",
+			       chunk, kernelcurrentheap));
+		chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
+		if (chunk == (tmalloc *) kernelcurrentheap)
+			mallocpage(realsize);
+		else if (chunk > (tmalloc *) kernelcurrentheap)
+			panic(sprintf
+			      ("Element du heap %x depassant la limite %x !",
+			       chunk, kernelcurrentheap));
+	}
+	if (chunk->size - realsize < MALLOC_MINIMUM)
+		chunk->used = 1;
+	else
+	{
+		new = (tmalloc *) ((u8 *) chunk + realsize);
+		new->size = chunk->size - realsize;
+		new->used = 0;
+		chunk->size = realsize;
+		chunk->used = 1;
+	}
+	return (u8 *) chunk + sizeof(tmalloc);
+}
+
+/*******************************************************************************/
+/* Libère de la mémoire virtuelle depuis le heap noyau */
+
+void vfree(void *vaddr)
+{
+	tmalloc *chunk, *new;
+	chunk = (tmalloc *) (vaddr - sizeof(tmalloc));
+	chunk->used = 0;
+	while ((new = (tmalloc *) ((u8 *) chunk + chunk->size))
+	       && new < (tmalloc *) kernelcurrentheap && new->used == 0)
+		chunk->size += new->size;
+}
+
+/*******************************************************************************/
+/* Retourne la taille de la mémoire physique (selon grub) */
+
+u64 physical_getmemorysize()
+{
+	return memorysize;
+}
+
+/*******************************************************************************/
+/* Retourne que la page physique actuelle est occupée */
+
+void physical_page_use(u32 page)
+{
+	bitmap[(page / 8)] |= (1 << (page % 8));
+}
+
+/*******************************************************************************/
+/* Retourne que la page physique actuelle est libre */
+
+void physical_page_free(u32 page)
+{
+	bitmap[(page / 8)] &= ~(1 << (page % 8));
+}
+
+/*******************************************************************************/
+/* Reserve un espace mémoire physique dans le bitmap */
+
+void physical_range_use(u64 addr, u64 len)
+{
+	u32     nbpage = TOPAGE(len);
+	u32     pagesrc = TOPAGE(addr);
+	if (len & 0x3FF > 0)
+		nbpage++;
+	if (addr >= MAXMEMSIZE)
+		return;
+	if (addr + len >= MAXMEMSIZE)
+		len = MAXMEMSIZE - addr - 1;
+	for (u32 page = pagesrc; page < pagesrc + nbpage; page++)
+		physical_page_use(page);
+}
+
+/*******************************************************************************/
+/* Libère un espace mémoire physique dans le bitmap */
+
+void physical_range_free(u64 addr, u64 len)
+{
+	u32     nbpage = TOPAGE(len);
+	u32     pagesrc = TOPAGE(addr);
+	if (len & 0x3FF > 0)
+		nbpage++;
+	if (addr >= MAXMEMSIZE)
+		return;
+	if (addr + len >= MAXMEMSIZE)
+		len = MAXMEMSIZE - addr - 1;
+	for (u32 page = pagesrc; page < pagesrc + nbpage; page++)
+		physical_page_free(page);
+}
+
+/*******************************************************************************/
+/* Retourne une page physique libre */
+
+u8     *physical_page_getfree(void)
+{
+	u32     byte;
+	u8      bit;
+	u32     page = 0;
+	for (byte = 0; byte < sizeof(bitmap); byte++)
+		if (bitmap[byte] != 0xFF)
+			for (bit = 0; bit < 8; bit++)
+				if (!(bitmap[byte] & (1 << bit)))
+				{
+					page = 8 * byte + bit;
+					physical_page_use(page);
+					return (u8 *) (page * PAGESIZE);
+				}
+	return NULL;
+}
+
+/*******************************************************************************/
+/* Retourne l'espace libre */
+
+u64 getmemoryfree(void)
+{
+	u32     byte, bit;
+	u64     free = 0;
+	for (byte = 0; byte < sizeof(bitmap); byte++)
+		if (bitmap[byte] != 0xFF)
+			for (bit = 0; bit < 8; bit++)
+				if (!(bitmap[byte] & (1 << bit)))
+					free += PAGESIZE;
+	return free;
+}
+
+/*******************************************************************************/
+/* Initialisation du bitmap pour la gestion physique de la mémoire */
+
+void physical_init()
+{
+	for (u64 page = 0; page < sizeof(bitmap); page++)
+		bitmap[page] = 0xFF;
+	for (u8 i=0;i<allparams->e820_numbers;i++)
+	{
+		if (allparams->e820_table[i].type == E820_TYPE_RAM)
+			physical_range_free(allparams->e820_table[i].addr, allparams->e820_table[i].size);
+		else
+			physical_range_use(allparams->e820_table[i].addr, allparams->e820_table[i].size);
+		if ((allparams->e820_table[i].addr + allparams->e820_table[i].size > memorysize) && allparams->e820_table[i].type == E820_TYPE_RAM)
+			memorysize = allparams->e820_table[i].addr + allparams->e820_table[i].size;
+		if (memorysize >= MAXMEMSIZE)
+			memorysize = MAXMEMSIZE - 1;
+	}
+	physical_range_use(0x0, KERNELSIZE);		
+}
+
+/*******************************************************************************/
+/* Retourne une page virtuelle de mémoire */
+
+page   *virtual_page_getfree(void)
+{
+	page   *pg;
+	vrange *vpages;
+	u8     *vaddr, *paddr;
+	paddr = physical_page_getfree();
+	if (paddr == NULL)
+		panic("Plus de memoire physique disponible !\n");
+	if (TAILQ_EMPTY(&vrange_head))
+		panic("Plus de place disponible dans la reserve de page !\n");
+	vpages = TAILQ_FIRST(&vrange_head);
+	vaddr = vpages->vaddrlow;
+	vpages->vaddrlow += PAGESIZE;
+	if (vpages->vaddrlow == vpages->vaddrhigh)
+	{
+		TAILQ_REMOVE(&vrange_head, vpages, tailq);
+		vfree(vpages);
+	}
+	virtual_pd_page_add(NULL, vaddr, paddr, 0);
+	pg = (page *) vmalloc(sizeof(page));
+	pg->vaddr = vaddr;
+	pg->paddr = paddr;
+	return pg;
+}
+
+/*******************************************************************************/
+/* Création d'un directory pour la gestion virtuelle de la mémoire */
+
+pd     *virtual_pd_create()
+{
+	pd     *new;
+	u32    *pdir, *pd0;
+	u32     i;
+	new = (pd *) vmalloc(sizeof(pd));
+	new->addr = virtual_page_getfree();
+	pdir = (u32 *) new->addr->vaddr;
+	pd0 = (u32 *) KERNEL_PD_ADDR;
+	for (i = 0; i < 256; i++)
+		pdir[i] = pd0[i];
+	for (i = 256; i < 1023; i++)
+		pdir[i] = 0;
+	pdir[1023] =
+		((u32) new->addr->paddr | (PAGE_PRESENT | PAGE_WRITE));
+	TAILQ_INIT(&new->page_head);
+	return new;
+}
+
+/*******************************************************************************/
+/* Attache une page virtuelle de la mémoire dans le directory spécifié */
+
+void virtual_pd_page_add(pd * dst, u8 * vaddr, u8 * paddr, u32 flags)
+{
+	u32    *pdir;
+	u32    *ptable;
+	u32    *pt;
+	page   *pg;
+	int     i;
+	if (dst == NULL)
+		if (vaddr > (u8 *) USER_CODE)
+		{
+			printf("ERREUR: Adresse %X n'est pas dans l'espace noyau !\n", vaddr);
+			return;
+		}
+	pdir = (u32 *) (0xFFFFF000 | (((u32) vaddr & 0xFFC00000) >> 20));
+	if ((*pdir & PAGE_PRESENT) == 0)
+	{
+		if (dst == NULL)
+			panic(sprintf
+			      ("Page table introuvable pour l'adresse %x !\r\n",
+			       vaddr));
+		pg = virtual_page_getfree();
+		pt = (u32 *) pg->vaddr;
+		for (i = 1; i < 1024; i++)
+			pt[i] = 0;
+		*pdir = (u32) pg->paddr | (PAGE_PRESENT | PAGE_WRITE |
+					   flags);
+		if (dst)
+			TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
+	}
+	ptable = (u32 *) (0xFFC00000 | (((u32) vaddr & 0xFFFFF000) >> 10));
+	*ptable = ((u32) paddr) | (PAGE_PRESENT | PAGE_WRITE | flags);
+	return;
+}
+
+/*******************************************************************************/
+/* Retire une page virtuelle de la mémoire dans le directory spécifié */
+
+void virtual_pd_page_remove(u8 * vaddr)
+{
+	u32    *ptable;
+	if (virtual_to_physical(vaddr))
+	{
+		ptable = (u32 *) (0xFFC00000 |
+				  (((u32) vaddr & 0xFFFFF000) >> 10));
+		*ptable = (*ptable & (~PAGE_PRESENT));
+		asm("invlpg %0"::"m"(vaddr));
+	}
+	return;
+}
+
+/*******************************************************************************/
+/* Renvoie l'adresse physique de la page virtuel */
+
+u8     *virtual_to_physical(u8 * vaddr)
+{
+	u32    *pdir;
+	u32    *ptable;
+
+	pdir = (u32 *) (0xFFFFF000 | (((u32) vaddr & 0xFFC00000) >> 20));
+	if ((*pdir & PAGE_PRESENT))
+	{
+		ptable = (u32 *) (0xFFC00000 |
+				  (((u32) vaddr & 0xFFFFF000) >> 10));
+		if ((*ptable & PAGE_PRESENT))
+			return (u8 *) ((*ptable & 0xFFFFF000) +
+				       (TOPG((u32) vaddr)));
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Détermine une plage virtuelle de mémoire comme étant mappé aux adresses physiques spécifiées GENERIQUE*/
+
+void virtual_range_use(pd * dst, u8 * vaddr, u8 * paddr, u64 len,
+		       u32 flags)
+{
+	u64     i;
+	u32     realen = len / PAGESIZE;
+	page   *pg;
+	if (len % PAGESIZE != 0)
+		realen++;
+	for (i = 0; i < realen; i++)
+	{
+		if (dst == NULL)
+		{
+			virtual_pd_page_add(dst, vaddr + i * PAGESIZE,
+					    paddr + i * PAGESIZE, flags);
+		}
+		else
+		{
+			pg = (page *) vmalloc(sizeof(page));
+			pg->paddr = paddr + i * PAGESIZE;
+			pg->vaddr = vaddr + i * PAGESIZE;
+			TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
+			virtual_pd_page_add(dst, pg->vaddr, pg->paddr,
+					    flags);
+		}
 	}
 }
 
 /*******************************************************************************/
+/* Supprime une plage virtuelle de mémoire GENERIQUE */
 
+void virtual_range_free(pd * dst, u8 * vaddr, u64 len)
+{
+	u64     i;
+	u32     realen = len / PAGESIZE;
+	if (len % PAGESIZE != 0)
+		realen++;
+	for (i = 0; i < realen; i++)
+	{
+		virtual_pd_page_remove(vaddr + i * PAGESIZE);
+		virtual_page_free(vaddr);
+	}
+}
+
+/*******************************************************************************/
+/* Détermine une plage virtuelle de mémoire en attribuant de la mémoire physique GENERIQUE */
+
+void virtual_range_new(pd * dst, u8 * vaddr, u64 len, u32 flags)
+{
+	u64     i;
+	u32     realen = len / PAGESIZE;
+	page   *pg;
+	if (len % PAGESIZE != 0)
+		realen++;
+	for (i = 0; i < realen; i++)
+	{
+		if (dst == NULL)
+		{
+			virtual_pd_page_add(dst, vaddr + i * PAGESIZE,
+					    physical_page_getfree(),
+					    flags);
+		}
+		else
+		{
+			pg = (page *) vmalloc(sizeof(page));
+			pg->paddr = physical_page_getfree();
+			pg->vaddr = vaddr + i * PAGESIZE;
+			TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
+			virtual_pd_page_add(dst, pg->vaddr, pg->paddr,
+					    flags);
+		}
+	}
+}
+
+/*******************************************************************************/
+/* Détermine une plage virtuelle de mémoire comme étant mappé aux adresses physiques spécifiées pour le noyau*/
+
+void virtual_range_use_kernel(u8 * vaddr, u8 * paddr, u64 * len, u32 flags)
+{
+	virtual_range_use(NULL, vaddr, paddr, len, flags);
+}
+
+/*******************************************************************************/
+/* Supprime une plage virtuelle de mémoire pour le noyau */
+
+void virtual_range_free_kernel(u8 * vaddr, u64 len)
+{
+	virtual_range_free(NULL, vaddr, len);
+}
+
+/*******************************************************************************/
+/* Détermine une plage virtuelle de mémoire en attribuant de la mémoire physique pour le noyau */
+
+void virtual_range_new_kernel(u8 * vaddr, u64 len, u32 flags)
+{
+	virtual_range_new(NULL, vaddr, len, flags);
+}
+
+/*******************************************************************************/
+/* Renvoie le nombre de pages virtuelles occupées */
+
+u32 virtual_getpagesused()
+{
+	u32     maxpage = ((u32) MAXPAGESSIZE) / ((u16) PAGESIZE);
+	return maxpage - virtual_getpagesfree();
+}
+
+/*******************************************************************************/
+/* Renvoie le nombre de pages virtuelles libres */
+
+u32 virtual_getpagesfree()
+{
+	vrange *next;
+	u32     realsize = 0;
+	TAILQ_FOREACH(next, &vrange_head, tailq) realsize +=
+		(next->vaddrhigh - next->vaddrlow) / PAGESIZE;
+	return realsize;
+}
+
+
+/*******************************************************************************/
+/* Libère une page virtuelle de la mémoire */
+
+void virtual_page_free(u8 * vaddr)
+{
+	vrange *next, *prev, *new;
+	u8     *paddr;
+	paddr = virtual_to_physical(vaddr);
+	if (paddr)
+		physical_page_free(TOPAGE((u32) paddr));
+	else
+	{
+		printf("Aucune page associee a l'adresse virtuelle %x\n",
+		       vaddr);
+		return;
+	}
+	virtual_pd_page_remove(vaddr);
+	TAILQ_FOREACH(next, &vrange_head, tailq)
+	{
+		if (next->vaddrlow > vaddr)
+			break;
+	}
+	prev = TAILQ_PREV(next, vrange_s, tailq);
+	if (prev->vaddrhigh == vaddr)
+	{
+		prev->vaddrhigh += PAGESIZE;
+		if (prev->vaddrhigh == next->vaddrlow)
+		{
+			prev->vaddrhigh = next->vaddrhigh;
+			TAILQ_REMOVE(&vrange_head, next, tailq);
+			vfree(next);
+		}
+	}
+	else if (next->vaddrlow == vaddr + PAGESIZE)
+	{
+		next->vaddrlow = vaddr;
+	}
+	else if (next->vaddrlow > vaddr + PAGESIZE)
+	{
+		new = (vrange *) vmalloc(sizeof(vrange));
+		new->vaddrlow = vaddr;
+		new->vaddrhigh = vaddr + PAGESIZE;
+		TAILQ_INSERT_BEFORE(prev, new, tailq);
+	}
+	else
+		panic("Liste chainee corrompue !\n");
+	return 0;
+}
+
+/*******************************************************************************/
+/* Destruction d'un directory pour la gestion virtuelle de la mémoire */
+
+void virtual_pd_destroy(pd * dst)
+{
+	page   *pg;
+	TAILQ_FOREACH(pg, &dst->page_head, tailq)
+	{
+		virtual_page_free(pg->vaddr);
+		TAILQ_REMOVE(&dst->page_head, pg, tailq);
+		vfree(pg);
+	}
+	virtual_page_free(dst->addr->vaddr);
+	vfree(dst);
+	return 0;
+}
+
+/*******************************************************************************/
+/* Affiche toutes les page du directory */
+
+void virtual_pd_show(pd *dst)
+{
+	page   *pg;
+	bool first=true;
+	TAILQ_FOREACH(pg, &dst->page_head, tailq)
+	{
+		if (!first)
+			print(",");
+		else
+			first=false;
+		printf("%Y",(u32)pg->vaddr);
+	}
+}
+
+/*******************************************************************************/
+/* Initialise une pages virtuelles (size) pour le heap du noyau */
+
+void malloc_init(void)
+{
+	tmalloc *chunk;
+	chunk = (tmalloc *) KERNEL_HEAP;
+	virtual_pd_page_add(NULL, KERNEL_HEAP, physical_page_getfree(),
+			    PAGE_NOFLAG);
+	kernelcurrentheap = KERNEL_HEAP + PAGESIZE;
+	chunk->size = PAGESIZE;
+	chunk->used = 0;
+}
+
+
+/*******************************************************************************/
+/* Initialisation d'une STAILQ pour la gestion virtuelle de la mémoire */
+
+void virtual_init(void)
+{
+	vrange *vpages = (vrange *) vmalloc(sizeof(vrange));
+	vpages->vaddrlow = (u8 *) KERNEL_PAGES + PAGESIZE;
+	vpages->vaddrhigh = (u8 *) KERNEL_PAGES + MAXPAGESSIZE;
+	TAILQ_INIT(&vrange_head);
+	TAILQ_INSERT_TAIL(&vrange_head, vpages, tailq);
+}
+
+/*******************************************************************************/
+/* Initialisation des 8 premiers MB de la mémoire en identity mapping */
+
+void identity_init(void)
+{
+	u32     i;
+	u32    *pd0 = KERNEL_PD_ADDR;
+	u8     *pg0 = (u8 *) 0;
+	u8     *pg1 = (u8 *) (PAGESIZE * PAGENUMBER);
+	pd0[0] = ((u32) pg0 | (PAGE_PRESENT | PAGE_WRITE | PAGE_4MB));
+	pd0[1] = ((u32) pg1 | (PAGE_PRESENT | PAGE_WRITE | PAGE_4MB));
+	for (i = 2; i < 1023; i++)
+		pd0[i] = ((u32) pg1 +
+			  PAGESIZE * i) | (PAGE_PRESENT | PAGE_WRITE);
+	pd0[1023] = ((u32) pd0 | (PAGE_PRESENT | PAGE_WRITE));
+}
+
+/*******************************************************************************/
+/* Initialisation des registres CR0, CR3, CR4 */
+
+void registry_init(void)
+{
+	asm("mov %[directory_addr], %%eax \n \
+        mov %%eax, %%cr3 \n \
+        mov %%cr4, %%eax \n \
+		or $0x00000010, %%eax \n \
+        mov %%eax, %%cr4 \n \
+        mov %%cr0, %%eax \n \
+		or $0x80000001, %%eax \n \
+        mov %%eax, %%cr0"::[directory_addr] "i"(KERNEL_PD_ADDR));
+}
+
+/*******************************************************************************/
+/* Initialisation de la mémoire paginée */
+
+void initpaging()
+{
+	identity_init();
+	registry_init();
+	physical_init();
+	malloc_init();
+	virtual_init();
+}
+
+/*******************************************************************************/
+/* Copie un octet une ou plusieurs fois en mémoire */
+
+void memset(void *dst, u8 val, u32 count, u32 size)
+{
+	u8     *d = (u8 *) dst;
+	if (size > 0)
+		size--;
+	for (; count != 0; count--)
+	{
+		*(d++) = val;
+		d += size;
+	}
+}
+
+/*******************************************************************************/
 /* Copie une portion de mémoire vers une autre */
+
 void memcpy(void *src, void *dst, u32 count, u32 size)
 {
-	char *s, *d;
-	u32 i;
-	s = (u8*) src;
-	d = (u8*) dst;
-	for(i=0;i<count;i++){
-		*(d+i*size) = *(s+i);	
+	u8     *s = (u8 *) src;
+	u8     *d = (u8 *) dst;
+	if (size > 0)
+		size--;
+	for (; count != 0; count--)
+	{
+		*(d++) = *(s++);
+		d += size;
 	}
 }
 
 /*******************************************************************************/
-
 /* Compare 2 portions de mémoire */
+
 u32 memcmp(void *src, void *dst, u32 count, u32 size)
 {
-	const u8 *mem1 = (const u8 *)src;
-	const u8 *mem2 = (const u8 *)dst;
-	for(; count != 0; count--)
+	u8     *s = (u8 *) src;
+	u8     *d = (u8 *) dst;
+	if (size > 0)
+		size--;
+	for (; count != 0; count--)
 	{
-		if(*mem1 != *mem2)
-		return *mem1 -  *mem2;
-		mem1+=size;
-		mem2+=size;
+		if (*(s++) != *(d++))
+			return *d - *s;
+		s += size;
+		d += size;
 	}
 }
 

lib/modes.c

@@ -1,225 +0,0 @@
-/* definition des registres de la carte VGA pour differents modes */
-
-#define maxgraphmode 11
-#define maxtextmode 5
-
-
-static mode_def textmodes[maxtextmode] = {
-
-
-	/*40*25 16 couleurs mode 0x00*/
-	{
-	0x67,
-	0x03, 0x08, 0x03, 0x00, 0x02, 
-	0x2D, 0x27, 0x28, 0x90, 0x2B, 0xA0, 0xBF, 0x1F, 0x00, 
-	0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x8E, 0x8F, 0x14, 0x1F, 0x96, 0xB9, 0xA3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x0C, 0x00, 0x0F, 0x08, 0x00, 
-	45, 25, 4
-	},
-
-
-	/*80*25 16 couleurs mode 0x01*/
-	{ 
-	0x67,
-	0x03, 0x00, 0x03, 0x00, 0x02, 
-	0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 
-	0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x0E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x0C, 0x00, 0x0F, 0x08, 0x00, 
-	80, 25, 4
-	},
-	
-
-	/*80*50 16 couleurs mode 0x02*/
-	{
-	0x63,
-	0x03, 0x01, 0x03, 0x05, 0x02, 
-	0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 
-	0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x0C, 0x00, 0x0F, 0x00, 0x00, 
-	80, 50, 4
-	}, 
-
-
-	/*100*50 16 couleurs mode 0x03*/
-	{
-	0x67,
-	0x03, 0x01, 0x03, 0x05, 0x02, 
-	0x70, 0x63, 0x64, 0x85, 0x68, 0x84, 0xBF, 0x1F, 0x00, 
-	0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x8E, 0x8F, 0x32, 0x1F, 0x96, 0xB9, 0xA3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x0C, 0x00, 0x0F, 0x00, 0x00, 
-	100, 50, 4
-	}, 
-
-
-	/*100*60 16 couleurs mode 0x04*/
-	{
-	0xA7,
-	0x03, 0x01, 0x03, 0x05, 0x02, 
-	0x70, 0x63, 0x64, 0x85, 0x68, 0x84, 0xFF, 0x1F, 0x00, 
-	0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 
-	0xE7, 0x8E, 0xDF, 0x32, 0x1F, 0xDF, 0xE5, 0xA3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x0C, 0x00, 0x0F, 0x00, 0x00, 
-	100, 60, 4
-	}
-	}; 
-
-static mode_def graphmodes[maxgraphmode] = {
-
-	/*640*480 n&b mode 0x80*/
-	{
-	0xE3,
-	0x03, 0x01, 0x0F, 0x00, 0x06,
-	0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
-	0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0xEA, 0x0C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
- 	0x01, 0x00, 0x0F, 0x00, 0x00,
-	80, 60, 1
-	},
-
-	/*320*200 4 couleurs mode 0x81*/
-	{
-	0x63,
-	0x03, 0x09, 0x03, 0x00, 0x02,
-	0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00,
-	0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x9C, 0x0E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x02, 0x00, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
- 	0x01, 0x00, 0x03, 0x00, 0x00,
-	40, 25, 
-	},
-
-	/*640*480 16 couleurs mode 0x82*/
-	{
-	0xE3,
-	0x03, 0x01, 0x0F, 0x00, 0x06,
-	0x5F, 0x4F, 0x50, 0x82, 0x53, 0x9F, 0x0B, 0x3E, 0x00,
-	0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0xE9, 0x8B, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x01, 0x00, 0x0F, 0x00, 0x00,
-	80, 60, 4
-	},
-
-	/*720*480 16 couleurs mode 0x83*/
-	{
-	0xE7,
-	0x03, 0x01, 0x08, 0x00, 0x06,
-	0x6B, 0x59, 0x5A, 0x82, 0x60, 0x8D, 0x0B, 0x3E, 0x00,
-	0x40, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
-	0xEA, 0x0C, 0xDF, 0x2D, 0x08, 0xE8, 0x05, 0xE3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x05, 0x0F, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-	0x01, 0x00, 0x0F, 0x00, 0x00,
-	90, 60, 4
-	},
-
-	/*800*600 16 couleurs mode 0x84*/
-	{
-	0xE7,
-	0x03, 0x01, 0x0F, 0x00, 0x06,
-	0x70, 0x63, 0x64, 0x92, 0x65, 0x82, 0x70, 0xF0, 0x00,
-	0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x5B, 0x8C, 0x57, 0x32, 0x00, 0x58, 0x70, 0xE3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
- 	0x01, 0x00, 0x0F, 0x00, 0x00,
-	100, 75, 4
-	},
-
-	/*320*200 256 couleurs RAPIDE mode 0x85*/
-	{
-	0x63,
-	0x03, 0x01, 0x0F, 0x00, 0x0E,
-	0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
-	0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x9C, 0x0E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3, 0xFF,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00,
-	40, 25, 8
-	},
-
-	/*320*200 256 couleurs mode 0x86*/
-	{
-	0x63,
-	0x03, 0x01, 0x0F, 0x00, 0x06, 
-	0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 
-	0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x0E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00, 
-	40, 25, 8
-	}, 
-
-	/*320*400 256 couleurs mode 0x87*/
-	{
-	0x63,
-	0x03, 0x01, 0x0F, 0x00, 0x06, 
-	0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 
-	0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00, 
-	40, 50, 8
-	},
-
-	/*320*480 256 couleurs mode 0x88*/
-	{ 
-	0xE3,
-	0x03, 0x01, 0x0F, 0x00, 0x06, 
-	0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 
-	0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0xEA, 0xAC, 0xDF, 0x28, 0x00, 0xE7, 0x06, 0xE3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00, 
-	40, 60, 8
-	}, 
-
-	/*360*480 256 couleurs mode 0x89*/
-	{ 
-	0xE7,
-	0x03, 0x01, 0x0F, 0x00, 0x06, 
-	0x6B, 0x59, 0x5A, 0x8E, 0x5E, 0x8A, 0x0D, 0x3E, 0x00, 
-	0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0xEA, 0xAC, 0xDF, 0x2D, 0x00, 0xE7, 0x06, 0xE3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00, 
-	45, 60, 8
-	},
-
-	/*400*600 256 couleurs mode 0x8A*/
-	{  
-	0xE7,
-	0x03, 0x01, 0x0F, 0x00, 0x06, 
-	0x74, 0x63, 0x64, 0x97, 0x68, 0x95, 0x86, 0xF0, 0x00, 
-	0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-	0x5B, 0x8D, 0x57, 0x32, 0x00, 0x60, 0x80, 0xE3, 0xFF, 
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF, 
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-	0x41, 0x00, 0x0F, 0x00, 0x00, 
-	50, 75, 8
-	}
-	};
-

lib/mouse.c

@@ -1,3 +1,6 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include "types.h"
 #include "asm.h"
 #include "mouse.h"
@@ -5,134 +8,142 @@
 #include "vga.h"
 #include "video.h"
 
-bool initmouse()
+/******************************************************************************/
+/* initialise la souris */
+
+bool initmouse(void)
 {
-u16 i=1024;
+	u16     i = 1024;
 
-outkbd(0x64,0xA8);         /* autorisé Aux */
+	outkbd(0x64, 0xA8);	/* autorisé Aux */
 
-outmseack(0xf3);         /*sample*/ 
-outmseack(100);          /*sample donnée*/ 
+	outmseack(0xf3);	/*sample */
+	outmseack(100);		/*sample donnée */
 
-outmseack(0xe8);         /*resolution*/ 
-outmseack(3);           /*resolution donnée*/ 
+	outmseack(0xe8);	/*resolution */
+	outmseack(3);		/*resolution donnée */
 
-outmseack(0xe7);         /* echelle 2:1*/ 
+	outmseack(0xe7);	/* echelle 2:1 */
 
-outmseack(0xf4);         /* Autorise peripherique */ 
+	outmseack(0xf4);	/* Autorise peripherique */
 
-outmsecmd(0x47);         /* Autorise interruption */ 
+	outmsecmd(0x47);	/* Autorise interruption */
 
-while(i-->0) if (inb(0x60)==250) return 1;
-return 0;
+	while (i-- > 0)
+		if (inb(0x60) == 250)
+			return 1;
+	return 0;
 }
 
-static  u8  bytepos=0,mousereplies=0;
-static  u8  mpacket[3];
-static  s32 mousex=40, mousey=12;
-static  u16 oldx=0, oldy=0;
-static  u8  oldchar=0x00,oldattr=0x07;
-static  bool mousebut1=0,mousebut2=0,mousebut3=0;
-static  u8  speed=6;
+static u8 bytepos = 0, mousereplies = 0;
+static u8 mpacket[3];
+static s32 mousex = 40, mousey = 12;
+static u16 oldx = 0, oldy = 0;
+static u8 oldchar = 0x00, oldattr = 0x07;
+static bool mousebut1 = 0, mousebut2 = 0, mousebut3 = 0;
+static u8 speed = 6;
 
+/******************************************************************************/
+/* ecriture vers souris */
 
 void outmseack(u8 value)
 {
-outkbd(0x64,0xD4);         /* ecriture vers souris */
-outb(0x60,value);
-mousereplies++;
+	outkbd(0x64, 0xD4);
+	outb(0x60, value);
+	mousereplies++;
 }
 
+/* ecriture vers mode */
+
 void outmsecmd(u8 command)
 {
-outkbd(0x64,0x60);         /* ecriture vers mode */
-outb(0x60,command);
+	outkbd(0x64, 0x60);
+	outb(0x60, command);
 }
 
-void mouse()
+/******************************************************************************/
+/* Handler d'interruption de la souris IRQ 12 */
+
+__attribute__((interrupt)) void mouse_handler(exception_stack_noerror *caller)
 {
-u8 mbyte=inb(0x60);
-s8 changex,changey;
-cli();
+	cli();
+	u8      mbyte = inb(0x60);
+	s8      changex, changey;
 
-  if (mousereplies > 0) 
-  {
-    if (mbyte == 0xFA) 
-    {
-      mousereplies--;
-      goto endofint;
-    }
-    mousereplies = 0;
-  }
+	if (mousereplies > 0)
+	{
+		if (mbyte == 0xFA)
+		{
+			mousereplies--;
+			goto endofint;
+		}
+		mousereplies = 0;
+	}
 
-        mpacket[bytepos]=mbyte;
-        bytepos++;
+	mpacket[bytepos] = mbyte;
+	bytepos++;
 
-if(bytepos==3) {     
-bytepos=0;
-if ( mpacket[1] == 0)
-    {
-      changex = 0;
-    }
-    else
-    {
-      changex = (mpacket[0] & 0x10) ?
-        mpacket[1] - 256 :
-        mpacket[1];
-    }
-    if (mpacket[2] == 0)
-    {
-      changey = 0;
-    }
-    else
-    {
-      changey = -((mpacket[0] & 0x20) ?
-                    mpacket[2] - 256 :
-                    mpacket[2]);
-    }
+	if (bytepos == 3)
+	{
+		bytepos = 0;
+		if (mpacket[1] == 0)
+		{
+			changex = 0;
+		}
+		else
+		{
+			changex =
+				(mpacket[0] & 0x10) ? mpacket[1] -
+				256 : mpacket[1];
+		}
+		if (mpacket[2] == 0)
+		{
+			changey = 0;
+		}
+		else
+		{
+			changey =
+				-((mpacket[0] & 0x20) ? mpacket[2] -
+				  256 : mpacket[2]);
+		}
 
-    mousex+= (changex<<speed);
-    mousey+= (changey<<speed);    
+		mousex += (changex << speed);
+		mousey += (changey << speed);
 
-    if(mousex<0) { mousex=0; }
-    if(mousex>=65535) { mousex=65535; }
-    if(mousey<0) { mousey=0; }
-    if(mousey>=65535) { mousey=65535; }
+		if (mousex < 0)
+		{
+			mousex = 0;
+		}
+		if (mousex >= 65535)
+		{
+			mousex = 65535;
+		}
+		if (mousey < 0)
+		{
+			mousey = 0;
+		}
+		if (mousey >= 65535)
+		{
+			mousey = 65535;
+		}
+		videoinfos *info = getvideo_info();
+		u16     newx = (u32) mousex * info->currentwidth / 65536;
+		u16     newy = (u32) mousey * info->currentheight / 65536;
 
-   u16 newx=(u32)mousex*getxres()/65536;
-   u16 newy=(u32)mousey*getyres()/65536;         
-
-    // Retrieve mouse button status from packet
-    mousebut1=mpacket[0] & 1;
-    mousebut2=mpacket[0] & 2;
-    mousebut3=mpacket[0] & 4;
+		// Retrieve mouse button status from packet
+		mousebut1 = mpacket[0] & 1;
+		mousebut2 = mpacket[0] & 2;
+		mousebut3 = mpacket[0] & 4;
 
 // printf("RX:%d\tRY:%d\tX:%d\tY:%d\tB1:%d\tB2:%d\tB3:%d\t\r\n",changex,changey,mousex,mousey,mousebut1,mousebut2,mousebut3);
 
-if ((newx!=oldx)||(newy!=oldy))
-{
- showchar(oldx,oldy,oldchar,oldattr); 
- oldx=newx;
- oldy=newy; 
- oldchar=getchar(oldx,oldy);
- oldattr=getattrib(oldx,oldy);
- showchar(newx,newy,0xDB,0x0F);
-}
-}
-endofint:
-irqendmaster();
-irqendslave();
-sti();
-//asm("movl 0x2C(%esp), %ebx;movl 0x30(%esp), %esi;movl 0x34(%esp), %edi;movl 0x38(%esp), %ebp;addl  $0x3C, %esp;iret;");
-asm(
-"addl  $0x18,%esp;\
-popl %bx;\
-iret;");
+		if (!info->isgraphic)
+			showchar(newx, newy, 0xDB, 0x0F);
+	}
+      endofint:
+	irqendmaster();
+	irqendslave();
+	sti();
 }
 
-
-
-
-
-
-
+/*******************************************************************************/

lib/pci.c

@@ -0,0 +1,147 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "asm.h"
+#include "types.h"
+#include "pci.h"
+#include "PCI/class.c"
+
+#define MAX_BUS_SCAN        256
+#define MAX_DEVICE_SCAN     32
+#define MAX_FUNCTION_SCAN   8
+
+/*******************************************************************************/
+/* Retourne une chaine correspondant à l'ID class/subclass PCI */
+
+u8     *pcigetclassname(const pcidev * device)
+{
+	pciclass *class = NULL;
+	if (device == NULL)
+	{
+		return NULL;
+	}
+	if (device->base_class == 0xff)
+	{
+		return "Unassigned class";
+	}
+	class = classcodes[device->base_class];
+	if (!class)
+	{
+		return "Unknowned class";
+	}
+	while (class->name != NULL)
+	{
+		if (class->number == device->sub_class)
+		{
+			return class->name;
+		}
+		class++;
+	}
+
+	return "Unknowned class";
+}
+
+/*******************************************************************************/
+/* Récupère les identifiants vendeur / periphérique du periphérique PCI donnée */
+
+pcidevmini getPCImininfo(const u8 bus, const u8 dev, const u8 function)
+{
+	pcidevmini result;
+	if ((result.vendor_id =
+	     pciConfigReadWord(bus, dev, function, 0x0)) != 0xFFFF)
+	{
+		result.device_id =
+			pciConfigReadWord(bus, dev, function, 0x2);
+	}
+	return result;
+}
+
+/*******************************************************************************/
+/* Récupère toutes les informations du periphérique PCI donnée */
+
+bool getPCInfo(pcidev * device, const u8 bus, const u8 dev,
+	       const u8 function)
+{
+	if ((device->vendor_id =
+	     pciConfigReadWord(bus, dev, function, 0x0)) != 0xFFFF)
+	{
+		u16     temp;
+		device->device_id =
+			pciConfigReadWord(bus, dev, function, 0x2);
+		device->command =
+			pciConfigReadWord(bus, dev, function, 0x4);
+		device->status =
+			pciConfigReadWord(bus, dev, function, 0x6);
+		temp = pciConfigReadWord(bus, dev, function, 0x8);
+		device->revision_id = temp & 0xFF;
+		device->interface = temp >> 8;
+		temp = pciConfigReadWord(bus, dev, function, 0xA);
+		device->sub_class = temp & 0xFF;
+		device->base_class = temp >> 8;
+		temp = pciConfigReadWord(bus, dev, function, 0xC);
+		device->cache_line_size = temp & 0xFF;
+		device->latency_timer = temp >> 8;
+		temp = pciConfigReadWord(bus, dev, function, 0xE);
+		device->header_type = temp & 0xFF;
+		device->bist = temp >> 8;
+		return true;
+	}
+	else
+		return false;
+}
+
+/*******************************************************************************/
+/* Récupère les informations sur le periphérique PCI donnée */
+
+u16 pciConfigReadWord(const u8 bus, const u8 dev, const u8 function,
+		      const u8 offset)
+{
+	u16     tmp = 0;
+	u32     addr =
+		(0x80000000 | (bus << 16) | (dev << 11) | (function << 8) |
+		 (offset & 0xFC));
+	outd(0xCF8, addr);
+	tmp = (u16) ((ind(0xCFC) >> ((offset & 2) * 8)) & 0xffff);
+	return tmp;
+}
+
+/*******************************************************************************/
+/* Scan le bus PCI et affiche les périphériques */
+
+void scanPCImini(void)
+{
+	u16     bus, device, function;
+	pcidevmini result;
+	for (bus = 0; bus < MAX_BUS_SCAN; ++bus)
+		for (device = 0; device < MAX_DEVICE_SCAN; ++device)
+			for (function = 0; function < MAX_FUNCTION_SCAN;
+			     ++function)
+			{
+				result = getPCImininfo(bus, device,
+						       function);
+				if (result.vendor_id != 0xFFFF)
+					printf("Bus:%hx Dev:%hx Func:%hx %hx:%hx\r\n", bus, device, function, result.vendor_id, result.device_id);
+			}
+	return;
+}
+
+/*******************************************************************************/
+
+/* Scan le bus PCI et affiche les périphériques */
+
+void scanPCI(void)
+{
+	u16     bus, device, function;
+	pcidev  result;
+	for (bus = 0; bus < MAX_BUS_SCAN; ++bus)
+		for (device = 0; device < MAX_DEVICE_SCAN; ++device)
+			for (function = 0; function < MAX_FUNCTION_SCAN;
+			     ++function)
+				if (getPCInfo
+				    (&result, bus, device, function))
+					printf("Bus:%hx Dev:%hx Func:%hx %hx:%hx ->%s\r\n", bus, device, function, result.vendor_id, result.device_id, pcigetclassname(&result));
+	return;
+}
+
+/*******************************************************************************/

lib/port.c

@@ -1,68 +0,0 @@
-#include "types.h"
-#include "asm.h"
-
-/*******************************************************************************/
-
-/* Envoie une série d'octet a destination d'une portion de mémoire
-vers le registre video spécifié */
-
-void outreg(u16 port,u8 *src,u16 num)
-{
-int i;	       
-for(i=0;i<num;i++)
-	{
-	 	outb(port,i);
-	 	outb(port+1,*src++);	
-	}
-}
-
-
-/*******************************************************************************/
-
-/* Envoie une série d'octet a destination d'une portion de mémoire
-vers le registre video spécifié (accés data et index confondu) */
-
-void outregsame(u16 port,u8 *src,u16 num)
-{
-int i;	
-for(i=0;i<num;i++)
-	{
-		inb(port);
-	 	outb(port,i);
-	 	outb(port,*src++);	
-	}
-}
-
-/*******************************************************************************/
-
-/* Récupère une série d'octet en provenance d'un registre video spécifié
-vers portion de mémoire */
-
-void inreg(u16 port,u8 *src,u16 num)
-{
-int i;	
-for(i=0;i<num;i++)
-	{
-	 	outb(port,i);
-	 	*src++=inb(port+1);	
-	}
-}
-
-/*******************************************************************************/
-
-/* Récupère une série d'octet en provenance d'un registre video spécifié
-vers portion de mémoire (accés data et index confondu) */
-
-void inregsame(u16 port,u8 *src,u16 num)
-{
-int i;	
-for(i=0;i<num;i++)
-	{
-		inb(port);
-	 	outb(port,i);
-	 	*src++=inb(port);	
-	}
-}
-
-/*******************************************************************************/
-

lib/process.c

@@ -0,0 +1,568 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+
+#include "types.h"
+#include "process.h"
+#include "memory.h"
+#include "gdt.h"
+
+process *processes;
+tid_t current;
+pid_t lastpid;
+
+
+static u8 elf_errors1[] = "Aucune signature ELF";
+static u8 elf_errors2[] = "Fichier au format ELF mais non 32 bits";
+static u8 elf_errors3[] = "ELF non LSB";
+static u8 elf_errors4[] = "ELF mauvaise version";
+static u8 elf_errors5[] = "ELF pour OS ne correspondant pas";
+static u8 elf_errors6[] = "Mauvais type de machine";
+static u8 *elf_errors[] =
+	{ &elf_errors1, &elf_errors2, &elf_errors3, &elf_errors4,
+	&elf_errors5, &elf_errors6
+};
+
+/*******************************************************************************/
+/* Vérifie la signature ELF 
+ 0 - RAS
+ 1 - Pas la signature ELF
+ 2 - pas ELF32
+ 3 - pas bon organisation LSB/MSB
+ 4 - pas bonne version ELF
+ 5 - pas bon OS
+ 6 - pas bon type machine */
+
+u32 iself(u8 * src)
+{
+	elf32  *header = (elf32 *) src;
+	if (header->e_ident[EI_MAG0] == ELFMAG0
+	    && header->e_ident[EI_MAG1] == ELFMAG1
+	    && header->e_ident[EI_MAG2] == ELFMAG2
+	    && header->e_ident[EI_MAG3] == ELFMAG3)
+	{
+		if (header->e_ident[EI_CLASS] != ELFCLASS32)
+			return 2;
+		if (header->e_ident[EI_DATA] != ELFDATA2LSB)
+			return 3;
+		if (header->e_ident[EI_VERSION] != EV_CURRENT
+		    || header->e_version != EV_CURRENT)
+			return 4;
+		if (header->e_ident[EI_OSABI] != ELFOSABI_COS2000)
+			return 5;
+		if (header->e_machine != EM_386)
+			return 6;
+		return 0;
+	}
+	else
+		return 1;
+}
+
+/*******************************************************************************/
+/* Met fin à une tâche */
+/* SYSCALL 
+{
+"ID":5,
+"LIBRARY":"libsys",
+"NAME":"exit",
+"INTERNALNAME":"processexit",
+"DESCRIPTION":"End a task for user or kernel domain",
+"ARGS": [
+{"TYPE":"u32","NAME":"resultcode","DESCRIPTION":"Code result of the execution"}
+],
+"RETURN":"u32"
+}
+END-SYSCALL */
+
+void processexit(void)
+{
+	cli();
+	deleteprocess(getcurrentpid());
+	switchtask(maketid(1,1));
+	sti();
+}
+
+/*******************************************************************************/
+/* Charge le fichier ELF en mémoire et mets à jour les informations sur le processus */
+
+u32 loadelf(u8 * src, pid_t pid)
+{
+	u8     *ptr;
+	u8      code;
+	u32     v_begin, v_end;
+	elf32  *header;
+	elf32p *program;
+	u32     i;
+
+	header = (elf32 *) src;
+	program = (elf32p *) (src + header->e_phoff);
+	code = iself(src);
+	process *aprocess=findprocess(pid);
+	if (aprocess==NULL) return NULL;
+	if (code != 0)
+	{
+		printf("Erreur de chargement ELF, %s !\r\n",
+		       elf_errors[code - 1]);
+		return NULL;
+	}
+	for (i = 0; i < header->e_phnum; i++, program++)
+	{
+		if (program->p_type == PT_LOAD)
+		{
+			v_begin = program->p_vaddr;
+			v_end = program->p_vaddr + program->p_memsz;
+			if (v_begin < USER_CODE)
+			{
+				printf("Ne peut charger l'executable en desssous de l'adresse %X\r\n", USER_CODE);
+				return 0;
+			}
+			if (v_end > USER_STACK)
+			{
+				printf("Ne peut charger l'executable au desssus de l'adresse %X\r\n", USER_STACK);
+				return 0;
+			}
+			if (program->p_flags == PF_X + PF_R)
+			{
+				aprocess->exec_low = (u8 *) v_begin;
+				aprocess->exec_high = (u8 *) v_end;
+			}
+			if (program->p_flags == PF_W + PF_R)
+			{
+				aprocess->bss_low = (u8 *) v_begin;
+				aprocess->bss_high = (u8 *) v_end;
+			}
+			memcpy((u8 *) (src + program->p_offset),
+			       (u8 *) v_begin, program->p_filesz, 0);
+			if (program->p_memsz > program->p_filesz)
+				for (i = program->p_filesz, ptr =
+				     (u8 *) program->p_vaddr;
+				     i < program->p_memsz; i++)
+					ptr[i] = 0;
+		}
+	}
+	return header->e_entry;
+}
+
+/*******************************************************************************/
+/* Initialise la liste des processus */
+
+void initprocesses(void)
+{
+	u32     i = 0;
+	processes = (process *) vmalloc(sizeof(process) * MAXNUMPROCESS);
+	while (i < MAXNUMPROCESS)
+	{
+		processes[i].pid = i+1;
+		processes[i++].status = PROCESS_STATUS_FREE;
+	}
+	pid_t pid=(pid_t)1;
+	process *aprocess=findprocess(pid);
+	if (aprocess==NULL) return NULL;
+	aprocess->pid = pid;
+	aprocess->result = 0;
+	aprocess->pdd = NULL;
+	aprocess->status = PROCESS_STATUS_RUN;
+	aprocess->iskernel = true;
+	TAILQ_INIT(&aprocess->task_head);
+	current=createtask(pid,getinitretry(),true);
+	task *atask = findtask(current);
+	atask->status = TASK_STATUS_RUN;
+}
+
+/*******************************************************************************/
+/* Récupère un emplacement dans la liste des processus */
+
+pid_t getfreepid(void)
+{
+	if ((u32)lastpid==0 || lastpid>MAXNUMPROCESS)
+		lastpid=(pid_t)1;
+	process* aprocess=findprocess(lastpid);
+	aprocess=getnextprocess(aprocess, PROCESS_STATUS_FREE);
+	if (aprocess == NULL)
+	{
+		printf("PANIC: plus d'emplacement disponible pour un novueau processus\n");
+		return NULL;
+	}
+	lastpid=aprocess->pid;
+	return lastpid;
+}
+
+/*******************************************************************************/
+/* Récupère un emplacement dans la liste des tâche du processus donné */
+
+tid_t getfreeptid(pid_t pid)
+{
+	process *aprocess=findprocess(pid);
+	if (aprocess==NULL) return maketid(0,0);
+	u32 number=0;
+	task *next;
+	TAILQ_FOREACH(next, &aprocess->task_head, tailq)
+		if (next->tid.number>number)
+			number=next->tid.number;
+	number++;
+	return maketid(pid,number);
+}
+
+/*******************************************************************************/
+/* Récupère le PID du processus courant */
+
+pid_t getcurrentpid(void)
+{
+	return current.pid;
+}
+
+/*******************************************************************************/
+/* Récupère le TID de la tâche courante */
+
+tid_t getcurrenttid(void)
+{
+	return current;
+}
+
+/*******************************************************************************/
+/* Change la tâche désigné dans le TID */
+
+tid_t	maketid(pid_t pid, u32 number)
+{
+	tid_t newtid;
+	newtid.pid=pid;
+	newtid.number=number;
+	return newtid;
+}
+
+/*******************************************************************************/
+/* Récupère l'adresse d'un processus */
+
+process* findprocess(pid_t pid)
+{
+	if ((u32)pid>0)
+		return &processes[(u32)pid-1];
+	else
+		return NULL;
+}
+
+/*******************************************************************************/
+/* Récupère l'adresse du processus courant */
+
+process* findcurrentprocess(void)
+{
+	return &processes[(u32)getcurrentpid()-1];
+}
+
+/*******************************************************************************/
+/* Bascule vers une tâche */
+
+void switchtask(tid_t tid)
+{
+	cli();
+	tid_t previous = current;
+	task *atask = findtask(tid);
+	if (atask==NULL) return;
+	process *aprocess=findprocess(tid.pid);
+	if (aprocess==NULL) return;
+	current = tid;
+	if (!aprocess->iskernel)
+	{
+		setTSS(atask->kernel_stack.ss0, atask->kernel_stack.esp0);
+		wrmsr(0x175, atask->syscall_stack.esp0, 0x0);
+	}
+	else
+	{
+		setTSS(0x0, 0x0);
+		wrmsr(0x175, 0x0, 0x0);
+	}
+	if (((atask->dump.cs & 0xFFF8) !=SEL_KERNEL_CODE) && ((atask->dump.cs & 0xFFF8) !=SEL_USER_CODE))
+		cpuerror("SWITCH ERROR", &atask->dump, false);
+	//printf("%Y\r\n",atask->tid.pid);		
+	atask->dump.eflags = (atask->dump.eflags | 0x200) & 0xFFFFBFFF;
+	createdump(atask->dump);
+	if ((atask->dump.cs & 0xFFF8)==SEL_KERNEL_CODE)
+		restcpu_kernel();
+	else
+		restcpu_user();
+	iret();
+}
+
+/*******************************************************************************/
+/* Cherche le prochain processus */
+
+process* getnextprocess(process* aprocess, u32 status)
+{
+	u32     i = (u32) aprocess->pid;
+	u32     parsed = 0;
+	while (parsed++ < MAXNUMPROCESS && ((status != PROCESS_STATUS_ALL && processes[i++].status != status) ||
+	 (status == PROCESS_STATUS_ALL && processes[i++].status == PROCESS_STATUS_FREE)))
+	{
+		if (i >= MAXNUMPROCESS)
+			i = 0;
+	}
+	if (parsed > MAXNUMPROCESS)
+		return NULL;
+	else	
+		return &processes[i-1];
+}
+
+/*******************************************************************************/
+/* Cherche la prochaine tâche du processus */
+
+task* getnexttask(task *atask, u32 status)
+{
+	task *next=atask;
+	while (next!=NULL)
+	{
+		next=TAILQ_NEXT(next, tailq);
+		if (next!=NULL && (status == TASK_STATUS_ALL || next->status == status))
+			return next;
+	}
+	return NULL;
+}
+
+/*******************************************************************************/
+/* Cherche la prochaine tâche */
+
+task* getschedule(void)
+{
+	process *aprocess=findcurrentprocess();
+	task *next=findcurrenttask();
+	u32 flag=0;
+	while(flag<2) {
+		if (aprocess==NULL) return NULL;
+		if (next==NULL)
+			next=findfirsttask(aprocess);
+		while(true)
+		{
+			if (next!=NULL)
+				if (current.pid==next->tid.pid && current.number==next->tid.number)
+					flag++;
+				else
+					return next;
+			else
+				break;
+			next=getnexttask(next,TASK_STATUS_RUN);
+		}			
+		aprocess=getnextprocess(aprocess,PROCESS_STATUS_RUN);
+	}
+}
+
+/*******************************************************************************/
+/* Cherche la première tâche du processeur */
+
+task* findfirsttask(process* aprocess)
+{
+	task *first;
+	return TAILQ_FIRST(&aprocess->task_head);
+}
+
+/*******************************************************************************/
+/* Cherche l'adresse d'une tâche */
+
+task* findtask(tid_t tid)
+{
+	process *aprocess=findprocess(tid.pid);
+	if (aprocess==NULL) return NULL;
+	task *next;
+	TAILQ_FOREACH(next, &aprocess->task_head, tailq)
+		if (next->tid.number==tid.number)
+			return next;
+}
+
+
+/*******************************************************************************/
+/* Cherche l'adresse de la tâche courante */
+
+task* findcurrenttask(void)
+{
+	return findtask(getcurrenttid());
+}
+
+
+/*******************************************************************************/
+/* Détruit une tâche */
+
+void deletetask(tid_t tid)
+{
+	cli();
+	stoptask(tid);
+	process* aprocess=findprocess(tid.pid);
+	if (aprocess==NULL) return;
+	if (current.pid=tid.pid && current.number==tid.number)
+		current=maketid(1,1);
+	task *atask=findtask(tid);
+	if (atask==NULL) return;
+	TAILQ_REMOVE(&aprocess->task_head, atask, tailq);
+	vfree(atask);
+}
+
+/*******************************************************************************/
+/* Execute une tâche */
+
+void runtask(tid_t tid)
+{
+	task *atask=findtask(tid);
+	if (atask==NULL) return;
+	if (atask->status == TASK_STATUS_READY)
+		atask->status = TASK_STATUS_RUN;
+}
+
+/*******************************************************************************/
+/* Initialise une tâche */
+
+tid_t createtask(pid_t pid,u8 *entry, bool kerneltask)
+{
+	cli();
+	tid_t tid;
+	tid.pid=pid;
+	process* aprocess=findprocess(pid);
+	if (aprocess==NULL) return maketid(0,0);
+	task *new = (task *) vmalloc(sizeof(task));
+	TAILQ_INSERT_TAIL(&aprocess->task_head, new, tailq);
+	page *apage = virtual_page_getfree();
+	if (kerneltask)
+	{
+		new->dump.ss = SEL_KERNEL_STACK;
+		if (pid!=1)
+			new->dump.esp =
+			(u32) apage->vaddr + PAGESIZE - 16;
+		new->dump.esp = KERNEL_STACK_ADDR;
+		new->dump.eflags = 0x0;
+		new->dump.cs = SEL_KERNEL_CODE;
+		new->dump.ds = SEL_KERNEL_DATA;
+		new->dump.es = SEL_KERNEL_DATA;
+		new->dump.fs = SEL_KERNEL_DATA;
+		new->dump.gs = SEL_KERNEL_DATA;
+		new->dump.cr3 = KERNEL_PD_ADDR;
+	}
+	else
+	{
+		TAILQ_INSERT_TAIL(&aprocess->pdd->page_head, apage, tailq);
+		new->kernel_stack.ss0 = SEL_KERNEL_STACK;
+		new->kernel_stack.esp0 =
+			(u32) apage->vaddr + PAGESIZE - 16;
+		page *apage = virtual_page_getfree();
+		TAILQ_INSERT_TAIL(&aprocess->pdd->page_head, apage, tailq);
+		new->syscall_stack.ss0 = SEL_KERNEL_STACK;
+		new->syscall_stack.esp0 =
+			(u32) apage->vaddr + PAGESIZE - 16;
+		new->dump.ss = SEL_USER_STACK | RPL_RING3;
+		new->dump.esp = USER_STACK - 16;
+		new->dump.eflags = 0x0;
+		new->dump.cs = SEL_USER_CODE | RPL_RING3;
+		new->dump.ds = SEL_USER_DATA | RPL_RING3;
+		new->dump.es = SEL_USER_DATA | RPL_RING3;
+		new->dump.fs = SEL_USER_DATA | RPL_RING3;
+		new->dump.gs = SEL_USER_DATA | RPL_RING3;
+		new->dump.cr3 = aprocess->pdd->addr->paddr;
+	}
+	new->tid=getfreeptid(pid);
+	if (entry==NULL)
+		new->dump.eip = aprocess->entry;
+	else
+		new->dump.eip = entry;		
+	new->dump.eax = 0;
+	new->dump.ecx = 0;
+	new->dump.edx = 0;
+	new->dump.ebx = 0;
+	new->dump.ebp = 0;
+	new->dump.esi = 0;
+	new->dump.edi = 0;
+	new->status = TASK_STATUS_READY;
+	return new->tid;
+}
+
+/*******************************************************************************/
+/* Arrête une tâche */
+
+void stoptask(tid_t tid)
+{
+	task *atask=findtask(tid);
+	if (atask==NULL) return;
+	atask->status=TASK_STATUS_STOP;
+}
+
+/*******************************************************************************/
+/* Initialise un processus */
+
+pid_t createprocess(u8 *src, bool kerneltask)
+{
+	cli();
+	tid_t previous = current;
+	process* oldprocess=findcurrentprocess();
+	current.pid = getfreepid();
+	current.number = 0;
+	process* new=findcurrentprocess();
+	if (new==NULL) return NULL;
+	new->parent=oldprocess->pid;
+	new->pdd = virtual_pd_create();
+	new->iskernel=kerneltask;
+	TAILQ_INIT(&new->page_head);
+	TAILQ_INIT(&new->task_head);
+	setCR3(new->pdd->addr->paddr);
+	new->entry = loadelf(src, new->pid);
+	createtask(new->pid,new->entry, new->iskernel);
+	current = previous;
+	process* old=findcurrentprocess();
+	if (old==NULL) return NULL;
+	u32 cr3=KERNEL_PD_ADDR;
+	if (old->pdd!=NULL)
+		cr3=old->pdd->addr->paddr;
+	setCR3(cr3);
+	new->status=PROCESS_STATUS_READY;
+	return new->pid;
+	sti();
+}
+
+/*******************************************************************************/
+/* Détruit un processus */
+
+void deleteprocess(pid_t pid)
+{
+	cli();
+	stopprocess(pid);
+	process* aprocess=findprocess(pid);
+	if (aprocess==NULL) return;
+	task *next;
+	TAILQ_FOREACH(next, &aprocess->task_head, tailq)
+		deletetask(next->tid);
+	virtual_pd_destroy(aprocess->pdd);
+	if (current.pid==pid)
+		current=maketid(1,1);
+	aprocess->status = PROCESS_STATUS_FREE;
+	sti();
+}
+
+/*******************************************************************************/
+/* Execute un processus */
+
+void runprocess(pid_t pid)
+{
+	cli();
+	process* aprocess=findprocess(pid);
+	if (aprocess==NULL) return;
+	if (aprocess->status == PROCESS_STATUS_READY)
+	{
+		aprocess->status = PROCESS_STATUS_RUN;
+		tid_t tid=maketid(pid,1);
+		task *atask=findtask(tid);
+		if (atask==NULL) return;
+		atask->status=TASK_STATUS_RUN;
+	}
+	sti();
+}
+
+/*******************************************************************************/
+/* Arrête un processus */
+
+void stopprocess(pid_t pid)
+{
+	process* aprocess=findprocess(pid);
+	if (aprocess==NULL) return;
+	if (aprocess->status == PROCESS_STATUS_RUN)
+	{
+		aprocess->status = PROCESS_STATUS_READY;
+		task *next;
+		TAILQ_FOREACH(next, &aprocess->task_head, tailq)
+		next->status=TASK_STATUS_READY;
+	}
+}
+
+/*******************************************************************************/

lib/scheduler.c

@@ -0,0 +1,105 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "interrupts.h"
+#include "types.h"
+#include "asm.h"
+#include "memory.h"
+#include "timer.h"
+#include "vga.h"
+#include "gdt.h"
+#include "process.h"
+
+static u8 curs[4] = { "-\\|/" };
+
+static u8 curspos = 0;
+
+static u32 time = 0;
+
+/******************************************************************************/
+/* Récupère la valeur du timer */
+/* SYSCALL 
+{
+"ID":4, 
+"NAME":"getticks",
+"LIBRARY":"libsys",
+"INTERNALNAME":"gettimer",
+"DESCRIPTION":"Return the internal value of the timer",
+"ARGS": [],
+"RETURN":"u32"
+}
+END-SYSCALL */
+
+u32 gettimer(void)
+{
+	return time;
+}
+
+/******************************************************************************/
+/* Handler d'interruption du timer IRQ 0 */
+
+__attribute__ ((noreturn)) void timer_handler(regs *dump)
+{
+	exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
+	bool noerror,user;
+	if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
+	{
+		noerror=true;
+		dump->eip = caller->eip;
+		dump->cs = caller->cs;
+		dump->eflags = caller->eflags;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack_noerror);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
+			user=true;
+		}
+	}
+	else
+	{
+		noerror=false;
+		dump->eip = ((exception_stack*)caller)->eip;
+		dump->cs = ((exception_stack*)caller)->cs;
+		if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+		{
+			dump->esp = (u32) caller + sizeof(exception_stack);
+			user=false;
+		}
+		else
+		{
+			dump->esp = (u32) ((exception_stack_user*) caller)->esp;
+			dump->ss = (u32) ((exception_stack_user*) caller)->ss;
+			user=true;
+		}
+	}
+	irqendmaster();
+	showchar(0, 0, curs[curspos], 7);
+	curspos = (curspos + 1) & 0x3;
+	time++;
+	task *new=getschedule();
+	if (new!=NULL)
+	{
+		task *old=findcurrenttask();
+		memcpy(dump, &old->dump, sizeof(regs), 0);
+		switchtask(new->tid);
+	}
+	if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
+	{
+		setESP(dump);
+		restcpu_kernel();
+	}
+	else
+	{
+		setESP(dump);
+		restcpu_user();
+		iret();
+	}
+}
+
+
+/*******************************************************************************/

lib/shell.c

@@ -0,0 +1,747 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
+#include "vga.h"
+#include "3d.h"
+#include "matrix.h"
+#include "video.h"
+#include "interrupts.h"
+#include "asm.h"
+#include "cpu.h"
+#include "string.h"
+#include "gdt.h"
+#include "shell.h"
+#include "math.h"
+#include "debug.h"
+#include "VGA/ansi.c"
+#include "3D/sphere.c"
+#include "3D/man.c"
+#include "memory.h"
+#include "syscall.h"
+#include "process.h"
+
+static command commands[] = {
+	{"reboot", "", &rebootnow},
+	{"clear", "", &clear},
+	{"mode", "", &mode},
+	{"detectcpu", "", &detectcpu},
+	{"test2d", "", &test2d},
+	{"regs", "", &showregs},
+	{"gdt", "", &showgdt},
+	{"idt", "", &showidt},
+	{"info", "", &showinfo},
+	{"err", "", &err},
+	{"test", "", &test},
+	{"view", "", &view},
+	{"disasm", "", &disas},
+	{"bpset", "", &bpset},
+	{"bpclr", "", &bpclr},
+	{"help", "", &help},
+	{"logo", "", &logo},
+	{"font", "", &sfont},
+	{"test3d", "", &test3d},
+	{"detectpci", "", &detectpci},
+	{"mem", "", &showmem},
+	{"testmem", "", &testmem},
+	{"testtask", "", &testtask},
+	{"ps", "", &ps},
+};
+
+/*******************************************************************************/
+/* Shell, traite les commandes */
+
+void shell()
+{
+	static u8 field[] =
+		"                                                                                \000";
+	static u8 item[] = "                       \000";
+	int     i;
+	bool    found;
+	while (true)
+	{
+		print("\r\n# ");
+		getstring(&field);
+		print("\r\n");
+		if (strgetnbitems(&field, ' ') < 1)
+			continue;
+		strgetitem(&field, &item, ' ', 0);
+		strtolower(&item);
+		found = false;
+		for (i = 0; i < sizeof(commands) / sizeof(commands[0]);
+		     i++)
+		{
+			if (strcmp(&item, &commands[i].name) == 0)
+			{
+				(*commands[i].function) (&field);
+				found = true;
+				break;
+			}
+		}
+		if (!found)
+			printf("Commande inconnue !\r\n\000");
+	}
+}
+
+int test(void)
+{
+	print("Fonction de test !\r\n");
+	return;
+}
+
+/*******************************************************************************/
+/* Afiche les processus */
+
+static u8* processstatus[] = {"LIBRE","PRET ","EXEC.","PAUSE"};
+static u8* taskstatus[] = {"PRET ","EXEC.","PAUSE"};
+
+/*******************************************************************************/
+/* Affiche les tâches et processus */
+
+int ps()
+{
+	print("*** Processus en memoire\r\n|   PID  |  Parent|Status|K|P.|Directo.|Pages...\r\n");
+	process* aprocess=findprocess((pid_t)1);	
+	while(true)
+	{
+		printf("|%Y|%Y| %s|%c|%hh u|%Y|",(u32)aprocess->pid,(u32)aprocess->parent,processstatus[aprocess->status],(aprocess->iskernel?'X':' '),aprocess->priority,(u32)aprocess->pdd);
+		if (aprocess->pdd!=NULL) virtual_pd_show(aprocess->pdd);
+		print("\r\n");
+		aprocess=getnextprocess(aprocess,PROCESS_STATUS_ALL);
+		if (aprocess==NULL || aprocess->pid==(pid_t)1) break; 
+	}
+	print("\r\n\r\n*** Taches en memoire\r\n|   TID  |   PID  |Status| CS |   EIP  | SS |   ESP  |\r\n");
+	aprocess=findprocess((pid_t)1);
+	task* atask;
+	while(true)
+	{	
+		atask=findfirsttask(aprocess);
+		while(true)
+		{
+			printf("|%Y|%Y| %s|%hY|%Y|%hY|%Y|\r\n",(u32)atask->tid.number,(u32)atask->tid.pid,taskstatus[atask->status],atask->dump.cs,atask->dump.eip,atask->dump.ss,atask->dump.esp);
+			atask=getnexttask(atask,TASK_STATUS_ALL);
+			if (atask==NULL || (atask->tid.number==1 && atask->tid.pid==1)) break; 
+		}
+		aprocess=getnextprocess(aprocess,PROCESS_STATUS_ALL);
+		if (aprocess==NULL || aprocess->pid==(pid_t)1) break; 
+	}
+}
+
+/*******************************************************************************/
+/* Test l'usage de création de tâche */
+
+int testtask()
+{
+	print("*** Creation d'une tache\r\n");
+	pid_t pid;
+	pid = createprocess(NULL, false);
+	runprocess(pid);
+	pid = createprocess(NULL, false);
+	runprocess(pid);
+}
+
+/*******************************************************************************/
+/* Test la memoire */
+
+int testmem()
+{
+	u8     *test;
+	print("**** AVANT ALLOCATION\r\n");
+	showmem();
+	test = vmalloc(150 * 1024 * 1024);	/* 10 pages */
+	print("**** APRES ALLOCATION\r\n");
+	showmem();
+	vfree(test);
+	print("**** APRES LIBERATION\r\n");
+	showmem();
+}
+
+/*******************************************************************************/
+/* Affiche des informations sur la mémoire */
+
+int showmem()
+{
+	u32     libre = getmemoryfree();
+	u32     total = physical_getmemorysize();
+	printf("Memoire physique (TOTAL)\r\n -libre \33[40D\33[15C%H (%.2f%%)\r\n -occupee \33[40D\33[15C%H\r\n -total \33[40D\33[15C%H\r\n\r\n", libre, ((float) libre / total * 100.0f), total - libre, total);
+	printf("Memoire HEAP (NOYAU) - % u blocs\r\n -libre \33[40D\33[15C%H\r\n -occupee \33[40D\33[15C%H\r\n -allouables \33[40D\33[15C%H\r\n\r\n", getmallocnb(), getmallocfree(), getmallocused(), getmallocnonallocated());
+	printf("Plan de memoire (NOYAU)\r\n -IDT \33[40D\33[15C%X\r\n -GDT \33[40D\33[15C%X\r\n -PGD \33[40D\33[15C%X\r\n -STACK \33[40D\33[15C%X\r\n -CODE \33[40D\33[15C%X\r\n -PAGES \33[40D\33[15C%X\r\n -HEAP \33[40D\33[15C%X\r\n -VESAFB \33[40D\33[15C%X\r\n\r\n", IDT_ADDR, GDT_ADDR, KERNEL_PD_ADDR, KERNEL_STACK_ADDR, KERNEL_CODE_ADDR, KERNEL_PAGES, KERNEL_HEAP, VESA_FBMEM);
+	printf("Memoire Virtuelle (NOYAU)\r\n -pages libres \33[40D\33[16C% u\r\n -pages occupees \33[40D\33[16C% u\r\n", virtual_getpagesfree(), virtual_getpagesused());
+	return;
+}
+
+/*******************************************************************************/
+/* Affiche les périphériques PCI */
+
+int detectpci()
+{
+	scanPCI();
+}
+
+/*******************************************************************************/
+/* Change la police courante */
+
+int sfont(u8 * commandline)
+{
+	if (strgetnbitems(commandline, ' ') < 2)
+	{
+		print("Syntaxe de la commande FONT\r\nfont \33[32mpolice\r\n\r\n \33[32mpolice\33[0m\33[0m\33[25D\33[10C - \33[Nom de la police de caractere\r\n");
+		return;
+	}
+	setfont(strgetpointeritem(commandline, ' ', 1));
+}
+
+/*******************************************************************************/
+/* Affiche le logo */
+
+int logo()
+{
+	print(ansilogo);
+	return;
+}
+
+/*******************************************************************************/
+/* Renvoie les commandes disponibles */
+
+int help()
+{
+	print("Commandes disponibles :\r\n\r\n");
+	for (u32 i = 0; i < sizeof(commands) / sizeof(commands[0]); i++)
+	{
+		printf("%s \r\n", &commands[i].name);
+	}
+	return 0;
+}
+/*******************************************************************************/
+/* Met un breakpoint */
+
+int bpset(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u8     *numero;
+	u8     *pointer;
+	u8      type = DBG_EXEC;
+	if (strgetnbitems(commandline, ' ') < 3)
+	{
+		print("Syntaxe de la commande BPSET\r\nbpset \33[32mnumero address [type]\r\n\r\n \33[32mnumero\33[0m\33[0m\33[25D\33[10C - numero du breakpoint (0-3)\r\n \33[32madresse\33[0m\33[25D\33[10C - adresse du breakpoint\r\n \33[32mtype\33[0m\33[25D\33[10C - type de breakpoint (0-3)\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	numero = strtoint(&arg);
+	if (numero > 3)
+	{
+		print("numero incorrect");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 2);
+	pointer = strtoint(&arg);
+	if (strgetnbitems(commandline, ' ') == 4)
+	{
+		strgetitem(commandline, &arg, ' ', 3);
+		type = strtoint(&arg);
+	}
+	if (type > DBG_READWRITE)
+	{
+		print("type incorrect");
+		return;
+	}
+	setdebugreg(numero, pointer, type);
+}
+
+/*******************************************************************************/
+/* Retire un breakpoint */
+
+int bpclr(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u8     *numero;
+
+	if (strgetnbitems(commandline, ' ') < 2)
+	{
+		print("Syntaxe de la commande BPCLR\r\nbpclr \33[32mnumero\r\n\r\n \33[32mnumero\33[0m\33[0m\33[25D\33[10C - numero du breakpoint (0-3)\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	numero = strtoint(&arg);
+	if (numero > 3)
+	{
+		print("numero incorrect");
+		return;
+	}
+	setdebugreg(numero, 0x0, DBG_CLEAR);
+}
+
+/*******************************************************************************/
+/* Desassemble une zone de mémoire donnée */
+
+int disas(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u8     *size;
+	u8     *pointer;
+
+	if (strgetnbitems(commandline, ' ') < 3)
+	{
+		print("Syntaxe de la commande DISASM\r\ndisasm \33[32madresse taille\r\n\r\n \33[32madresse\33[0m\33[0m\33[25D\33[10C - Adresse a visualiser\r\n \33[32mtaille\33[0m\33[25D\33[10C - nombre d'octets a desassembler <256\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	pointer = strtoint(&arg);
+	size = pointer;
+	strgetitem(commandline, &arg, ' ', 2);
+	size += strtoint(&arg);
+	while (pointer < size)
+	{
+		pointer += disasm(pointer, NULL, true);
+	}
+}
+
+/*******************************************************************************/
+/* Génère des exceptions */
+
+int view(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u32     address;
+	u8      size;
+	u8     *pointerb;
+	u16    *pointerw;
+	u32    *pointerd;
+	u8      format;
+	u8      nbligne;
+	if (strgetnbitems(commandline, ' ') < 3)
+	{
+		print("Syntaxe de la commande VIEW\r\nview \33[32madresse taille [size] [nbligne]\r\n\r\n \33[32madresse\33[0m\33[0m\33[25D\33[10C - Adresse a visualiser\r\n \33[32mtaille\33[0m\33[25D\33[10C - nombre d'octets a visualiser <256\r\n \33[32mformat\33[0m\33[25D\33[10C - c (ascii) b (octet) w (mot) d (double mot)\r\n \33[32mnbligne\33[0m\33[25D\33[10C - nombre d'octets a visualiser par ligne\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	address = strtoint(&arg);
+	strgetitem(commandline, &arg, ' ', 2);
+	size = strtoint(&arg);
+	if (strgetnbitems(commandline, ' ') < 4)
+		format = 'b';
+	else
+	{
+		strgetitem(commandline, &arg, ' ', 3);
+		format = arg[0];
+	}
+	switch (format)
+	{
+		case 'c':
+			pointerb = address;
+			nbligne = 12;
+			break;
+		case 'b':
+			pointerb = address;
+			nbligne = 22;
+			break;
+		case 'w':
+			pointerw = address;
+			nbligne = 13;
+			break;
+		case 'd':
+			pointerd = address;
+			nbligne = 7;
+			break;
+	}
+	if (strgetnbitems(commandline, ' ') == 5)
+	{
+		strgetitem(commandline, &arg, ' ', 4);
+		nbligne = strtoint(&arg);
+	}
+	printf("Adresse %Y - % hhu", address, size);
+	for (u32 i = 0; i < size; i++)
+		switch (format)
+		{
+			case 'c':
+				if (i % nbligne == 0)
+					printf("\r\n:%Y - ", pointerb);
+				printf("%hhY \33[40C%c\33[41D",
+				       *(pointerb), *(pointerb++));
+				break;
+			case 'b':
+				if (i % nbligne == 0)
+					printf("\r\n:%Y - ", pointerb);
+				printf("%hhY ", *(pointerb++));
+				break;
+			case 'w':
+				if (i % nbligne == 0)
+					printf("\r\n:%Y - ", pointerw);
+				printf("%hY ", *(pointerw++));
+				break;
+			case 'd':
+				if (i % nbligne == 0)
+					printf("\r\n:%Y - ", pointerd);
+				printf("%Y ", *(pointerd++));
+				break;
+		}
+}
+/*******************************************************************************/
+/* Génère des exceptions */
+
+int err(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u32     argint;
+	if (strgetnbitems(commandline, ' ') < 2)
+	{
+		print("Syntaxe de la commande ERR\r\nerr \33[32mexception\r\n\r\n exception\33[0m\33[25D\33[10C - code de l'exception\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	argint = strtoint(&arg);
+	switch (argint)
+	{
+		case 0:
+			print("Creation d'une erreur de division par 0 !\r\n");
+			asm("movl $0x0,%ecx; divl %ecx");
+			break;
+		case 1:
+			print("Creation d'un breakpoint !\r\n");
+			setdebugreg(0, &test, DBG_EXEC);
+			test();
+			break;
+		case 2:
+			print("NON GERE!\r\n");
+			break;
+		case 3:
+			print("Creation d'une erreur interruption 3 !\r\n");
+			asm("int $0x3");
+			break;
+		case 4:
+			print("NON GERE!\r\n");
+			break;
+		case 5:
+			print("NON GERE!\r\n");
+			break;
+		case 6:
+			print("Creation d'une erreur d'opcode invalide !\r\n");
+			asm("mov %cr7, %eax");
+			break;
+		case 7:
+			print("NON GERE!\r\n");
+			break;
+		case 8:
+			print("NON GERE!\r\n");
+			break;
+		case 9:
+			print("NON GERE!\r\n");
+			break;
+		case 10:
+			print("NON GERE!\r\n");
+			break;
+		case 11:
+			print("Creation d'une erreur segment non present !\r\n");
+			setidt(&err, SEL_KERNEL_CODE, INTGATE, 104);
+			asm("int $0x68");
+			break;
+		case 12:
+			print("NON GERE!\r\n");
+			break;
+		case 13:
+			print("Creation d'une erreur general fault !\r\n");
+			asm("mov $0x666, %ax; ltr %ax");
+			break;
+		case 14:
+			if (random(0, 100) > 50)
+			{
+				print("Creation d'une erreur de page en ecriture !\r\n");
+				asm("movl $0x66666666,(0xE0000000)");
+			}
+			else
+			{
+				print("Creation d'une erreur de page en lecture !\r\n");
+				asm("movl (0xD0000000),%eax");
+			}
+			break;
+		case 15:
+			print("NON GERE!\r\n");
+			break;
+		case 16:
+			print("NON GERE!\r\n");
+			break;
+		case 17:
+			print("NON GERE!\r\n");
+			break;
+		case 18:
+			print("NON GERE!\r\n");
+			break;
+		default:
+			print("Exception qui n'existe pas !!!\r\n");
+			break;
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Information sur le démarrage */
+int showinfo()
+{
+	return 0;
+}
+
+/*******************************************************************************/
+/* Affiche les registres */
+
+int showregs()
+{
+	int20;
+	return 0;
+}
+
+/*******************************************************************************/
+/* Change le mode */
+int mode(u8 * commandline)
+{
+	u8      arg[] = "       \000";
+	u32     argint;
+	if (strgetnbitems(commandline, ' ') < 2)
+	{
+		print("Syntaxe de la commande MODE\r\nmode \33[32mmodevideo\r\n\r\n modevideo\33[0m\33[25D\33[10C - mode video a initialiser (>0x80 = graphique)\r\n");
+		return;
+	}
+	strgetitem(commandline, &arg, ' ', 1);
+	argint = strtoint(&arg);
+	changemode(argint);
+	return 0;
+}
+
+/*******************************************************************************/
+/* Efface l'écran */
+
+int clear()
+{
+	clearscreen();
+	return 0;
+}
+
+/*******************************************************************************/
+/* Redemarre */
+
+int rebootnow()
+{
+	print("<Appuyer sur une touche pour redemarrer>");
+	waitascii();
+	reboot();
+	return 0;
+}
+
+/*******************************************************************************/
+/* Teste les fonctionnalités 3D */
+
+int test3d()
+{
+	videoinfos *vinfo = getvideo_info();
+	if (!vinfo->isgraphic)
+	{
+		print("Mode graphique necessaire afin de lancer ce programme\r\n");
+		return 1;
+	}
+	model3d model;
+	float   factor = 100.0f;
+	type3D  type = TYPE3D_POINTS;
+	matrix44 rotatex, rotatey, rotatez, mrotatex, mrotatey, mrotatez,
+		identity;
+	matrix44_homogen(&identity);
+	matrix44_rotation_x(0.1f, &rotatex);
+	matrix44_rotation_y(0.1f, &rotatey);
+	matrix44_rotation_z(0.1f, &rotatez);
+	matrix44_rotation_x(-0.1f, &mrotatex);
+	matrix44_rotation_y(-0.1f, &mrotatey);
+	matrix44_rotation_z(-0.1f, &mrotatez);
+	matrix44 *transformation = &identity;
+	vector4 origin = { 0.0f, 0.0f, 0.0f, 0.0f };
+	vector4 cubeorigin = { 0.0f, 0.0f, 0.0f, 0.0f };
+	origin.x = vinfo->currentwidth / 2.0f;
+	origin.y = vinfo->currentheight / 2.0f;
+	origin.z = 70.0f;
+	cube(&model, &cubeorigin, 35.0f);
+	u8      achar = ' ';
+	u8      i;
+	while (achar != 'q' && achar != 'Q')
+	{
+		clearscreen();
+		show3dmodel(&model, transformation, &origin, factor, type);
+		achar = waitascii();
+		switch (achar)
+		{
+			case '1':
+				load3ds(&man, sizeof(man), &model);
+				break;
+			case '2':
+				load3ds(&sphere, sizeof(sphere), &model);
+				break;
+			case 17:
+				transformation = &rotatex;
+				break;
+			case 18:
+				transformation = &mrotatex;
+				break;
+			case 19:
+				transformation = &rotatey;
+				break;
+			case 20:
+				transformation = &mrotatey;
+				break;
+			case 2:
+				transformation = &rotatez;
+				break;
+			case 3:
+				transformation = &mrotatez;
+				break;
+			case '-':
+				factor -= 10.0;
+				break;
+			case '+':
+				factor += 10.0;
+				break;
+			case '*':
+				switch (type)
+				{
+					case TYPE3D_POINTS:
+						type = TYPE3D_LINES;
+						break;
+					case TYPE3D_LINES:
+						type = TYPE3D_POINTS;
+						break;
+				}
+				break;
+		}
+
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Teste les fonctionnalités 2D graphiques */
+
+int test2d()
+{
+	videoinfos *vinfo = getvideo_info();
+	if (!vinfo->isgraphic)
+	{
+		print("Mode graphique necessaire afin de lancer ce programme\r\n");
+		return 1;
+	}
+	struct vertex2d a, b, c;
+	randomize();
+	u32     color;
+	for (int i = 0; i < 2000; i++)
+	{
+		a.x = random(0, vinfo->currentwidth);
+		a.y = random(0, vinfo->currentheight);
+		b.x = random(0, vinfo->currentwidth);
+		b.y = random(0, vinfo->currentheight);
+		if (vinfo->currentdepth > 24)
+			color = egatorgb(random(0, 16));
+		else if (vinfo->currentdepth == 8)
+			color = random(0, 63);
+		else
+			color = random(0, 16);
+		v_line(&a, &b, color);
+	}
+	waitascii();
+	for (int i = 0; i < 2000; i++)
+	{
+		a.x = random(0, vinfo->currentwidth);
+		a.y = random(0, vinfo->currentheight);
+		b.x = random(0, vinfo->currentwidth);
+		b.y = random(0, vinfo->currentheight);
+		c.x = random(0, vinfo->currentwidth);
+		c.y = random(0, vinfo->currentheight);
+		if (vinfo->currentdepth > 24)
+			color = egatorgb(random(0, 16));
+		else if (vinfo->currentdepth == 8)
+			color = random(0, 63);
+		else
+			color = random(0, 16);
+		trianglefilled(&a, &b, &c, color);
+		triangle(&a, &b, &c, egatorgb(4));
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Lit l'IDT et l'affiche */
+
+int showidt()
+{
+	u32     index, i = 0;
+	idtdes *desc;
+	struct idtr idtreg;
+	sidt(idtreg);
+	printf("Information sur l'IDT\r\nAdresse:%X Limite:%hX\r\n",
+	       idtreg.base, (u32) idtreg.limite);
+	desc = idtreg.base;
+	for (index = 0; index < idtreg.limite / sizeof(idtdes); index++)
+	{
+		u32     select = desc[index].select;
+		u32     offset =
+			desc[index].offset0_15 +
+			(desc[index].offset16_31 << 16);
+		u32     type = desc[index].type & 0x0F00;
+		u8     *typestr1, *typestr2;
+		if (i >= 32 & i <= 39)
+			typestr1 = "IRQ master";
+		else if (i >= 96 & i <= 103)
+			typestr1 = "IRQ slave ";
+		else if (i < 19)
+			typestr1 = "EXCEPTION ";
+		else
+			typestr1 = "INTERRUPT ";
+		if (type == INTGATE)
+			typestr2 = "INTGATE";
+		else if (type == TRAPGATE)
+			typestr2 = "TRAPGATE";
+		else if (type == TASKGATE)
+			typestr2 = "TASKGATE";
+		else if (type == CALLGATE)
+			typestr2 = "CALLGATE";
+		else if (type == LDTDES)
+			typestr2 = "LDTDES";
+		else
+			print("inconnu");
+		printf("%s % hu %hY:%Y - %s\r\n", typestr1, i++, select,
+		       offset, typestr2);
+
+		if (i % 32 == 0)
+		{
+			print("\r\n<Appuyez sur une touche>\r\n");
+			waitascii();
+		}
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Lit les descripteurs GDT et les affiche */
+
+int showgdt()
+{
+	u32     index;
+	struct gdtr gdtreg;
+	sgdt(gdtreg);
+	printf("Information sur la GDT\r\nAdresse:%X Limite:%hX\r\n",
+	       gdtreg.base, gdtreg.limite);
+	for (index = 0; index < gdtreg.limite; index += sizeof(gdtdes))
+	{
+		if (!isdesvalid(index))
+			printf("\033[31m");
+		printf("SEL =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\033[0m\r\n", index, getdesbase(index), getdeslimit(index), getdesdpl(index), getdestype(index), getdessize(index), getdesbit3(index), getdesbit2(index), getdesbit1(index), getdesalign(index));
+	}
+	return 0;
+}
+
+/*******************************************************************************/
+/* Detecte et affiche les information sur le CPU */
+
+int detectcpu()
+{
+	cpuinfo cpu;
+	u8      noproc[] = "\033[31mInconnu\033[0m\000";
+	strcpy(&noproc, &cpu.detectedname);
+	getcpuinfos(&cpu);
+	printf("\r\nDetection du processeur\r\033[1m Revision \t:%d\r Modele \t:%d\r Famille \t:%d\r Nom cpuid\t:%s\rJeux d'instruction\t:%s\033[0m\r\n\000", cpu.stepping, cpu.models, cpu.family, &cpu.detectedname, &cpu.techs);
+	return 0;
+}
+
+/*******************************************************************************/

lib/string.c

@@ -1,65 +1,412 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas             */
+/*                                                                             */
 #include <string.h>
 
+/******************************************************************************/
 /* Compare 2 chaines de caractère et renvoie la premiere distance (diff) */
-s8 strcmp(const u8 *src,const u8 *des)
+
+s8 strcmp(const u8 * src, const u8 * dest)
 {
 	register s8 result;
 	do
 	{
-	if ((result = *src - *des++) != 0) break;
+		if ((result = *src - *dest++) != 0)
+			break;
 	}
-	 while (*src++!=0);
-  return result;
+	while (*src++ != 0);
+	return result;
 }
 
+/******************************************************************************/
+/* Trouve la premiere occurence d'un caractère dans une chaine et renvoie un pointeur */
 
-/* Trouve la premiere occurence d'un caractère dans une chaine */
- 
-u8 * strchr(const u8 *src, u8 achar)
+u8     *strchr(const u8 * src, u8 achar)
 {
-	for(; *src!= achar; ++src)
-		if (*src == 0) return 0;
-	return (u8*)src;
+	for (; *src != achar; ++src)
+		if (*src == 0)
+			return 0;
+	return (u8 *) src;
 }
 
+/******************************************************************************/
+/* Trouve la premiere occurence d'un caractère dans une chaine  */
+
+u32 strchrpos(const u8 * src, u8 achar)
+{
+	u32     i;
+	for (i = 0; *(src + i) != achar; ++i)
+		if (*(src + i) == 0)
+			return 0;
+	return i;
+}
+
+/******************************************************************************/
 /* Renvoie la taille de la chaine */
 
-u32 strlen(const u8 *src)
+u32 strlen(const u8 * src)
 {
-	u32 size;
+	u32     size;
 
-	for (size = 0; *(src+size) != 0; size++);
+	for (size = 0; *(src + size) != 0; size++);
 	return size;
 }
 
-
+/******************************************************************************/
 /* copie une chaine dans une autre */
-u8* strcpy(const u8 *src, u8 *des)
+u8     *strcpy(const u8 * src, u8 * dest)
 {
-	u8 *temp = des;
-	while ((*des++ = *src++) != 0);
+	u8     *temp = dest;
+	while ((*dest++ = *src++) != 0);
 	return temp;
 }
 
-
+/******************************************************************************/
 /* copie une portion limité d'une chaine asciiZ*/
 
-u8 *strncpy(const u8 *src,u8 *des,u32 count)
+u8     *strncpy(const u8 * src, u8 * dest, u32 count)
 {
-	u8 *temp = des;
-	while (count) {
-		if ((*temp = *src) != 0) src++;
+	u8     *temp = dest;
+	while (count)
+	{
+		if ((*temp = *src) != 0)
+			src++;
 		temp++;
 		count--;
 	}
-	return des;
+	return dest;
 }
 
+/******************************************************************************/
 /* concatene 2 chaines de caractère */
-u8 *strcat( const u8 *src,u8 *des)
+
+u8     *strcat(const u8 * src, u8 * dest)
 {
-	u8 *temp = des;
-	while (*des!=0) des++;
-	while ((*des++ = *src++) != 0);
+	u8     *temp = dest;
+	while (*dest != 0)
+		dest++;
+	while ((*dest++ = *src++) != 0);
 	return temp;
 }
+
+/******************************************************************************/
+/* Met en minuscule */
+
+void strtolower(u8 * src)
+{
+	while (*src != 0)
+	{
+		if ((*src >= 'A') && (*src <= 'Z'))
+			*src = *src + 'a' - 'A';
+		src++;
+	}
+}
+
+/******************************************************************************/
+/* Met en majuscule */
+
+void strtoupper(u8 * src)
+{
+	while (*src != 0)
+	{
+		if ((*src >= 'a') && (*src <= 'z'))
+			*src = *src - ('a' - 'A');
+		src++;
+	}
+}
+
+/******************************************************************************/
+/* inverse la casse */
+
+void strinvertcase(u8 * src)
+{
+	while (*src != 0)
+	{
+		if ((*src >= 'A') && (*src <= 'Z'))
+			*src = *src + 'a' - 'A';
+		else if ((*src >= 'a') && (*src <= 'z'))
+			*src = *src - ('a' - 'A');
+		src++;
+	}
+}
+
+/******************************************************************************/
+/* Met une majuscule et met le reste en minuscule */
+
+void stronecase(u8 * src)
+{
+	if ((*src >= 'a') && (*src <= 'z'))
+		*src = *src - ('a' - 'A');
+	while (*src != 0)
+	{
+		src++;
+		if ((*src >= 'A') && (*src <= 'Z'))
+			*src = *src + 'a' - 'A';
+	}
+}
+
+/******************************************************************************/
+/* Fixe la taille de la chaine */
+
+void strsetlen(u8 * src, u32 size)
+{
+	*(src + size) = '\000';
+}
+
+/******************************************************************************/
+/* Inverse la chaine */
+
+void strinvert(u8 * src)
+{
+	u8     *dst = src + strlen(src) - 1;
+	while (src < dst)
+	{
+		u8      char1 = *dst;
+		u8      char2 = *src;
+		*dst = char2;
+		*src = char1;
+		src++;
+		dst--;
+	}
+}
+
+/******************************************************************************/
+/* Remplace tout les caractères rechercher par un autre */
+
+void strreplace(u8 * src, u8 search, u8 replaced)
+{
+	u8     *pos = strchr(src, search);
+	while (pos != 0)
+	{
+		*pos = replaced;
+		pos = strchr(src, search);
+	}
+}
+
+/******************************************************************************/
+/* Rempli de caractère */
+
+u8     *strfill(u8 * dst, u8 pattern, u32 size)
+{
+	u32     i;
+	for (i = 0; i <= size; i++)
+		*(dst + i) = pattern;
+	*(dst + i + 1) = '\000';
+	return dst;
+}
+
+/******************************************************************************/
+/* Renvoie la partie gauche d'une chaine */
+
+void strleft(u8 * src, u8 * dest, u32 size)
+{
+	u32     i;
+	for (i = 0; (*(src + i) != 0) && (i < size); i++)
+		*dest++ = *(src + i);
+	*dest++ = '\000';
+}
+
+/******************************************************************************/
+/* Renvoie la partie droite d'une chaine */
+
+void strright(u8 * src, u8 * dest, u32 size)
+{
+	u32     i;
+	u32     begin = strlen(src) - size;
+	for (i = 0; (*(src + i + begin) != 0) && (i < size); i++)
+		*dest++ = *(src + i + begin);
+	*dest++ = '\000';
+}
+
+/******************************************************************************/
+/* Supprime une portion de chaine */
+
+void strdelete(u8 * src, u32 index, u32 size)
+{
+	u32     i;
+	u32     realsize = strlen(src) - index - size;
+	for (i = 0; (*(src + index + size + i) != 0) && (i < realsize);
+	     i++)
+		*(src + index + i) = *(src + index + size + i);
+	*(src + index + i) = '\000';
+}
+
+/******************************************************************************/
+/* Insert une portion dans la chaine */
+
+void strinsert(u8 * src, u8 * dest, u32 index)
+{
+	u32     i;
+	u32     realsize = strlen(src);
+	u32     copysize = strlen(dest) - index;
+	for (i = 0; i <= copysize; i++)
+		*(dest + index + realsize + copysize - i) =
+			*(dest + index + copysize - i);
+	for (i = 0; (*(src + i) != 0); i++)
+		*(dest + index + i) = *(src + i);
+}
+
+/******************************************************************************/
+/* Supprime les délimiteurs consécutifs */
+
+void strcompressdelimiter(u8 * src, u8 delim)
+{
+	u8     *pos = strchr(src, delim);
+	while (pos != 0)
+	{
+		u8      i;
+		for (i = 0; (*(pos + i) != 0) && (*(pos + i) == delim);
+		     i++);
+		if (i > 1)
+			strdelete(pos, 1, i - 1);
+		pos = strchr(pos + 1, delim);
+	}
+}
+
+/******************************************************************************/
+/* Récupérère l'élément N d'une liste utilisant un délimiteur */
+
+u8     *strgetitem(u8 * src, u8 * dest, u8 delim, u32 index)
+{
+	u32     i;
+	u8     *pos = strgetpointeritem(src, delim, index);
+	for (i = 0; (*(pos + i) != 0) && (*(pos + i) != delim); i++)
+		*(dest + i) = *(pos + i);
+	*(dest + i) = '\000';
+	return dest;
+}
+
+/******************************************************************************/
+/* Récupérère un pointeur sur l'élément N d'une liste utilisant un délimiteur */
+
+u8     *strgetpointeritem(u8 * src, u8 delim, u32 index)
+{
+	u32     i;
+	u8     *pos = src;
+	for (i = 0; i < index; i++)
+		pos = strchr(pos + 1, delim);
+	if (*pos == delim)
+		pos++;
+	return pos;
+}
+
+/******************************************************************************/
+/* Récupérère le nombre d'éléments d'une liste utilisant un délimiteur */
+
+u32 strgetnbitems(u8 * src, u8 delim)
+{
+	u32     number = 0;
+	if (*src == 0)
+		return 0;
+	number++;
+	u8     *pos = strchr(src, delim);
+	while (pos != 0)
+	{
+		pos = strchr(pos + 1, delim);
+		number++;
+	}
+	return number;
+}
+
+/******************************************************************************/
+/* Renvoie la base minimum du nombre */
+
+u8      base[] = " 0123456789ABCDEF\000";
+
+u8 strgetminbase(u8 * src)
+{
+	u8      temp[] = "                                           \000";
+	u8     *dst = &temp;
+	strtoupper(strcpy(src, &temp));
+	u8      max = 0;
+	while (*dst != 0)
+	{
+		u32     result = strchrpos(&base, *dst++);
+		if (result == 0)
+			return 0;
+		if (result > max)
+			max = result;
+	}
+	if (max > 10)
+		return 16;
+	else if (max > 8)
+		return 10;
+	else if (max > 2)
+		return 8;
+	else
+		return 2;
+}
+
+/******************************************************************************/
+/* Renvoie la base du nombre */
+
+u8      hexa[] = "0x\000";
+u8      bases[] = " bodh\000";
+u8      basesnum[] = { 0, 2, 8, 10, 16 };
+
+u8      declaredbase = 10;
+u8      minbase = 0;
+u8 strgetbase(u8 * src)
+{
+	u8      temp[] = "                               \000";
+	strleft(src, &temp, 2);
+	if (strcmp(&temp, &hexa) == 0)
+	{
+		declaredbase = 16;
+		u8      size = strlen(src);
+		strright(src, &temp, size - 2);
+		minbase = strgetminbase(&temp);
+	}
+	else
+	{
+		strright(src, &temp, 1);
+		declaredbase = basesnum[strchrpos(&bases, temp[0])];
+		if (declaredbase > 0)
+		{
+			u8      size = strlen(src);
+			strleft(src, &temp, size - 1);
+			minbase = strgetminbase(&temp);
+		}
+		else
+		{
+			minbase = strgetminbase(src);
+			declaredbase = minbase;
+		}
+	}
+	if (declaredbase >= minbase && minbase != 0)
+		return declaredbase;
+	else
+		return 0;
+}
+
+/******************************************************************************/
+/* Transforme une chaine en nombre */
+
+u32 strtoint(u8 * src)
+{
+	u8     *temp = src;
+	u32     result = 0;
+	u8      thebase = strgetbase(src);
+	u32     multi = 1;
+	u8      shorter = 0;
+
+	if (thebase == 0)
+		return 0;
+	if (*(src + 1) == 'x')
+		shorter = 2;
+	while (*++temp != 0);
+	while (*temp == 0 || *temp == 'b' || *temp == 'o' || *temp == 'd'
+	       || *temp == 'h')
+		temp--;
+	while (src + shorter <= temp)
+	{
+		u8      achar = *temp--;
+		if ((achar >= 'a') && (achar <= 'z'))
+			achar = achar - ('a' - 'A');
+		result = result + multi * (strchrpos(&base, achar) - 1);
+		multi = multi * thebase;
+	}
+	return result;
+}
+
+/*******************************************************************************/

lib/syscall.c

@@ -0,0 +1,93 @@
+/*******************************************************************************/
+/* COS2000 - Compatible Operating System - LGPL v3 - Horde Nicolas             */
+/*                                                                             */
+#include <types.h>
+#include <gdt.h>
+#include <asm.h>
+#include <memory.h>
+#include <interrupts.h>
+#include <syscall.h>
+#include <process.h>
+
+ /* 32bit SYSENTER instruction entry.
+  *
+  * Arguments:
+  * %eax System call number.
+  * %ebx Arg1
+  * %esi Arg2
+  * %edi Arg3*/
+
+extern wrapper_sysenter;
+
+/*******************************************************************************/
+/* Initialise les appels système par SYSENTER/SYSEXIT */
+
+void initsyscall(void)
+{
+	wrmsr(0x174, SEL_KERNEL_CODE, 0x0);
+	wrmsr(0x175, NULL, 0x0);
+	wrmsr(0x176, &wrapper_sysenter, 0x0);
+	return;
+}
+
+/*******************************************************************************/
+/* Fonction permettant de tester le fonctionnement de SYSENTER */
+/* SYSCALL 
+{
+"ID":0,
+"LIBRARY":"libsys",
+"NAME":"testapi",
+"INTERNALNAME":"testapi",
+"DESCRIPTION":"Simple function to test if SYSCALL API is correctly running",
+"ARGS": [
+{"TYPE":"u32","NAME":"arg1","DESCRIPTION":"first argument of your choice"},
+{"TYPE":"u32","NAME":"arg2","DESCRIPTION":"second argument of your choice"},
+{"TYPE":"u32","NAME":"arg3","DESCRIPTION":"third argument of your choice"}
+],
+"RETURN":"u32",
+"DUMP":"yes"
+}
+END-SYSCALL */
+
+u32 testapi(u32 arg1, u32 arg2, u32 arg3, regs* dump)
+{
+	printf("Appel syscall %u depuis %Y:%Y avec arguments => ARG1:%Y ARG2:%Y ARG3:%Y\r\n", dump->eax, (u32) dump->cs, dump->eip, arg1, arg2, arg3);	
+	return;
+}
+
+/*******************************************************************************/
+/* Entrée pour les appels système SYSENTER */
+__attribute__ ((noreturn)) void sysenter_handler(regs *dump)
+{
+	sti();
+	switch (dump->eax)
+	{
+     		case 5:
+			dump->eax=(u32) processexit(dump->ebx);
+			break;
+     		case 4:
+			dump->eax=(u32) gettimer();
+			break;
+     		case 2:
+			dump->eax=(u32) print(dump->ebx);
+			break;
+     		case 1:
+			dump->eax=(u32) waitascii();
+			break;
+     		case 0:
+			dump->eax=(u32) testapi(dump->ebx, dump->esi, dump->edi, dump);
+			break;
+
+		default:
+			printf("Appel syscall vers fonction inexistante en %Y:%Y", dump->cs, dump->eip);
+			break;
+	}
+      //dump->eflags &= ~(1 << 6);
+      dump->eflags |= (1 << 6);
+	setESP(dump);
+	restcpu_user();
+	sysexit();
+}
+
+/*******************************************************************************/
+