PureBasic

c'est Free.fr qui semble déconner ...

(encore que de chez moi , le telechargement se fait tres bien)
ça doit dépendre des fournisseurs

je viens de l' essayer les outils ne démarrent pas, ils sont bien dans le répertoire outils??
j'ai chargé un fichier de 7000 lignes pas plus long que l'IDE PB

merci
bonne soirée

kernadec a écrit :je viens de l' essayer les outils ne démarrent pas, ils sont bien dans le répertoire outils??

oui mais faut mettre les Outils fournis avec l'archive !!
en clair tu vire ton ancien dossier de EPB
tu désarchive le nouvel EPB
et tout marchera !!

c'est fait expres , car EPB est encore en cours de devellopement
et comme je peux etre amené a retoucher aussi les outils (Epb_ascii,Epb_couleur,Epb_structure)

donc , ces outils ne marcheront qu'avec la version Epb avec lequel ils sont fournis ...
Autre chose :
comme je change / ajoute des paramètres dans Epb.prefs , je conseil de l’effacer
bref , virez l'ancien Dossier , et remplacez le par celui de l'archive pour etre sur que tout fonctionne

ok, ça marche comme t'as dit.
mais juste une remarque, j'ai charger plusieurs code et les gros codes, il prend son temps pour passer
d'un onglet avec gros code à un autre, c'est peu embêtant....
quand justement on bosse sur un gros code et que l'on change d'onglet pour une raison ou une autre
et que l'on revient sur ce long code... cela me semble vraiment lent...
je pense que tu connais ce soucis, je ne voudrais pas remuer le couteau trop durement, après un tel boulot...

Merci, Bonne soirée.
Cordialement

en fait le temps qui est pris viens du fait
que j'utilise le clic sur les onglets (mais aussi la mise en forme Alt+tab) pour mettre a jour les listviews
(procedure/constante/Signets) et ... la complétions
je ne sais pas comment Japbe fait tout ce boulot aussi vite ...

pour la completion, j'utilise une fonction donné par la librairie que j'utilise
mais, pour la mise a jour des listview, je suis obligé de parcourir tout le code
a la recherche des infos (possiblement nouvelle) a mettre dans les listview...

du coup ça prends du temps sur les gros code ...

c'est surtout le systeme de complétion qui est tres tres lent !
la lib (Gosci_Scintilla) utilise pourtant un system de Map() , mais ça rame ..
je pourrai gagner de la vitesse si je désactive la completion pour nos propres constante et procedure... seulement on perd en convivialité ..

je ne sais sur quel pied danser ..

en l"etat , il vaut mieux utiliser EPB pour des codes courts/moyen ou
utilisant des includes par exemple ...

Merci a toi

Dobro a écrit :mais, pour la mise a jour des listview, je suis obligé de parcourir tout le code
a la recherche des infos (possiblement nouvelle) a mettre dans les listview...

Pourquoi n'analyses-tu pas simplement la ligne de l'éditeur sur laquelle est posée le curseur ?
Il me semble que pour la coloration ça fonctionne comme ça ! J'avais fait ça pour un projet d'éditeur de code interprété,
et ça fonctionne bien, et sans prendre trop de ressource
Et bien sûr, il faut aussi analyser les copier-coller

Simplement, je trouve ça moins lourd que de repasser les 5000 lignes de code à chaque mise à jour.

graph100 a écrit : Pourquoi n'analyses-tu pas simplement la ligne de l'éditeur sur laquelle est posée le curseur ?

ha oui tiens... pourquoi je fait pas ça ??

hum, faut que je retourne dans mon code, voir pourquoi, je fais pas ça

Mais quel bourrin !!

Bon je viens de regarder mon code , et voila pourquoi je parcours tout le code

Actuellement :
lorsque l'on ecrit une nouvelle procedure

genre procedure Toto()

lors d'un appuis sur Return

j'efface ma liste chainée procedure

je parcours une a une les lignes du code, et lorsque je trouve le mot procedure
je l'ajoute dans la liste chainée procedure

puis a la derniere ligne , je parcours a nouveau ma liste chainée pour mettre a jour ma listView !

de sorte que si tu efface ou modifie une ligne comprenant le mot procedure
le processus se repete, donc la listview est mise a jour en temps reel

alors donc , en utilisant ta methode , de ne tenir compte que de la ligne en cours
je vais gagner du temps pour ajouter une procedure dans la listview

mais alors se pose la question suivante :

comme gere tu la modification d'une procedure dans le code
ou comment gere tu la disparition d'une procedure du code ?

ma methode repart de zero a chaque fois, mais au moins la list view contient un etat des lieux
reel de ce qui se passe dans le code


si je ne me concentre que sur la ligne en cours ,
1 il me serai possible d'ajouter toute nouvelle procedure (car le scan de la liste chainée
me dirai si elle est deja presente ou non...)

mais impossible d'effacer une procedure qui aurai été modifiée , car elle serai considéré comme
nouvelle procedure (ayant un nouveau nom)

et impossible d'effacer une procedure, car la procedure en cours venant d'etre modifié

je ne pourrai vérifier si son nom est deja présent dans la listview (par le scan de celle-ci)....
puisque ce nom venant d'etre changé...

(a moins peut etre de mettre en memoire la ligne en cours avant modification...mais c'est complexe... on est en temps reel...)

j'avais choisi l'algo de "l'ardoise" j'efface, et je reecrit tout , ce qui me parraissait plus simple

.... mais plus lourds du point de vue temps , car je ne m'attendais pas a ce que Purebasic
soit si lent avec les Chaines.....

la lumiere me viendra... c'est simplement une question de temps
lorsque le declic se fera, je coderai ça en 3 minutes chrono....
je fonctionne comme ça ...

effectivement ça corse le problème. mm

Alors, je propose un point de vue :

- tu scannes uniquement certaines lignes. Et principalement celle qui est en cours d'édition.
- derrière ça, tu stockes dans une liste, ou autre, le numéro des lignes des procédures, avec leur noms et autres infos.
- tu mets à jour les numéros de ligne en fonction des actions utilisateurs (retours chariot, effacement, copier coller, etc...)
Ce qui implique une gestion fine de tous les évènements qui arrive de ton éditeur.
- lorsque tu effaces un truc, tu peux tester avec le numéro de ligne si c'étais une ligne contenant une procédure. Soit tu mets à jour le nom si il a changé (dans l'éditeur pb, le nom se maj lorsque le curseur change de ligne, par quelque moyen que ce soit).
à la limite tu peux tester chaque ligne de contenant des procédures, ça seras toujours plus rapide que de faire tout le code.

En gros tu fais un adressage dynamique des lignes à procédures, ça va pas être simple, mais je pense que c'est faisable

graph100 a écrit :tu peux tester avec le numéro de ligne si c'étais une ligne contenant une procédure.

j'y ai reflechi hier soir au pieu avant de dormir

j'en suis venu aux memes conclusions que toi

de plus , il se trouve que je gere deja les numéros de lignes
ces numeros sont deja inscrit dans la listview !! apres le ">" (faut scroller a fond a droite pour les voir)

ces numéros me servent deja pour le "Saut" a la bonne ligne en cas de clic dans la listview
il me suffit de comparer le numero de ligne en cour d'edition, avec les numeros de ligne
de la listview , pour savoir si c'est un ligne de code deja referencé

lorsque j'aurai 5 minutes , je changerai ça
Merci a toi pour tes lumieres


ps: :
mais bon dans l'absolu , c'est surtout les completions qui prennent du temps !

et là c'est une autres histoire !
la lib que j'utilise m'oblige a mettre en chaine le nom des procedures
par exemple pour

procedure toto()
endprocedure

procedure titi()
endprocedure

procedure tutu()
endprocedure

il faut que je transmette
" toto() titi() tutu() "

la mise en chaine ne prends pas trop de temps , mais la transmission
elle , super lente !


extrait du code :

Le vieux réflexe : "chaine$ = chaine$ +"

ha oui mais là je suis en désacord complet avec le purebasic !


pour moi
a=a+1
n'est pas la meme chose que

a+1 ...


je sais tres bien qu'on peut faire ça en Purebasic
mais je trouve que c'est une aberration ! car source de confusion

en Basic (et en principe)

a=10

print a+1
ça renvoyait 11 !!
mais si tu faisais juste apres
print a
ça renvoyait 10
car la valeur de a , n'as pas ete touché

alors que

a=10
a=a+1
print a
ça renvoie 11

pourquoi :
parce que dans la premiere proposition (a+1)
on prends une variable "a" auquel on ajoute 1,pour l'affichage

et si on faisait
a=2
b=10
print a+b ; <-- affiche le resultat de a+b SANS TOUCHER A LEUR VALEUR RESPECTIVE
ça sortait 12
on appelais ça le mode Direct !!

et si on voulais mettre ce resultat dans a
alors dans ce cas
a=a+b

ce qui signifie littéralement
"a est egale a sa propre valeur (a lui meme) plus la valeur de b"

dans ce cas le contenu de la variable a etait changé
c'etait d'ailleurs le but de cette orthographe

Heureusement Purebasic me permet de garder mes habitudes de dinosaure

Oui C'est la force de PB

Mais ton exemple en remplaçant print par debug fonctionne tout aussi bien. Mais je pige bien ce que tu veux dire je t'embête plus qu'autre chose là