Forum TI-Planet.org

Je viens de débuter dans le C-ez80 (j'entends par là utiliser le langage c qui sera compilé avec la toolchain de CE-programming et non le compilateur GCC).

J'ai rencontré quelques difficultés d'adaptation. Voilà je souhaite réaliser un programme très simple : l'utilisateur entre une chaîne de caractère avec des chiffres et un caractère, de plus on demande bien à l'utilisateur de ne rentrer qu'un seul caractère et la machine doit retourner la chaîne avant le caractère saisi. Par exemple si l'utilisateur entre "123x" la machine doit répondre par "123" (non une variable mais bien une chaîne de caractères).

Faire le programme en basic et C-GCC est très simple. Mais en C-ez80, je n'y arrive pas (cela fait deux jours que je cherche).

Je precise que j'utilise la fonction void os_GetStringInput(char *string, char *buf, size_t bufsize); contenu dans tice.h (l.678 environ) .

J'ai remarqué que je dois déclarer mes variables avant cette fonction. Ce qui extrêmement handicapant car je crée mes variable juste après pour travailler avec.

Autrement dit si je ne déclare pas mes variables avant la fonction qui demande à utilisateur de rentrer une chaîne, le compilateur CE-programming me renvoie une flopée d'erreurs de type 100 je crois.
Ma question, comment faire ?
J'ai pensé aux pointeurs mais c'est peine perdue (à moins que je ne les ai mal utilisés).

Autre question : est-ce-que vous connaîtriez d'autre fonction de type input ?
Enfin pourquoi déclarer les variables avant de demander un input, ces variables sont donc initialisées à 0 et leur valeur ne sera pas modifié après la fonction, d'où leur inutilité ?

je pense surtout que je m'y prends mal. Je remercie par avance tous celles et ceux qui peuvent me répondre.
Bonne journée à tous.

Tiens moi aussi j'ai le même problème je voulais essayer de faire un programme C-ez80 pour le tester sur une TI-84+CE virtuelle (CEmu), mais j'ai un double problème car mon IDE de langage C (Code::Blocks) avec compilateur GCC ne reconnait pas <tice.h>. Désolé je ne peux pas te résoudre ton problème

pour ce qui est de ce type de problème, vous pouvez simplement faire un copier coller du header à l'adresse suivante :
http://ce-programming.github.io/toolcha ... ource.html et puis cela devrait marcher sans problème.

Merci isquelcrax en fait mon IDE n'est pas très récent et il manquait certains headers .h

Salut,

Je dois répondre rapidement pour le moment, mais n’hésite pas a continuer la discussion sur le topic, je serai davantage disponible pour répondre plus tard

Par rapport au fait d'avoir a déclarer toutes ses variables au début de son "scope" (les bornes d'utilisation de la variables, en gros, donc par exemple, au début d'une fonction, d'une boucle, etc.), ce n'est en fait pas spécifique au C eZ80. C'est une des regles du "C89"/"C ANSI", qui est vieux, certes (règles abolies depuis), mais malheureusement la version du C qui est uniquement disponible pour le moment via le compilateur ZDS pour la toolchain eZ80.
Donc en gros, t'auras pas vraiment le choix, désolé Mais ce n'est pas bien grave ni foncièrement mauvais - un tas de code font précisément ca, et ca oblige a respecter une certaine rigueur, plutôt que de déclarer des trucs en plein milieu d'autres, sans plus rien pouvoir y comprendre.

Par rapport a os_GetStringInput, mais en general aussi, je te conseille de tout simplement consulter les exemples de la toolchain.
Ici en l’occurrence, pour cette fonction : https://github.com/CE-Programming/toolc ... src/main.c

En ce qui concerne a l'usage d'un IDE, c'est tout a fait possible, il suffit de correctement le configurer pour lancer le makefile de la toolchain, et lui renseigner le bon chemin pour les includes.
Alternativement, vous pouvez aussi utiliser l'IDE en ligne "Project Builder" . Mais attention, il ne contient justement pas la version avec le getStringInput, parce qu'il faut que je mette a jour la toolchain Mais sinon, tout est deja intégré, donc c'est plus simple pour débuter, par exemple.

D'accord, cela vient peut-être de C99 que j'arrive à déclarer des variables en plein milieu de mon code. Je ne connaissais pas les restrictions du C89. Concernant l'exemple que tu me donnes, je l'ai déjà utilisé et je me base sur os-input et sur fileio-detect (déclaration des variables notamment ). J'ai l'habitude de coder avec SublimeText 2 et d' utiliser l'invite de commande en me basant sur les informations fournies par le dossier template. Je sais aussi utiliser Code::Block mais je ne l'ai pas configuré. Si quelqu'un pourrait me montrer son code source C-ez80 pour mon problème, ce serait parfait.

