Un fichier FOS, qu'est-ce que c'est ?

[Amarok]

Après avoir vu le B.A. BA du code, voyons un peu où il se cache et comment il s'utilise...



Un fichier .FOS n'est au fond qu'un vulgaire fichier texte,
mais écrit dans un language que le compilateur saura transformer en Petit Miracle.
C'est pourquoi il doit respecter certaines règles et un vocabulaire spécifique.
S'interroger sur la construction d'un fichier, c'est bien. Mais sans savoir à quoi il sert, c'est pas très productif !


---------------------
PRESENTATION
---------------------

Basiquement, un fichier n'est qu'un "bout de papier" contenant un ensemble de variables et fonctions.
C'est ici que nous trouverons leur forme, leur fonctionnement et leurs utilisations.

On pourrait très bien n'avoir qu'un seul et unique fichier qui contiendrait la totalité du code.
Si ça peut être pratique au début, avoir tout sous la main rapidement,
on imagine bien l'enfer que cela deviendrait à mesure que la page s'allongerait...
De plus le découpage en plusieurs fichiers permet de ne pas avoir à tout recompiler à chaque fois (on dirait pas comme ça mais... ça peut en prendre du temps!), de faciliter les updates et le travail en équipe, de regrouper le code par thème, par but, etc...
Bref, de ranger sa chambre quoi !!!


Considérons la partie SERVER de notre SDK comme un bon gros bloc-note.
Chaque fichier .FOS en est une page.
Et chaque page est autonome.

Une page blanche qui n'attend que votre imagination pour prendre vie...
Ca mettrait presque la larme à l'oeil, non ?
Bref, passons... Rangez vos mouchoirs, et place à la sueur !

...

Tout cela signifie qu'un fichier ne connait que ce qu'il contient lui-même. Si j'écris une fonction ou une variable sur ma page, les autres pages du bloc-note n'en ont pas connaissance. Je pourrais donc avoir des éléments (variables, fonctions) identiques (même nom, même type) dans différents fichiers sans qu'ils se marchent dessus, puisqu'ils ne sont pas aux mêmes endroits !

Pour décrire ce phénomène, on parle de la portée, ou encore du champ, d'un élément. Pas évident d'aborder ses notions avec les fichiers, ces grands inconnus !
Voyons donc cela au travers des fonctions que nous connaissons déjà un peu, car elles aussi sont soumises à ce même phénomène.


---------------------------------------------------------
LA MAISON DES NOS AMIES LES FONCTIONS
---------------------------------------------------------

Concrètement, la plupart de ces fichiers servent à définir les fonctions.
Ou plus simplement, dire qu'elles existent en décrivant leur forme (on parle de "déclaration")
et ce qu'elles font, leurs contenus (on parle alors de "définition") :

DECLARATION, "sa forme" :
- ce qu'elle donne (le résultat qu'elle renvoie)
- comment elle se nomme
- ce dont elle a besoin pour cela (ses paramètres)

DEFINITION, "son contenu" :
- comment elle les transforme en résultat (ou pas ^^)


Nous avons déjà vu quelques exemples au chapitre précédent. On aurait pu les écrire de la façon suivante :

DECLARATION
{
   DEFINITION
}

On voit bien que les "{...}" délimitent ce que l'on appelle "le corps de la fonction", dans le même sens qu' un "corps de texte".
C'est le fameux champ de la fonction ! Tout ce qui est à l'intérieur de ces bornes n'existent QUE pour cette fonction.
Si je créé (donc déclare) une variable ici, elle ne peut pas être utilisée ailleurs :

void MaisOuSuisJe()
{
   int que_dedans;
}
 
void SuisJeUnique()
{
   int que_dedans;
   // Et bien oui ! Chaque variable que_dedans est parfaitement indépendante,
   // car elles ne "se voyent" pas !
}

... à moins que ma fonction ne l'a renvoie comme résultat :

int MaisOuSuisJe()
{
   int que_dedans;
   int plus_maintenant;
 
   plus_maintenant = que_dedans;
 
   return plus_maintenant;
}

Il y a encore bien d'autres procédés pour "extraire" une variable (ou juste sa "valeur" comme dans notre exemple) d'une fonction. Nous les aborderons plutard dans un chapitre spéficique (parce qu'elles le valent bien !).


----------------------------
L'ETABLE A VARIABLE
----------------------------

Eh oui, elles aussi sont parquées ici et répondent à la même Loi !
Une variable déclarée en dehors de tout champ (=> "{}" & "()" ) est utilisable par l'ensemble du fichier.
On dit qu'elle a pour portée, le fichier.

Reprenons l'exemple précédent :

int plus_maintenant;
 
void MaisOuSuisJe()
{
   int que_dedans;
   
   // on utilise cette fois une variable hors de la portée de la fonction
   plus_maintenant = que_dedans;
}

Ici nous avons simplement déclarée notre variable. Nous aurions pu également l'initialiser, lui affecter une valeur à sa création :
int plus_maintenant = 123 ;

Pour certains types de variable, l'initialisation est obligatoire.


------------------------------
LIENS ENTRE FICHIERS
------------------------------

Bah oui, on a dit "bloc-note" pas "feuilles volantes" !
Des fichiers enfermés chacun dans leur petit champ, ça n'aurait pas grande utilité n'est-ce pas ?!

Nous avons 2 outils pour cela :
- INCLUDE
- IMPORT

#include "mon_fichier.fos"
Le INCLUDE effectue en fait tout simplement un copier/coller d'un fichier !
Il permet donc, du coup, d'avoir un accès total à son contenu => fonctions & variables donc.

import declaration_de_ma_fonction from "mon_fichier"
L' IMPORT lui autorise l'accès à l'une des fonctions contenue dans un fichier. Mais pour que ce dit "fichier" soit accessible, il faut qu'il ait été déclaré comme MODULE au préalable (dans le fichier script.cfg).
Aaaah... Les fameux modules !!!

Par exemple, pour pouvoir faire référence aux items par leur nom (ils sont déclarés dans le fichier _itempid.fos), il faut simplement que je rajoute " #include "_itempid.fos" " en tête de mon fichier. Pour tout ce qui touchera au temps, il faudra inclure le fichier time.fos, etc.

Indirectement, ces outils permettent du coup de retacer les liens entre les fichiers, leurs dépendances.
Si vous voulez savoir "où", "par qui" tel fichier est utilisé, cherchez donc dans les includes & imports !
(NotePad++ s'en chargera avec plaisir ;o)

[Amarok]

:smile5::smile5::smile5: Encore un gros morceau de passé ! :crazy: Il me semble ne rien avoir oublié. Je compléterai en fonction de vos questions.