Librairie kernel avec fonctions - Page 1

Voilà mon problème, je voudrais savoir si une librarie Kernel ou Nostub est capable d'exporter des labels, voici un exemple:

void *CursorTimer; //Déclaration dans le programme

void Fonction(void) {StateCursorTimer=1; GX_CreateTimer(CursorTimer,80);}

En effet lorsque je compile, un message d'erreur apparaît: Exported label is not valid

Oui. Le "Exported label is not valid" doit vouloir dire que tu as sauté un numéro de label exporté (si tu exportes le label libkrnl__x, tu dois aussi exporter les labels libkrnl__0000, libkrnl__0001, ..., libkrnl__{x-2}, libkrnl__{x-1}). Ça n'a rien à voir avec le type de label.

Non, ce n'est pas ça le problème, je ne pas sauté de label voici le code:


//Le programme pour la gestion du curseur sous Windows ST
Cursor.h

#define DesinstallCursor_Timer DesinstallCursor

#define XCursor system->XCursor
#define YCursor system->YCursor
#define CursorKeys system->CursorKeys
//Variables pour prévention des erreurs et calibrage du curseur

short HeightCursor;
#define StateCursorTimer system->Cursor_TimerState
#define StateCursorEnabled system->Cursor_State

//Structure de sauvegarde de l'horloge de gestion du curseur: Cursor_Timer
#define TimerCursor system->CursorTimer

//Enumérations Curseurs standard
enum CursorsSprite {C_Pointer = 0, C_Sablier = 130, C_Stop = 260, C_Help = 390};
enum CursorButtons {C_NOTHING=0, C_ENTER=1, C_APPS=2, C_ALL=3};

//Structure d'état des touches directionnels
GX_joypad Cursor_JoyPad;

/*-------------------------------------------------------------
Install/Desinstall l'horloge système pour la gestion du curseur
-------------------------------------------------------------*/
void InstallCursor_Timer(void) {if (StateCursorTimer==FALSE) {TimerCursor=GX_CreateTimer (Cursor_Timer,CursorSpeed); StateCursorTimer=TRUE;}}
void DesinstallCursor(void) {if (StateCursorTimer==TRUE) {GX_DestroyTimer (TimerCursor); StateCursorTimer=FALSE;}}

/*--------------------------------------------------------
Install l'horloge du curseur, affiche le curseur à l'écran
--------------------------------------------------------*/
void ActivateCursor(void)
{
if (StateCursorEnabled==FALSE) {
InstallCursor_Timer();

AdjustCursor();
AdjustHeightCursor();
SaveCursorBuffer(XCursor,YCursor);
SaveExtrenumCursorBuffer(XCursor,YCursor);

DrawCursor();

LoadExtrenumCursorBuffer(XCursor,YCursor);

StateCursorEnabled=TRUE;}
}


/*------------------------------------------------------------
Desinstall l'horloge du curseur et efface le curseur à l'écran
------------------------------------------------------------*/
void DesactivateCursor(void)
{
if (StateCursorEnabled==TRUE) {
DesinstallCursor_Timer();

RestoreCursorBuffer(XCursor,YCursor);
LoadExtrenumCursorBuffer(XCursor,YCursor);
StateCursorEnabled=FALSE;}
}


/*---------------------------------------------------------
Selectionne par défaut le pointeur et le centre sur l'écran
---------------------------------------------------------*/
void InstallCursor(void)
{
CenterCursorInScreen(); //Installation du curseur
SelectCursor(C_Pointer);
}


/*-------------------------------------------------------------------------------------------
Teste l'état des touches directionnel et déplace le curseur en fonction de XCursor et YCursor
---------------------------------------------------------------------------------------------*/
void TestCursorKeys(void)
{
Cursor_JoyPad=GX_ReadJoypad();

if (StateCursorEnabled==1 && (Cursor_JoyPad.down || Cursor_JoyPad.up || Cursor_JoyPad.right || Cursor_JoyPad.left)) {

DesactivateCursor();

if (Cursor_JoyPad.down) {if (Cursor_JoyPad.hand) YCursor+=StepCursorY; else {YCursor++; CursorKeys|=0x01;}}
if (Cursor_JoyPad.up) {if (Cursor_JoyPad.hand) YCursor-=StepCursorY; else {YCursor--; CursorKeys|=0x02;}}
if (Cursor_JoyPad.right) {if (Cursor_JoyPad.hand) XCursor+=StepCursorX; else {XCursor++; CursorKeys|=0x04;}}
if (Cursor_JoyPad.left) {if (Cursor_JoyPad.hand) XCursor-=StepCursorX; else {XCursor--; CursorKeys|=0x08;}}

ActivateCursor();} else CursorKeys=0x00;
}