Oui, il est possible en C99 de déclarer ses variables n'importe où, contrairement au C89.

SublimeText + ligne de commandes, c'est pas mal Sans aller utiliser un IDE a proprement parler, tu aurais aussi Visual Code, qui comprend un peu mieux le langage C.

Et sinon, je ne suis pas sûr de comprendre ton problème exactement. Est-ce que l'exemple de la toolchain compile/fonctionne pour toi ? Si oui, et si tu as toujours des erreurs dans ton propre code, meme apres l'avoir modifié pour correctement déclarer les variables, c'est qu'il doit te manquer quelques trucs à faire encore...
N'hésite pas à copier/coller ici le code source et les erreurs qui apparaissent.

Fournir le code source, il est complètement incomplet mais bon le voici :

Code: Select all

/* Keep these headers */
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <tice.h>

/* Standard headers (recommended) */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fileioc.h>
#include <debug.h>
/* Put your function prototypes here */
void printText(const char *text, uint8_t x, uint8_t y);
void printTextSmall(const char *text, uint8_t xpos, uint8_t ypos);
int nb_occ(char* str,char car);
/* Put all your globals here */
/*typedef signed char     int8_t;typedef unsigned char   uint8_t;
typedef signed short    int16_t;typedef unsigned short  uint16_t;
typedef signed int      int24_t;typedef unsigned int    uint24_t;
typedef signed long     int32_t;typedef unsigned long   uint32_t;
typedef int24_t         intptr_t;typedef uint24_t        uintptr_t;*/


void main(void) {
    /* Fill in the body of the main function here */
   signed char string[30];
   signed char prompt[30];
    /*séparation des caractères de la chaîne en différentes variables char en utilisant la méthode des pointeurs, fonctioone avec
    printf("%c",*ptX) avec 0 ≤X ≤ 30 et X appartenant à IN*/
    uint8_t *pt0 = string;int8_t a = *pt0;uint8_t *pt1 = &string[1];int8_t b = *pt1;
    uint8_t *pt2 = &string[2];int8_t c = *pt2;uint8_t *pt3 = &string[3];int8_t d = *pt3;
    uint8_t *pt4 = &string[4];int8_t e = *pt4;uint8_t *pt5 = &string[5];int8_t f = *pt5;
    uint8_t *pt6 = &string[6];int8_t g = *pt6;uint8_t *pt7 = &string[7];int8_t h = *pt7;
    uint8_t *pt8 = &string[8];int8_t i = *pt8;uint8_t *pt9 = &string[9];int8_t j = *pt9;
    uint8_t *pt10 = &string[10];int8_t k = *pt10;uint8_t *pt11 = &string[11];int8_t l = *pt11;
    uint8_t *pt12 = &string[12];int8_t m = *pt12;uint8_t *pt13 = &string[13];int8_t n = *pt13;
    uint8_t *pt14 = &string[14];int8_t o = *pt14;uint8_t *pt15 = &string[15];int8_t p = *pt15;
    uint8_t *pt16 = &string[16];int8_t q = *pt16;uint8_t *pt17 = &string[17];int8_t r = *pt17;
    uint8_t *pt18 = &string[18];int8_t s = *pt18;uint8_t *pt19 = &string[19];int8_t t = *pt19;
    uint8_t *pt20 = &string[20];int8_t u = *pt20;uint8_t *pt21 = &string[21];int8_t v = *pt21;
    uint8_t *pt22 = &string[22];int8_t w = *pt22;uint8_t *pt23 = &string[23];int8_t x = *pt23;
    uint8_t *pt24 = &string[24];int8_t y = *pt24;uint8_t *pt25 = &string[25];int8_t z = *pt25;
    uint8_t *pt26 = &string[26];int8_t A = *pt26;uint8_t *pt27 = &string[27];int8_t B = *pt27;
    uint8_t *pt28 = &string[28];int8_t C = *pt28;uint8_t *pt29 = &string[29];int8_t D = *pt29;
    uint8_t *pt30 = &string[30];int8_t E = *pt30;
   

    //char *token = strtok (string, "x");
    //while (token != NULL);
    //{
       // printf ("%s\n", token);
        //token = strtok (NULL, "x");
   //}
       //signed int NbVariable = nb_occ(string, "X"); //count the number of the function variable X (main string)
       
    os_ClrHome();
    //int Nbplus = nb_occ(string, '+');// count the number of + (main string)
    //int8_t Nbminus = nb_occ(string, '-');// count the number of - (main string)
    os_GetStringInput("Enter a string:  ", string, sizeof string);
    os_ClrHome();
   print(pt1,0,0);
   while (!os_GetCSC());
}

/* Put other functions here */
void printText(const char* text, uint8_t xpos, uint8_t ypos)
{
    os_SetCursorPos(ypos, xpos);
    os_PutStrFull(text);
}
void print(char *text, uint8_t xpos, uint8_t ypos) {
    os_SetCursorPos(ypos, xpos);
    os_PutStrFull(text);
}
int nb_occ(char* str,char car) {
    signed int i,nbocc = 0;
    signed int size = strlen(str);

    for (i = 0 ; i < size ; i++)
    {
        if (str[i] == car)
            nbocc ++;
    }
    return nbocc;
}

Normalement il compile sans difficultés.
maintenant des explications :
1) le code source est un bordel, je sais mais je vais expliquer pour qu vous puissiez m'aidez rapidement

le gros pavé : ce sont des pointeurs, il me permettent d'afficher la chaîne saisi avec plus ou moins : par ex dans le code, si l'utilisateur saisi 2x la machine réponds par x, s'il saisi 32x+9 la machine affiche 2x+9 et ainsi de suite.
Mon problème je vais l'expliquer par plusieurs exemples :
si l'utilisateur saisi 2x+9 la machine doit afficher 2
si l'utilisateur saisi 2a+89 la machine doit afficher 2
si l'utilisateur saisi x+5, la machine affiche 1 car 1x+9 = x+9
si l'ulisateur saisi 3456x²+90x+6 la machine doit afficher 3456
si l'utilisateur saisi 12c la machine doit afficher 12
Je pense que vous avez compris

certaines lignes de codes présentes ne servent à rien à cause du C89 par la exemple la fonction nb_occ calculait le nombre d’occurrences du caractères qu'on lui donne par exemple
si l'utilisateur tape 23x+9x²+4 la variable Nbplus vaut 2 car il y a deux plus et NBminus vaut 0 car il n'y a pas de moins et NbVariable vaut 2 car il y a deux fois le symbole x. Cette fonction m'aurait été utile pour plus tard

ensuite on peut voir la fonction strtok en en commentaire c'est normal car elle ne peut pas travailler à cause du C89 (maudit sois-tu)
elle m'aurait de découper la fonction en différente chaîne selon le nombre de signe plus ou moins(cela n'est pas dans le code fourni)

le typedef vous donne une sorte de tableau de conversion.

Ensuite pour mon problème, je ne vois pas comment utiliser les pointeurs( pourtant cela a parfaitement marcher dans le pavé). Et malheureusement ils sont la clé de voûte du programme .

Le programme n'est pas du tout au point mais au moins j'ai une piste. Pour les plus chevronné(e)s, comment faire ?

Hmm, effectivement, le gros pavé, c'est pas bien beau, et à vrai dire je n'en vois pas l'utilité. On peut faire autrement pour accéder à n'importe quelle partie, puisque "string" est un tableau de char - en effet, les chaînes de caractères sont juste une suite de caractères, en C (et un '\0' à la fin).

Par ailleurs, strtok fonctionne, je ne vois pas pourquoi ça ne serait pas le cas ici
Au pire, déclare toutes tes variables avant.
Donc char *token, uint8_t nb_plus etc. Ensuite, au moment voulu, tu leur assignes leur valeur.

Par ailleurs, utilise davantage des unsigned (uint8_t/16_t/24_t) et une taille plus correct, ça ira plus vite.
Pas besoin de typedef, c'est déjà tout fourni dans stdint.h https://github.com/CE-Programming/toolc ... d/stdint.h

Ensuite, pour le programme en lui-même, il semble que tu veuilles faire un parseur d'expression mathématique... Peut-être peux-tu regarder un code déjà existant pour essayer de voir comment il est formé ? J'ai porté un moteur de calcul de dérivée ici : https://tiplanet.org/pb/?id=1381_146138 ... le=parse.c Ca pourrait t'intéresser.
Celui-ci, aussi, est une alternative https://github.com/nathanfarlow/SymbolicDerivative/ (regarde le fichier src/parser.c)

Je regarderai plus en détail le reste plus tard.

Je te remercie pour ta réponse. C'est vrai que je cherche à coder un analyseur syntaxique (autrement dit un parseur). Je me suis lancé le défi de le faire en C-eZ80 pour le fun. Visiblement c'est pas ce que j'attendais. J'ai consultée le fichier parsec et il est très bien fait. Maintenant étant donnée que je dois programmer en C89 ce qui change du C99, J'ai pensé à une autre alternative plus simple : utiliser Y1 comme Nathan l'a fait, de ce fait il n'y a plus d'input. Si jamais je rencontre des difficultés, je posterais un nouveau message.

PS; est-ce-que vous connaîtriez (je m'adresse à tout le monde) des tutos pour le C89 uniquement car moi j'appris à coder en C99 ? une dernière question : peut-on faire la même chose en asm ez80 ? je pose la question car je suis en train d'apprendre ce langage, j'en suis qu'aux registres et il me semble très prometteur.