Nouveau petit shell - Page 3

ls -p sur v200 n'affiche la liste des fichiers que sur un écran de la taille de celui de la 89, c'est pas chouette

Merde, C vrai, j'avait pas pensé a ca.
L'ecran est aussi grand que pour une ti92+ ??
Donne moi les dimensions.
G eliminé quelques bug et quand on appui sur hau et bas, on peut selectionner la commande que l'on veut

nan ça devrait faire back dans l'history plutôt ! Et par contre, [->] devrait être un auto-completor dossier/commandes ... bon, c'est peut-être trop demander, mais j'ai aucune idée de la complexité de la chose, et c'est comme ça que je l'aurais vu, mais après, tu fais comme tu veux !

en fait, G pas trop d'idée pour comment faire un history, C pour ca que G fait le coup de la touche haut, et bas

Ba pingoo est pas obligé de faire exactement pâreil qu'un shell standard Unix !

L'id de faire haut<->bas pour choisir une commandes est une bonne idée

Ecran de la 92+/v200 : 128*240

godzil a écrit :
Ba pingoo est pas obligé de faire exactement pâreil qu'un shell standard Unix !

L'id de faire haut<->bas pour choisir une commandes est une bonne idée

Ca y est, je l'ai implementé. Ma prochaine version v 0.11 sera en telechargement, des que j'aurai corrigé d'autre petits bugs

stpatrick
a écrit : Ecran de la 92+/v200 : 128*240

OK, merci

Pour l'historique, tu peux simplement utiliser une pile, non ?
Tu peux soit allouer pour chaque commande un bloc, soit allouer un gros bloc au début.
Il me semble qu'AMS utilise la première solution pour son historique.
La deuxième est pas terrible je trouve.
Mais le défaut de la première, c'est qu'on se retrouve vite avec une tonne de blocs alloués et ça fait pas joli, je trouve. Enfin pour pallier à ça, tu peux dire par exemple que l'historique suavegarde jusqu'à 30 commandes seulement.

Je comprend pas trop le coup de la pile, C trop compliqué pour moi

mais non, je suis a peu près certain que c pas super compliqué. Je voudrais bien l'appliquer, mais j'ai pas le temps cette semaine. Je pense qu'il serait mieux d'utiliser un bloc et de faire un realloc quand c nécéssaire.

En gros Pingoo :

Tu a un tableau et un "pointeur" sur le tableau

Ton tableau contient un historique des chaines que l'utilisateur a tapé, et le "pointeur" indique le nombre de commande dans la table.

pas obligé le nombre de commande. il est possible d'utiliser toute la RAM soit + de 1000 commandes je pense. On va dire que 30 suffit et il faut utiliser un séparateur dans le tableau

Si le nombre de commandes sert pour savoir si tu a rempli le tableua ou pas

je pensais à une chaine de carac + separateur
du genre
"ls -ash jeux\0man ls\0 ..."

plus complexe a faire dans se cas

pas vraiment...

en gros, je fait un tableau 2 dim
et je stocke les commanes marqué dedant (ca risque pas de prendre trop de memoire ca ??)

pas énormement. Ma solution serait probablement plus économique mais bon.

Si pasque tu est obligé de parcourir la chaine pour trouver le prochain

Donc en gros

Methode tableau :

char *gethistory(int i)
{
tab[1] = "ls -ash jeux\0"
tab[2] = "man ls\0"
//etc...

return tab[i]
}

Ta méthode :

char *gethistory(int i)
{
str = "ls -ash jeux\0man ls\0"
i = 2
ptr = str[0]
while(j<i)
{
 while(ptr!=0)
  ptr++
 i++
}
return ptr;
}

Bon ya de forte chance que sa marche pas, j'ai pas testé, mais en gros c sa

Pingoo, si tu fait un :!

char *[], sa prendra pas plus de place que la méthode de EvaSDK

t'es sur ? Parce que normalement ou il te faut un tableau de pointeur sur 30 chaines soit tu doit avoir un tableau de 30 chaines et dans ce cas la, quel que soit la taille (qui sera limité) de la chaine, la même taille sera consommé, d'ou perte (enfin je pense)
alors que ma méthode présente l'avantage de permettre le stockage de commande longue si nécéssaire (pour un éventuel pipe) même si il lui faut une taille max (ce qui peut-être arrangé dans les 2 méthode d'ailleurs)

donc, jecréé un tableau a deux entrée style,
char tab[50][50]
puis a chaques commandes de marquée, je copie la commande marque dans une ligne du tableau.
puis, quand on appui sur une touche, sa incremente ou dacremente un compteur qui va lire la ligne du dessus, ou du dessous dans le tableau

EvaSDK, faire un char *[] permet d'avoir un tableau de chaine qui on une taille indéfinie, mais oui effectivement il y a un ptit overhead, cad

Si on stoque x commandes dans ta version

un char *[] permet de faire plus "C" (ta méthodes est plus "asm") et provoque un overhead de 4*x octets (cad un pointeur)

Pour info un char *[] est un Tableau de Pointeur sur char *

voila

Pingoo, ta méthode est bien mais si on tape plus de 50 car, on risque d'avoir une surprise, meme si c improblable sur une TI...

Le pbm du char*[] : Obligation de faire des malloc/free

Et tu va avoir un overhead, mais bon il est pas enorme.

Tu fait comme tu veux maintenant, c toi le programmeur

ok, bon ben PiNGoO, tu fais comme tu le sens.
Overhead de 4*x ou x à toi de choisir

godzil a écrit :
Pingoo, ta méthode est bien mais si on tape plus de 50 car, on risque d'avoir une surprise, meme si c improblable sur une TI...

pas si au bout de 50 commande, on remet le compteur de ligne a 0
Non ??

car = caractère

=> si on tape plus de 60 caractères par commande, je suppose
(et non pas 50 lignes)

ben en fait, si on tape plus de 50 car, les autres vont aller sur le début de la 2eme ligne, et c pas cool

enfin, plus de 50 caractere pour une commande, ca fait beaucoup non ??