/*----------------------------------------------------------------------
Sauvegarde/Charge dans le buffer l'image précédent l'affichage du curseur
------------------------------------------------------------------------*/
void SaveCursorBuffer(short X,short Y)
{
if (X>Screen_Xmax-15) X=Screen_Xmax-15;
if (Y>Screen_Ymax-HeightCursor+1) Y=Screen_Ymax-HeightCursor+1;

W_GetGraySprite16(X,Y,HeightCursor,GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE),system->Cursor_BufferSave[0],system->Cursor_BufferSave[1]);
}

void RestoreCursorBuffer(short X,short Y)
{
if (X>Screen_Xmax-15) X=Screen_Xmax-15;
if (Y>Screen_Ymax-HeightCursor+1) Y=Screen_Ymax-HeightCursor+1;

W_GraySprite16_MASK(X,Y,HeightCursor,system->Cursor_BufferSave[0],system->Cursor_BufferSave[1],system->Cursor_BufferSave[0],system->Cursor_BufferSave[1],GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE));
}


/*-----------------------------------------------
Sauvegarde/Charge dans le buffer l'image extrème
-------------------------------------------------*/
void SaveExtrenumCursorBuffer(short X,short Y)
{
short X1=0,Y1=0; //,X2=0,Y2=0;

if (X>Screen_Xmax-15) {X1=0;Y1=Y;}
if (Y>Screen_Ymax-15) Y1=Screen_Ymax-15;

if (X>Screen_Xmax-15) {
W_GetGraySprite16(X1,Y1,16,GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE),system->Cursor_BufferExtrenum[0],system->Cursor_BufferExtrenum[1]);}
}

void LoadExtrenumCursorBuffer(short X,short Y)
{
short X1=0,Y1=0; //,X2=0,Y2=0;

if (X>Screen_Xmax-15) {X1=0;Y1=Y;}
if (Y>Screen_Ymax-15) Y1=Screen_Ymax-15;

if (X>Screen_Xmax-15) {
W_GraySprite16_MASK(X1,Y1,16,system->Cursor_BufferExtrenum[0],system->Cursor_BufferExtrenum[1],system->Cursor_BufferExtrenum[0],system->Cursor_BufferExtrenum[1],GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE));}
}


/*--------------------------
Affiche à l'écran le curseur
----------------------------*/

void DrawCursor(void)
{
if (system->Cursor_XOR==FALSE)
W_GraySprite16_MASK(XCursor,YCursor,HeightCursor,system->Cursor_Buffer[0],system->Cursor_Buffer[1],system->Cursor_Buffer[2],system->Cursor_Buffer[3],GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE));
else {
W_GraySprite16_XOR(XCursor,YCursor,HeightCursor,system->Cursor_Buffer[0],system->Cursor_Buffer[1],GetPlane(LIGHT_PLANE),GetPlane(DARK_PLANE));}
}


/*----------------------------------------------------------------
Ajuste la hauteur du sprite pour ne pas planter le système en YMax
------------------------------------------------------------------*/
void AdjustHeightCursor(void)
{
if (YCursor>Screen_Ymax-16) HeightCursor=(Screen_Ymax+1)-YCursor;
else HeightCursor=15;
}

/*-------------------------------------
Fonction ajustant le curseur à l'écran.
Le curseur ne d"épassera pas l'écran.
--------------------------------------*/
void AdjustCursor(void)
{
if (XCursor<0) XCursor=0;
if (XCursor>Screen_Xmax) XCursor=Screen_Xmax;
if (YCursor<0) YCursor=0;
if (YCursor>Screen_Ymax) YCursor=Screen_Ymax;
}

