Index des articles > Programmation > Tutorial TIGCC - Chapitre 1 - Débuter avec TIGCC

Tutorial TIGCC - Chapitre 1 - Débuter avec TIGCC

Article posté par limmt

Chapitre 1 - Débuter avec TIGCC

A - Intro

Ce tutorial vous permettra d'apprendre les bases nécessaire à la programmation en C avec TIGCC sur vos TIs68k. Pour ce tutorial nous utiliserons la version 0.95 de TIGCC

I) Introduction au langage C

Dans le langage C, chaque fin de commande doit OBLIGATOIREMENT se terminer par ";". Ce caractère permet au compilateur de reconnaitre une fin de commande, si vous ne le mettez pas, vous obtiendrez une parse error qui entraînera d'autres erreurs. Prenons un exemple simple:
short a=0;
Ce code permet de créer la variable "a", en type short (entier court, codé sur 2 octets). On doit mettre le ";" à la fin. On pourrait également écrire:
short
a
=
0

;

qui serait reconnu exactement pareil par le compilateur. Les mots clefs et les noms de fonction et de varaibles doivent cependant rester en un mot sans espaces. On écrira généralement la première forme, qui est plus lisible.
Pour une meilleure lisibilité, les mots clefs du langage C sont marqués comme ca, une commande ou un argument comme ca et les commentaires comme ca, TIGCC le fait également.
! Il est imporant de bien commenter vos programmes, surtout si vous débutez en C, vous vous y perdrez dans des centaines de lignes de code avec des projets plus gros.
Pour inclure un commentaire jusqu'à la fin de la ligne il faut mettre:
//Votre commentaire
Vous pouvez également faire un bloc de commentaire, avec:
/*Commentaire:
Tout ce qui sera entre les deux balises ne sera pas compilé par TIGCC*/


II) Variables

a) Déclaration:
Un variable est une donnée crée par le programme. En C, elle est supprimée à la fin de l'exécution du programme. En C, contrairement au TI-basic, on doit déclarer les variables.
Une déclaration de variable prend généralement la forme:
type nom_var[=valeur];
Le type de variable décide quels sera la taille en mémoire de la variable (2 octets, 4 octets...), nom_var est le nom de la varaible, il n'est pas limité à 8 caractères comme en TI-basic. Un nom de variable ne doit pas comporter d'espaces. La dernière partie est l'assignation d'une valeur. On peut assigner directement une valeur à une variable lors de la déclaration. Elle est facultative.
! Attention à la casse des variables, var, VAR et Var ne seront pas reconnues comme la même variable.
Il existe différents types de varaibles en C ; les plus courants sont:
short entier codé sur 2 octets (de -32768 à 32767)
unsigned short entier positif codé sur 2 octets (de 0 à 65635)
int type de variable standard, entier codé sur 2 octets (de -32768 à 32767)
unsigned int type de variable standard, entier positif codé sur 2 octets (de 0 à 65635)
long entier codé sur 4 octets (de -2147483648 à 2147483648)
unsigned long entier positif codé sur 4 octets (de 0 à 4294967296)
float nombre positif codé sur 4 octets (de 1e-999 à 9.999999999999999e999), avec TIGCC il équivaut à double et long double
char caractère, codé sur un octet (de -127 à 128)
unsigned char caractère, codé sur un octet (de 0 à 255)

b) Assignation d'une valeur:
Assigner une valeur à une variable en C est une chose très simple. Il suffit de faire:
variable=valeur;
Ceci est l'équivalent de:
valeur [STO>] variable
en TI-basic

c) Listes de varaible à une ou deux dimensions:
En basic, vous avez surement utilisé des listes. On peut faire la même chose avec TIGCC.
Il est également possible de faire des matrices (liste à deux dimensions).

Syntaxe générale de la déclaration d'une liste à une dimension:

type variable[elements][={valeur1, valeur2...}];

On met entre crochets le nombre d'éléments à mettre et dans l'assignation on met entre accolades les valeurs.

Syntaxe générale de la déclaration d'une liste à des dimension:

type variable[elements1][elements2][={{valeur1_1, valeur1_2...},{valeur2_1, valeur2_2...}...}];

On met deux fois un nombre d'éléments puis entre accolades des listes également entre accolades des éléments.

Exemple:

short varlist[2][3] = {
{1,2,3},
{12,24,2}
};


Ce code déclare une liste de 2x3 shorts.
Il est également possible de laisser la (si liste à une dimension) ou une des deux (si liste à deux dimensions) déclarations du nombres d'éléments vide, elle sera alors remplie en fonction de ce que vous mettez après.
Par exemple j'aurais pu aussi bien écrire:

short varlist[][3] = {
{1,2,3},
{12,24,2}
};


Qui aurait été tout à fait correct.

Pour assigner une valeur à un élément d'une liste vous faites:

varlist[1][0]=45;
liste_une_dimension[4]=12;

! Le premier élément d'une liste est 0 et non pas 1 et le dernier est (nombre d'éléments-1).
Il faut faire attention à ne pas assigner une valeur en dehors d'une liste car cela compilera sans problème mais entrainera un plantage à plus ou moins long terme si vous écrivez dans des données systèmes.

III) Fonctions

Pour executer une fonction, il faut faire:
nom_fonction([argument(s)]);
Le prototype de la fonction vous permet de savoir s'il faut le passer des arguments et leur type. Une fonction peut retourner une valeur, pour l'enregsitrer il faut faire:
var=nom_fonction([argument(s)]);
en ayant au préalable déclaré var. Les fonctions que nous utiliserons pour l'intant proviennent de la TIGCCLIB, leur prototype peut être trouvé dans la doc de TIGCC.


