Mem Zone

Lib et Doc rédigé par 2072

Télechargement

Rôle de cette Lib

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:

  • Vous pouvez créer des fichiers dans ces zones mémoire
  • Vous pouvez changer la dimension d’un fichier existant dans une zone mémoire.
  • Effacez un fichier d’une zone mémoire.
  • Vous pouvez lire et écrire des données dans un fichier en zone mémoire.
  • effacer un fichier d’zone mémoire .

Quels sont les dossiers dans l'archive? Comment est-ce que je les utilise?

  • memzones.c est le dossier qui contient toutes les fonctions de la bibliothèque, vous devez l’ajouter à votre makefile (ou " Projet “).
  • memzones.h est le dossier d’en tête de memzones.c que VOUS AVEZ À " #INCLUDE " dans vos dossiers .c qui utilisent les fonctions de memzones.c
  • DEF.h est un dossier d’en tête de définition utilisé par la lib.

Quelle sont ces zone de la mémoire?

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.

Zone 0

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.

Zone 1

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.

Zone 3

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)

Zone 4 à Zone 11

  • 4: CHAR
  • 5: LIST
  • 6: MATRICE
  • 7: GÉNÉRAL
  • 8: TRAVAIL
  • 9: LOCAL
  • 10: DT 8
  • 11: DT 9

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 12

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.

Zone 13 à Zone 15

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.

Zone 16

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.

Description des fonctions

  • 1) long search_mem_zone (int zone_id, unsigned char *zone_name, struct memory_zone *bf);
  • 2) unsigned int write_mem_zone (struct memory_zone *bf, const void *src, int offset, unsigned length);
  • 3) unsigned read_mem_zone (struct memory_zone *bf, void *dest, unsigned offset, unsigned length);
  • 4) int change_password (struct memory_zone *bf, unsigned char *password);
  • 5) void clear_mem_zone (const struct memory_zone *bf);
  • 6) int create_mem_zone(unsigned char zone_id, char *zonename, unsigned int size, int flag);
  • 7) unsigned long afxleft (void);
  • 8) char far *tell_mem_zone_seg( unsigned char id );
  • 9) void huge_movedata(unsigned int src_seg, unsigned int src_off, unsigned int des_seg, unsigned int des_off, unsigned long num);

search_mem_zone

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.

write_mem_zone

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.

read_mem_zone

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.

change_password

Changement du mot de passe d’un fichier BASIC contenu en zone 1 L’ancien mot de passe sera remplacé par le nouveau.

clear_mem_zone

Cette fonction remplis un fichier par des NULL. Note que cette fonction est très rapide.

create_mem_zone

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.

  • zone_id est l’identificateur de la zone.
  • zonename est le nom de la zone (8 char seulement).

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 :

  • Si le flag est mis à CREATE_ZONE alors si la zone de la mémoire existe déjà il en rend -1.
  • Si le flag est mis à RESIZE_ZONE alors si le fichier existe déjà il est redimensionné le nom du fichier n’est pas modifié.
  • Si le flag est mis à DELETE_ZONE alors le fichier existe déjà il est effacez. La dimension de la mémoire peut étre 0.

Les valeurs du retour:

  • 0 si OK.
  • -1 si erreur (une dimension absurde, aucun nom, id impossible...).
  • -2 si pas assez de mémoire pour créer le fichier ou si la fonction ne peut pas allouer la mémoire.

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 :

  • 40 multiplets si c’est un type 1 zone
  • 30 multiplets pour tout autre type

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

afxleft

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).

tell_mem_zone_seg

FONCTION UTILISE PAR LA LIB, NE PAS TOUCHER

Fonctions supplémentaires de la version 2.00b

Fonctions non testé.

  • MEMZ *mopen (const char ztype, const unsigned char *zonename, const char *mode);
  • size_t mwrite (const void *ptr, size_t element_size, size_t n, MEMZ *stream);
  • size_t mread (void *ptr, size_t element_size, size_t n, MEMZ *stream);
  • int mclose (MEMZ *stream);
  • int mseek (MEMZ *stream, unsigned offset, int whence);
  • unsigned int simple_mseek(MEMZ *a, unsigned int b); – this is a macro
  • unsigned int mrewind(MEMZ *a); – this is a macro
  • int munlink(MEMZ *a, MEMZ *b); – this is a macro
  • int mtruncate (MEMZ *stream, size_t newsize);

MZLIST

Lib implémenté par Superna

Télechargement

Pourquoi cette Lib

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.

Description des fonctions

b_findfirst

int b_findfirst(struct memory_zone * file,unsigned short type);

param d’entré :

  • unsigned short type → zone dans la quelle la recherche est effectuée (1 à 12)

param de sortie :

  • int → 1 : Signifie qu’il y a un fichier disponible ; -2 : Signifie qu’il y a un fichier disponible sur la zone suivante ; -1 : signifie qu’il n’y a plus de fichiers aprés ;
  • struct memory_zone * file → informations sur le fichier détecté

ex :

//Lancement de l'exploration
val=b_findfirst(&bf,1);

b_findnext

int b_findnext(struct memory_zone * file);

param d’entrée :

  • unsigned short type → zone dans la quelle la recherche est effectuée (1 à 12)

param de sortie :

  • int → 1 : Signifie qu’il y a un fichier disponible ; -2 : Signifie qu’il y a un fichier disponible sur la zone suivante ; -1 : signifie qu’il n’y a plus de fichiers aprés
  • struct memory_zone * file → informations sur le fichier détecté

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

Un exemple

#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();
              }
       }
}
 
lib_gestram.txt · Dernière modification: 2007/12/17 12:03 par 193.249.190.29
 
Recent changes RSS feed Creative Commons License Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki