Lib et Doc rédigé par 2072
Cette bibliothèque vous permet d’utiliser la RAM de la G100. Cette mémoire est divisée en « zones mémoires » (ficfiers BASIC, Mat, List...) .
Possibilités offertes par cette Lib:
La G100 utilise les zone mémoire pour ctocker des données d’utilisation ou de configuration.
Ca peut être un programme BASIC (souvent a appelé fichier BASIC), une variable, une liste, une matrice...
Il y a 16 types différents de zone mémoire, chaque type est utilisé pour entreposer un genre spécial de données.
Contiens les variables (ALPHA):
Ce type de zone est très spécial: depuis Son accés dois étre le plus rapide possible car les variables sont souvent utilisées dans les programmes BASIC.
La dimension de cette zone est variable (des allocation dynamique y sont effectuées). Il y a 29 variables différentes (A~Z, THETA, RHO et ANS). Chaque variable utilise 18 octets dans la zone 0.
Ces fichiers n’ont pas de nom donc vous ne pouvez pas les adresser avec search_mem_zone.
Pour écrire dans cette zone vous devez la remplir avec la bonne structuration en utilisant tell_mem_zone_seg comme suit :
var_A = tell_mem_zone_seg(0); //donne l’adresse de la 1er vars A par un pointeur far
Ainsi &var_A[18 * 1] donne l’adresse de la 2em vars B par un pointeur far
Les variables sont entreposées dans ordre alphabétique de A à Z, RHO, THETA, ANS.
Contiens les programmes BASIC : Un fichier de cette zone doit avoir une dimension > 24 autrement des bugs peuvent se produire lors de l’utilisation de cette zone.
Il s’agit d’une zone spéciale (SYSTÈME) :
Le fichier CLIP contien le presse papier de la G100. On écris dedans avec l’ASCII de la G100.
Le fichier FNAME contient le nom du dernier exécutable du menu principal utilisé. Il est utilisé par les applications de CASIO(TM)
Ces noms viennent du menu caché qui est accessible quand la G100 est fermé en appuyant sur la clef simultanément : [F1] [→] [AC/ON] alors [1] une fois le menu est affiché.
Zone de configuration pour les programmes Flash :
Là vous trouverez tout données créé par un programme CASIO ajouté.
L’utilisation de cette zone est très adaptée pour y placer des fichierr relatif ou fonctionnement de vos applications.
Ces zones sont utilisé par des applications de la G100 :
Il est possible de voir le contenu ces zones mémoire en utilisant TOUCHE 4.0.
Pas d’autres informations.
Contiens un fichier ALC (RÉGION ALLOC ) :
Elle se situe entre les adresses $1BF7:$0003 et $1BF7 :$0005.
Il n’est pas possible d’accéder a cette zone mémoire avec cette lib.
Pas d’autres informations.
Cette fonction doit être utilisée avant en des fonctions 2 à 5, elle initialise la structure bf. Elle retournera la dimension du fichier si succès ou -1 si une erreur s’était passée. Une structure du memory_zone est:
struct memory_zone
{ int b_ztype; // indicates the zone id
unsigned int b_offset; //
unsigned int b_segment;//point on the size of the zone (3 bytes before the name).
unsigned int b_inner_offset; //point on the offset where it can start to write/read data.
unsigned int b_size; //total zone size.
unsigned int b_real_size;//the real size available for data (used to prevent overflow).
unsigned char b_name[10]; //name of the zone.
unsigned char b_password[10];//password (for basic program zone only).
};
exemple :
int main (void)
{ struct memory_zone bf;
if (search_mem_zone(1, "TEST", &bf) != -1)
printf("TEST found! The size is %u", bf.b_size);
else
printf("TEST not found!");
exit(0);
}
Important :
Lorsque vous modifiez le contenu d’une zone mémoire l’adresse du fichier modifié change. Donc utilisez, dans ce cas, search_mem_zone () d’appeler toute fonction qui utilise la structure bf.
Si vous utilisez plusieurs fichiers en même temps cette remarque est aussi valable.
Cette fonction vous permet d’écrire dans un fichier pointé par la structure bf.
Les données qui peuvent y être écrites peuvent être de n’importe quel type (int, char, float, une structure, typdef…)
Exemple :
ecriture de la valeur 16 a l’offset 2
int i = 16; write_mem_zone(&bf, &i, 2, sizeof(f1));
Si l’offset est supperieur à la taille du fichier, la donnée est écrite à l’adresse la plus haute du fichier afin de proteger les autres fichiers.
Cette fonction lis des données contenues dans un fichier pointé par la structure bf.
Les données qui peuvent y être lues peuvent être de n’importe quel type (int, char, float, une structure, typdef…)
Exemple :
unsigned int file_begining; read_mem_zone(&bf, &file_begining, 0, sizeof(unsigned int));
read_mem_zone et write_mem_zone retournent le nombre d’octets transité.
write_mem_zone(&bf, &f1, 2, sizeof(f1));
L’exemple au-dessus d’écrivez la structure " f1 " entière dans le dossier décrit par bf à l’offset 2.
Changement du mot de passe d’un fichier BASIC contenu en zone 1 L’ancien mot de passe sera remplacé par le nouveau.
Cette fonction remplis un fichier par des NULL. Note que cette fonction est très rapide.
Cette fonction vous permet de créer un fichier dans une zone mémoire (Zones 2 à 12 uniquement). Chaque zone est dénotée avec un identificateur du type de $0 à $F et son nom qui suivent l’identificateur. Par exemple les fichiers BASIC sont dénotées par $1.
Ces fichiers sont classé selon la dimension du fichier dans la RAM (toute zone de la mémoire doit avoir une dimension >14 multiplets). le flag prends les valeurs CREATE_ZONE, RESIZE_ZONE ou DELETE_ZONE :
Les valeurs du retour:
Rem :
Si vous entreprenez de créer un fichier de dimension $FFFF les 16 derniers octets ne seront pas utilisé mais la fonction ne retournera pas d’erreurs.
Souvenez-vous que si vous voulez un fichier avec 16 octets disponible vous devrez créer un fichier de :
Exemple :
#include <dos.h>
#include <conio.h>
#include <bios.h>
#include <stdlib.h>
#include <stdio.h>
#include "memzones.h"
int main (void)
{struct memory_zone bf;
char text[16];
if (create_mem_zone(1,"TEST", 230, RESIZE_ZONE) != -2)
{if (search_mem_zone(1, (unsigned char *)"TEST", &bf) != -1)
{printf("TEST found! The size is %un", bf.b_size);
write_mem_zone(&bf, "Hello world!", 0, 14);
read_mem_zone(&bf, text, 0, 14);
printf("%s", text);
}
else printf("TEST not found!n");
//this line is useless since it cannot happen!?!
}
else printf("Not enough memory!n");
bioskey(0);
return 0;
}
Cette fonction rend la mémoire disponible pour les données de la G100 (la même valeur que vous pouvez voir dans le menu du système).
FONCTION UTILISE PAR LA LIB, NE PAS TOUCHER
Fonctions non testé.
Lib implémenté par Superna
Cette librairie permet de lister les fichiers contenus dans les mem_zones. Elle peut par exemple servir pour créer un exploreur de fichiers contenu en mem_zone.
Cette lib nécessite l’inclusion de la lib memzone de 2072.
int b_findfirst(struct memory_zone * file,unsigned short type);
param d’entré :
param de sortie :
ex :
//Lancement de l'exploration val=b_findfirst(&bf,1);
int b_findnext(struct memory_zone * file);
param d’entrée :
param de sortie :
remarque :
pour utiliser cette fonction il faut appeler “b_findfirst” au moins une fois avant
ex :
val=b_findfirst(&bf,1);
while(val==1)
{printf("File name : %sn",bf.b_name);
printf("File Size : %in",bf.b_size);
val=b_findnext(&bf);
}
#include <stdio.h> #include <conio.h> #include "memzones.h" #include "mzlist.h"
void main(void)
{struct memory_zone bf;
int nb_file=0;
int val;
int cur_zone=1;
val=b_findfirst(&bf,1); //Lancement de l'exploration
while(val!=-1)
{while(val==1)
{printf("Zone Courante : %i",cur_zone);
printf("Fichier n%i :n",nb_file);
printf("Filename : %sn",bf.b_name);
printf("File Size : %in",bf.b_size);
getch();
val=b_findnext(&bf);
nb_file++;
}
if(val==-2)
{cur_zone=bf.b_ztype; //On saute de zone
printf("Zone Courante : %i",cur_zone);
getch();
}
}
}