/*----------------------------------------
Selectionne un curseur par défaut de 0 à 3
------------------------------------------*/
void SelectCursor(short CursorNumber)
{
InitCursor(extract_data(0,W_GetSymByName("windows\wingfx"))+CursorNumber);
}

/*----------------------------------------------------------------------------
Initialise les variables XCursor et YCursor pour centrer le curseur à l'écran
-----------------------------------------------------------------------------*/
void CenterCursorInScreen(void) {XCursor=(Screen_Xmax/2)-8;YCursor=(Screen_Ymax/2)-8;}

/*-----------------------------------------------------
Place le curseur à la postion X et Y souhaité.
Attention ses valeurs sont pour l'affichage du sprite
------------------------------------------------------*/
void PlaceCursor(short X,short Y)
{
DesactivateCursor();
XCursor=X; YCursor=Y;
ActivateCursor();
}


/*---------------------------------------------------------------------------------------
Renvoie 1 si le curseur et dans la zone x0,y0,x1,y1 et un bouton du type Cu_... et pressé
-----------------------------------------------------------------------------------------*/
BOOL GetCursorIn(short x0_CurInt,short y0_CurInt,short x1_CurInt,short y1_CurInt,short CurButtonInt)
{
if ((XCursor+system->Cursor_ActionX>=x0_CurInt && XCursor+system->Cursor_ActionX<=x1_CurInt && YCursor+system->Cursor_ActionY>=y0_CurInt && YCursor+system->Cursor_ActionY<=y1_CurInt) && ((CurButtonInt==C_NOTHING) || (CurButtonInt==C_ENTER && (_TestKey(RR_ENTER) || _TestKey(RR_ENTER2)==TRUE)) || (CurButtonInt==C_APPS && (_TestKey(RR_APPS)==TRUE)) || (CurButtonInt==C_ALL && (_TestKey(RR_ENTER) || _TestKey(RR_ENTER2) || _TestKey(RR_APPS)==TRUE)))) return 1;
else return 0;
}

/*-----------------------------------------------------------------------------
Cette fonction place le curseur au centre d'un rectangle défini par x0,y0,x1,y1
-------------------------------------------------------------------------------*/
void CenterCursor_In(short x0,short y0,short x1,short y1) {PlaceCursor(GetCenterX(1,x0,x1)+system->Cursor_ActionX,GetCenterY(1,y0,y1)+system->Cursor_ActionY);}

/*-----------------------------------------------
Copie les données du curseur dans les buffers...
-------------------------------------------------*/
void InitCursor(void *Data)
{
DesactivateCursor();

system->Cursor_ActionX=*(BYTE*)(Data);
system->Cursor_ActionY=*(BYTE*)(Data+1);

memset(system->Cursor_Buffer[0],0,32);
memset(system->Cursor_Buffer[0],0,32);
memset(system->Cursor_Buffer[0],0,32);
memset(system->Cursor_Buffer[0],0,32);

memcpy(system->Cursor_Buffer[0],Data+2,32);
memcpy(system->Cursor_Buffer[1],(Data+2+32),32);
memcpy(system->Cursor_Buffer[2],(Data+2+64),32);
memcpy(system->Cursor_Buffer[3],(Data+2+96),32);

ActivateCursor();
}

BOOL CursorIn(short x0,short y0,short x1,short y1)
{
if ((XCursor+15)<x0 || XCursor>x1 || (YCursor+15)<y0 || YCursor>y1) return 0;
else return 1;
}

void DesactivateCursor2(short x0,short y0,short x1,short y1)
{
if (CursorIn(x0,y0,x1,y1)) DesactivateCursor();
else SelectCursor(C_Sablier);
}

void ActivateCursor2(void) {SelectCursor(C_Pointer); ActivateCursor();}


//La librarie WinAPI

/*------
Cursor.h
-------*/
#define CursorSpeed winapi__0000
#define StepCursorX winapi__0001
#define StepCursorY winapi__0002