B - Votre premier programme en C

I) Corps du programme

Je vais vous présenter le corps du programme sans explications, j'y reviendrai plus tard, ce programme sera utilisable pour les TI89 et les TIs92+/V200. Vous pouvez déjà le compiler et l'exécuter pour essayer d'abord de comprendre par vous même.

#include

void _main(void)
{
clrscr();
printf("Hello world!");
ngetchx();
}

! Remarquez l'indentation du programme.

II) Expliquations

Je vais reprendre le programme ligne par ligne pour que vous compreniez bien.
#include permet d'inclure dans le programme le fichier header tigcclib.h, ce fichier contient toutes les fonctions de la TIGCCLIB. Vous devez toujours l'inclure si vous voulez pouvoir utilisez les fonctions incluses.
void _main(void) cette ligne permet de déclarer la fonction _main comme ne renvoyant rien (void) et ne pernant aucun argument (void). Quand vous créerez un programme la fonction principale sera toujours _main, c'est elle qui sera lancée à l'exécution du programme.
{ permet de déclarer un début de bloc d'instructions, vous aurez souvent des bloc car toutes les structures conditionnelles les utilisent. Une fonction est toujours composée d'un bloc d'instructions, qui peuvent elles-mêmes faire appel à d'autres fonctions. On remarque que lorsqu'on crée un bloc d'instruction avec TIGCC il referme automatiquement les crochets et indente ce qu'il y a à l'intérieur.
clrscr(); clrscr est une fonction qui ne prend pas d'arguments et qui ne renvoie rien. Elle efface l'écran.
! Attention à la casse (ClrScr(); n'aura pas le même effet, essayez de compiler avec cette deuxième fonction, executez plusieurs fois et observez.).
printf("Hello world!"); cette fonction permet d'afficher du texte à l'écran, pour l'instant nous l'utiliserons comme une fonction prenant une chaine de caractères en argument et ne renvoiyant rien.
ngetchx(); cette fonction permet d'attendre que l'utilisateur appuie sur une touche et renvoie le code de la touche correspondante, ici nous n'en avons pas besoin, elle correspond à peu près à la fonction TI-basic getkey()
} ferme de bloc d'instructions ouvert plus haut, la fin de la fonction _main fait automatiquement quitter le programme.

! Dans la version 0.95 de TIGCC certaines choses sont déclarées implicitement:
#define USE_TI89
#define USE_TI92PLUS
#define USE_V200
Ces trois déclarations permettent de choisir pour quelle(s) TI(s) le programme sera compilé. Lers trois sont inclues par défaut. Cependant il se peut que vous ne vouliez faire un programme pour qu'une seule des TIs. Dans ce cas vous devrez enlever la définition de la création avec: #undef USE_TI89
par exemple pour enlever la compilation pour TI89.

#define SAVE_SCREEN
Permet de créer un programme restaurant l'écran automatiquement à la fin. Si vous ne voulez pas que ca le fassse, utilisez: #undef SAVE_SCREEN


C - Les fonctions les plus élémentaires en détail

I) Les fonctions du préprocesseur

Le préprocesseur est un macro-processeur. Ses commandes doivent se placer avant la fonction _main et pas dans une fonction. Je vais juste vous expliquer le fonctionnement de ses commandes les plus simples ici.
Ses commandes commencent toujours par #.

#define permet de définir quelque chose. On peut définir une commande pour le programme: #define USE_KERNEL, par exemple pour faire un programme en mode kernel. On peut également définir une macro. Par exemple si on met au début du programme:
#define print(arg) {clrscr(); printf(arg);}
Lorsqu'on écrira print("Texte"); tout se passera comme si l'on avait écrit clrscr(); printf("Texte");.

#include permet d'inclure un fichier header dans un programme. #include >tigcclib.h< inclut les headers de la TIGCCLIB, si on veut inclure un autre header dans le programme qui fait partie du projet, on met: #include "nomheader.h". Un header est un fichier contenant des fonctions (extension .h). On s'en sert pour simplifier la présentation du programme principal (.c)

Il existe d'autres commandes du préprocesseur que nous verrons plus tard.

II) Quelques fonctions de base de la TIGCCLIB

void clrscr (void);
Efface l'écran et retaure la position d'affichage pour les commande d'affichage à 0,0. Ne prend pas d'arguments et ne renvoie rien.

void DrawStr (short x, short y, char * str, short attr);
Affiche la chaîne de caractères str à x,y en mode attr.
Les modes d'affichage seront les mêmes pour pratiquement toutes les fonctions d'affichage, je vais donc vous récapituler les plus courants:
A_NORMALmode normal (mode OR)
A_REVERSEmode inversé
A_XORmode XOR, affiche si un des deux pixels (destination ou commande) est affiché si les deux le sont ou aucun, laisse effacé
A_REPLACEaffiche les pixels de destination en écrasant la source (équivaut à peu près à RplcPic de TI-basic).
Vous avez vu que pour la chaîne de caractère, j'ai rajouté une * derrière char, celà correspond à une définition de pointeur, j'y reviendrai plus tard, pour l'instant nous considérerons cela comme une chaîne de caractères que nous définirons comme ceci:
char * nomchaine="chaine de caractères";
Vous pouvez également la modifier comme une autre variable.


Limmt Ribeman © 2004

>> Vos commentaires [0]

Pas de commentaires

Poster un commentaire


Seuls les membres peuvent poster des commentaires