#define InstallCursor_Timer winapi__0003
#define DesinstallCursor winapi__0004
#define ActivateCursor winapi__0005
#define DesactivateCursor winapi__0006
#define InitCursor winapi__0007
#define InstallCursor winapi__0008
#define TestCursorKeys winapi__0009
#define SaveCursorBuffer winapi__000A
#define RestoreCursorBuffer winapi__000B
#define SaveExtrenumCursorBuffer winapi__000C
#define LoadExtrenumCursorBuffer winapi__000D
#define DrawCursor winapi__000E
#define AdjustHeightCursor winapi__000F
#define AdjustCursor winapi__0010
#define SelectCuror winapi__0011
#define CenterCursorInScreen winapi__0012
#define PlaceCursor winapi__0013
#define GetCursorIn winapi__0014
#define CenterCursor_In winapi__0015
#define CursorIn winapi__0016
#define ActivateCursor2 winapi__0017
#define DesactivateCursor2 winapi__0018

#include "Cursor.h"


Je résume le problème: Pour initialisé l'événement curseur, je doit utiliser une fonction CursorTimer mais cette fonction n'hésite pas dans la librarie mais plutôt dans le programme principal (des applications à Windows ST et Windows ST lui même).
Je préférerais faire ça sous forme de ROM_CALLS mais je voudrais bien que Pphd m'explique comment faire et quels sont les limites des ROM_CALLS.

Ah, je vois ce que tu veux faire. Ben, tu devras passer un pointeur en paramètre à tes fonctions de ta librairie. Ou alors à une fonction d'initialisation. Tu ne peux pas référencer un label du programme principal directement dans une librairie dynamique.

D'ailleurs, dans une librairie statique, tu peux référencer un label du programme principal sans problème.

Oui mais je ne veut surtout pas de librairie statique tu imagine chaque application Windows ST, il faut un minimum de 30ko.
Je croit avoir trouvé le problème, j'ai remarqué que lorsque je passe à une déclaration de winapi > 000D j'ai ce message d'erreur, je me demande si TIGCC et limité en fonctions pour les libraries dynamique.

>je me demande si TIGCC et limité en fonctions pour les libraries dynamique.
Non.
Vérifie que tu as bien défini la fonction à laquelle tu as donné le numéro 000E.

Et ce que j'ai dit au #3 reste valable. Si tu veux accéder à des labels du programme principal, il faut passer des pointeurs à tes fonctions de la librairie. La librairie dynamique ne peut pas accéder directement aux labels de ton programme principal.

Ca je le sais et je l'ai fait mais le problème est toujours là, en effet j'ai fait plusieurs teste et lorsque je depasse le nombre 15 000F en Hexa j'ai ce message d'erreur qui apparâit, je ne comprend pas pourtant tout est bien écrit???

C'est peut-être un bogue de TIGCC en fin de compte. Un moment, je vais voir ça.

Non. Je ne peux pas reproduire ton problème. Je pense que c'est un problème de ton code.

Je cherche mais il ya beaucoup de chance que tu ais résond mais je trouve quand même la création de librairies Kernel limité

C'est le format kernel qui est limitant. On a implémenté tout ce qui est prévu par le format.

Voici un exemple plus restrinct est le problème y est toujours:

Cursor.h void InstallCursor_Timer(void) {} void DesinstallCursor(void) {} void SaveCursorBuffer(short X,short Y){} void RestoreCursorBuffer(short X,short Y){} void SaveExtrenumCursorBuffer(short X,short Y){} void LoadExtrenumCursorBuffer(short X,short Y){} void DrawCursor(void){} void AdjustHeightCursor(void){} void AdjustCursor(void){} void ActivateCursor(){} void DesactivateCursor(void){} void InitCursor(void *Data){} void SelectCursor(short CursorNumber){} void InstallCursor(void){} void TestCursorKeys(void){} void PlaceCursor(short X,short Y) {} BOOL GetCursorIn(short x0_CurInt,short y0_CurInt,short x1_CurInt,short y1_CurInt,short CurButtonInt){} void CenterCursor_In(short x0,short y0,short x1,short y1) {} BOOL CursorIn(short x0,short y0,short x1,short y1){} void DesactivateCursor2(short x0,short y0,short x1,short y1){} void ActivateCursor2(void) {} void CenterCursorInScreen(void) {}

Winapi.c

#define USE_KERNEL

#include <tigcclib.h> // Include All Header Files

char _library[] = "Library Windows ST API (WinAPI)";

short _ti92plus, _ti89;

/*------
Cursor.h
-------*/
#define InstallCursor_Timer winapi__0000
#define DesinstallCursor winapi__0001
#define SaveCursorBuffer winapi__0002
#define RestoreCursorBuffer winapi__0003
#define SaveExtrenumCursorBuffer winapi__0004
#define LoadExtrenumCursorBuffer winapi__0005
#define DrawCursor winapi__0006
#define AdjustHeightCursor winapi__0007
#define AdjustCursor winapi__0008
#define ActivateCursor winapi__0009
#define DesactivateCursor winapi__000A
#define InitCursor winapi__000B
#define SelectCuror winapi__000C
#define InstallCursor winapi__000D
#define TestCursorKeys winapi__000E
#define PlaceCursor winapi__000F
#define GetCursorIn winapi__0010
#define CenterCursor_In winapi__0011
#define CursorIn winapi__0012
#define DesactivateCursor2 winapi__0013
#define ActivateCursor2 winapi__0014
#define CenterCursorInScreen winapi__0015

#include "Cursor.h"

La tu pourras faire des teste et tu verra que ça ne vient pas du code

Je ne sais pas si le problème vient de là (je vais vérifier), mais:
char _library[] = "Library Windows ST API (WinAPI)";
Ça ne va pas, ça. C'est int _library; qu'il faut mettre. Le commentaire, tu le mets en _comment.

J'ai trouvé, j'avais mal écrit SelectCursor.
Je suis vraiment nul non?

Je pense que c'est la fatigue qui fait ça.

Merci encore, là tu peut confirmer que je sui un nul!

C'est une erreur de ton code:

#define SelectCuror winapi__000C
                ^^--- faute de frappe

(post croisé)

Si vous pensez que je suis un Newbies alors vous avez résond!

Pour la prochaine fois: la meilleure méthode de trouver ce qui ne va pas dans ce genre de cas est de regarder le fichier .s. (Décoche "Delete assembly files after successful linking" dans les options de l'IDE.)

Je l'avais dèjà décoché et je regarde souvent ce qui a dans les fichiers s (assemebleur) mais là je n'y avais pas pensé, maintenant ça fonctione mais je voudrais savoir quels sont les limites du kernel et du nostub car je pense que faire des DLL n'est pas la meilleur solution?

C'est surtout que les DLLs _nostub ne sont pas prévues pour ce genre d'utilisation (cf. documentation). Elles ont été créées uniquement pour passer outre la limite des 64 KO (taille maximale d'un fichier).

Et d'ailleurs: est-ce que les programmes utiliseront toutes ces fonctions? Parce que s'ils n'en utiliseront que quelques-unes, alors une librairie statique pourraît être une bonne idée.

Les fonctions que j'ai diffusé ici sont le coeurs de Windows St (le curseur) est donc tout les programme utilisant un curseur (la plupart à mon avis) utliserons ses fonctions mais si Pphd arrive à lire des fonctions en mémoire flash alors je ne voit pas ou est le problème de taille. En effet le coeur du système ne fera pas plus de 50 ko est je pense mettre plus de 200 fonctions dans des librarie ainsi facilitant la création d'application Windows et même le développement de Windows ST car je ne voit pas pourquoi créer un OS avec des fonctions et ne pas les diffuser, cela me paraît abusurde mais ne t'inquiète pas je mélange les 2 type de librarie en trouvant un juste milieu entre la mémoire et la vitesse.

C'est + des problèmes de conception que autres choses.

Je dis ça parce que si il faut désarchiver à chaque fois 50 ko + 100 pour Windows ST il n'ya plus de mémoire RAM et je trouve dommage que l'on ne puisse pas executer du code dans la mémoire flash car on pourrai gagner énormement de place, je sais que j'en demande de trop.

Je dis que ca sera possible dans PedroM. Mais pas dans la v1.00. Surement dans la v1.20.

Mais je patienterais, ne t'inquiète pas en attend je ferais ça en librarie Kernel mais pour l'instant il y a encore beaucoup de travail sur Windows St donc ce n'est pas très urgent.