[Axe]Charmap

Salut
Pour faire court, je suis en train de faire un charmap destinée à un éditeur de cours (que je n'ai pas encore codé) sur TI.
S'il y a des volontaires pour m'aider à la finir ou proposer des caractères, il sont les bienvenus!
Je prévois de faire un éditeur sur PC, en espérant ne pas avoir trop de mal
voilà le début:

Code:

:.CHARMAP
:.0
:[708898A8C8887000]→Pic1
:.1
:[2060202020207000]
:.2
:[708808102040F800]
:.3
:[F808100808887000]
:.4
:[10305090F8101000]
:.5
:[F880F00808887000]
:.6
:[304080F088887000]
:.7
:[F808102040404000]
:.8
:[7088887088887000]
:.9
:[7088887808106000]
:.A
:[20508888F8888800]
:.B
:[F08888F08888F000]
:.C
:[7088808080887000]
:.D
:[F08888888888F000]
:.E
:[F88080E08080F800]
:.F
:[F88080E080808000]
:.G
:[7088808098887000]
:.H
:[888888F888888800]
:.I
:[7020202020207000]
:.J
:[3810101010906000]
:.K
:[8890A0C0A0908800]
:.L
:[808080808080F000]
:.M
:[88D8A88888888800]
:.N
:[8888C8A898888800]
:.O
:[7088888888887000]
:.P
:[F08888F080808000]
:.Q
:[70888888A8906800]
:.R
:[F08888F0A0908800]
:.S
:[7088807008887000]
:.T
:[F820202020202000]
:.U
:[8888888888887000]
:.V
:[8888888888502000]
:.W
:[8888A8A8A8A85000]
:.X
:[8888502050888800]
:.Y
:[8888502020202000]
:.Z
:[F80810204080F800]
:.minuscules
:.0
:[7098A8A8C8700000]
:.1
:[2060A02020F80000]
:.2
:[7088102040F80000]
:.3
:[E010201010E00000]
:.4
:[10305090F8100000]
:.5
:[F880F00808F00000]
:.6
:[384080F088700000]
:.7
:[F808102040800000]
:.8
:[7088708888700000]
:.9
:[7088780810600000]
:.A
:[0070087888700000]
:.B
:[808080F088F00000]
:.C
:[0070808080700000]
:.D
:[0808087888780000]
:.E
:[007088F080780000]
:.F
:[609080E080800000]
:.G
:[0070809888700000]
:.H
:[8080B0C888880000]
:.I
:[2000202020700000]
:.J
:[1000101050200000]
:.K
:[0090A0C0A0900000]
:.L
:[C040404040E00000]
:.M
:[0050A8A8A8A80000]
:.N
:[0018282828280000]
:.O
:[0070888888700000]
:.P
:[00F088F080800000]
:.Q
:[0078887808080000]
:.R
:[00A0D08080800000]
:.S
:[0078807008F00000]
:.T
:[80E0808090600000]
:.U
:[0088888898680000]
:.V
:[0088888850200000]
:.W
:[0088A8A8A8500000]
:.X
:[0088502050880000]
:.Y
:[0088887808700000]
:.Z
:[00F8102040F80000]

Certains caractères mathématiques prennent plus de place, je devrais sûrement sauter plus de pixels chaque ligne, ça prévoit d'être preneur de tête

Code:


.Il existe
[F80808780808F800]
.est inclus dans
[788080808080F800]
.pour tout
[82827C4428281000]
.appartient à
[788080F08080F000]
.ensembles
.N
[C2E2D2D2CACAC600]
.Z
[FE060C123060FE00]
.D
[F8C4C2C2C2C4F800]
.Q
[3864C2C2CA643A00]
.R
[FCC2C2FCD0CCC200]

.signe d'équivalence, combiner les trois
.<
[0618608060180600]
.=
[00FE000000FE0000]
.>
[C06006020660C000]
.tests
.=
[0000F800F8000000]
.différent de
[1010F820F8404000]
.supérieur à
[C02010081020C000]
.inférieur à
[1820408040201800]
.supérieur ou égal
[C0300830C000F800]
.inférieur ou égal
[186080601800F800]


Tu veux gérer un panel de caractères (sous forme de sprite) indépendant des officiels et des tokens ?
C'est intéressant !

Je ne sais pas bien comment tu alignes tes caractères pour le moment.
Si on n'aligne pas les contenus des sprites, il faudra décaler les sprites, et vice versa, à moins que tu te moques de l'esthétique.
Par exemple l et p ne sont pas des lettres alignées ensemble.
Je pense que tu devrais centrer tant que possible tes caractères dans les sprites, tant pour aligner que pour créer des exposants/indices ou autres farfelues. (peut-être que tu t'y efforces déjà d'ailleurs)
La question sera moins pointilleuse s'il n'y a que des majuscules. j'avais mal lu ton post, il y a bien des minuscules

Si tu crées des caractères d'informations multiples comme inférieur_ou_égal, cela pourrait être plus esthétique que la combinaison de "<" et "=".

Je me lance sur quelques lettres grecques. edit: Finalement presque toutes.

Hum moi je t'aide volontier dans la partie codage car je me debrouille plutot bien en Axe

L'editeur de cours est extrenement simple a faire y compris pour les image et autre outils (je parle bien sur sur la ti) apres la partie ordi j'espere que tu pourras le faire !

c'est vraiment un bon projet et je m'y insere dedans !

Il faudrait comme pour TIdoc un fichier lecteur pour la calculatrice (pour mettre tout les caractere dedans) les routine il n'y en auras pas un max ca ne sera pas trop long je pense
On peut meme imaginer en faire pour des applications mais ca on verra

en tout cas je prend part au projet et je tiens a apporter des idee.

J'ai commencé au hasard puis j'ai suivi internet pour presque toutes les lettres grecques.

Code:

.alpha
[01314A84844A3101]
.beta
[1C223C22223C20E0]
.gamma
[E314081414141408]
.GAMMA
[FF80808080808080]
.delta
[3840201028444438]
.DELTA
[10102828444482FE]
.epsilon
[3E4140241C20413E]
.eta
[4C52322222020202]
.theta
[18242424FF242418]
.kappa
[2629293028242221]
.lamda
[4040202010081422]
.LAMDA
[18182424244242C3]
.mu
[4242426458404040]
.nu
[008C8E4444282810]
.xi
[8C5C2018201C02FE]
.XI
[FF8100243C2481FF]
.pi
[FF24242424242424]
.rho
[0C121C10102020F8]
.sigma
[00017E8888482810]
.SIGMA
[FE4020102040FE00]
.tau
[3F50909050101010]
.phi 1
[1038549292543810]
.PHI 1
[FF103854543810FF]
.phi 2
[4C5252523C101010]
.chi
[40A4949812324A44]
.psi
[9254543810101010]
.omega
[000044829292926C]
.OMEGA
[003C4281814224E7]

.ps : vive pixelscape !

Un éditeur est bien plus complexe qu'un lecteur, tu simplifies trop vite sachiix69.
Cependant s'il n'y a pas de notion d'insertion ni de formatage cela pourra rester très proche de ton idéal de simplicité.

On peut imaginer des caractères en plusieurs morceaux comme l'intégrale en ascii peut-être ?

EDIT : table améliorée :
-changé l'ordre pour corréler à ce que j'ai trouvé sur wikipédia
-écrit en majuscule le nom de chaque caractère majuscule plutôt que d'ajoûter "maj" derrière
-supprimmé "(min)" qui avant plaçait en exergue l'abscence de majuscule pour le caractère via les parenthèses
-saut de lignes et mention ci-après de quelques caractères absents : io,sampi,zeta,dzeta,omicron,upsilon

Ah mais moi je parle uniquement du lecteur puisque le lecteur sera sur ordinateur

apres l'editeur si il est sur TI je n'y ai pas encore reflechis.

Je pensais deja a la base a ca :

un code compiler structurer de ce genre la :

-de 00 a XX en hexa pour les charactere
-XX+1 pour passer de normal font en invert font
-XX+2 pour passer en large font
-XX+3 pour souligner (une premiere sur z80 )
-XX+4 pour barrer (idem)



Je peut faire une applications ou tu met un premier caractere dans le programme, le nombre XX+5 par exemple et ca propose de lire ce programme

qu'en pense tu ?

De quelle façon veux-tu lire les textes ? En combinant ces cas :
*routine
-application
-programme
-comme ion
*texte
-programme à executer (utilisant la routine)
-programme lu (par l'appli ou le programme routine executé)
-EDIT: appvar

L'application est facilement plus lourde mais l'accès en mémoire est plus facile.
A contrario le programme routine est facilement plus léger mais moins accessible
Des routines stockées comme ion, je ne sais pas si c'est possible mais ça peut être efficace malgré les risques d'incompatibilités.

Les formats peuvent influencer de manières différentes :
-charger un sprite différent (e.g. police)
-ajoûter des choses (e.g. souligné ou barre)
-transformer le sprite (e.g. retourné, symétrie)
-décaler le sprite (e.g. indice, exposant)
-symétrie/rotation de texte, qui serait probablement compilée à partir d'un texte saisi à l'endroit pour obtenir le résultat en brut utilisant les autres formats cités et en changeant l'ordre des caractères

La table des caractères et formats peut être structurée de plusieurs manières (quel que soit l'effet du format) :
- (la tienne) un code qui fait la somme "carac+format" (revient à placer côte à côte les formats d'un même caractère dans la table) ; avantage pour la création de nouveaux caractères
-un code qui fait la somme "table+carac" (revient à placer chaque format dans une table) ; avantage pour la création de formats
-un code qui stocke les informations carac et format séparément (e.g. deux octets ou paires d'octet) côte à côte dans le fichier ; "carac//format"

(je n'envisage pas des formatages d'ensembles, ce serait bien trop compliqué pour nous pour une économie de mémoire souvent négligeable)

J'ai une préférence pour la méthode avec un programme routine et le codage "carac//format".

EDIT : je vois dans les messages suivants que tout est prévu comme des balises, donc il y aurait bien des formatages d'ensembles, et cela évite mes hypothèses de structures de codage.

Pour qu'il n'y ai pas de malentendu, l'éditeur est sur ordinateur et le lecteur sur calculatrice, l'éditeur sur calculatrice n'est pas encore prévu.
L'utilisateur rentre son texte dans un notepad, lance le traducteur qui le transforme en hexa, puis copie le nouveau code dans TokenIDE où
il le compile en appvar (.8xv).
(si vous avez une meilleur idée pour créer l'appvar, proposez )
Chaque caractère ou instruction est faite d'un octet
Les 240 premiers sont des caractères, les 15 derniers des instructions du type souligner, inverser.
Pour les indices, exposants, vecteurs et tout le blabla, on peut utiliser des caractères déjà présents mais placés à de différents endroits à l'aide d'instructions.
Ex:

Code:


Fe sup 2+ sup
devient:
4D 23 FF 02 B3 FF

(4D pour F, 23 pour e, FF pour indiquer qu'on veut placer du texte en exposant, 02 et B3 pour 2+
et FF pour indiquer qu'on veut quitter le mode exposant)


Si mes caractères sont codés sur 8 octet, c'est à cause de l'axe qui m'oblige à les afficher ainsi mais mes caractères ne prennent que
7 pixels de haut et 5 de large.
Les lettres grecques que tu as faites sont en 8*8, mais ce n'est pas grave!
J'avais également essayé de faire des lettres grecques en 5*7 hier mais certaines comme le zêta sont impossibles à réaliser avec cette dimension.
Alors je vais ajouter les tiennes et les miennes
Merci beaucoup pour votre aide

C'est bien. Après il faudra automatiser ça comme TextToTi ou TiDoc.

Il reste encore à se décider sur la forme de stockage de la routine de LECTURE puisque vous avez tous deux montré qu'il y aurait un compilateur (éventuellement éditeur) sur ordinateur et un lecteur sur TI.

Sache que je n'ai pas dessiné certaines lettres comme le dzeta car j'avais du mal et que je ne les fréquente jamais...

Nous devrions nous inspirer de certaines lettres imprimmables utilisées par TiDoc (et XtraToken) : il y a des lettres grecques en police graphique 3*5 + marges.

Songe que certains formats peuvent être compilés sans balise propre afin d'alléger la lecture : par exemple une inversion verticale ou symétrie centrale ou rotation , d'un texte , peut être composée d'une permutation des caractères (à ce niveau là transformé par le compilateur) puis d'un format d'inversion de caractères.

Ce sera probablement compliqué mais j'envisage de permettre tantôt un format balise, tantôt un format avec uniquement entête pour alléger quand le format ne touche qu'un caractère.

Autre solution de balisage : un entête et une info de longueur à la suite au lieu d'une longueur indéfinie et d'une balise fermante.
Je l'énonce juste pour le principe, car je pense bien que vous préférerez les balises fermantes.

Il est possible d'augmenter la capacité des codes au delà de 256 : en réservant un ou plusieurs codes à l'information "instruction étendue" comme en hexadécimal Z80 où DD,ED,FD,commandent l'extension, et ou d'autres instructions suivantes peuvent étendre encore plus.
Cela peut apporter non-seulement une variété, mais en plus le concept de choix de tables/plug_in/include...
Pour l'instant restons-en à l'éventuelle extension des commandes sans chercher à faire des extensions modifiables.

Cette dernière méthode d'extension peut s'appliquer à des formats sur un unique caractère afin d'optimiser.

Alors pour le lecteur comme je l'ai dit le plus simple est une applications a lancer et qui te propose de lire les programme que tu as envoyee. c'est plus simple pour l'utilisateur.

Pour le lecteur, c'est comme je l'ai dit un truc qui interprete chaque octets comme un truc a lire ou une commande a executer.

pour des code a deux charactere hexadecimal, on peut facilement faire cela

car du coup chaque commande sera un nombre entre 0 et 65535

vous etes d'accord ?

je repredn ce que je veux dire :

-de 00 a XX en hexa pour les charactere
-XX+1 pour passer de normal font en invert font
-XX+2 pour passer en large font
-XX+3 pour souligner (une premiere sur z80 )
-XX+4 pour barrer (idem)
-XX+5 pour l'exposant...

Et une applications permet de ne pas faire plusieurs programme.

vous me comprenez ?

Oui je comprend :
-tu préfères avoir une application comme un shell pour détecter et lire des appvar.
-tu penses tout coder sur 2 octets plutôt que de te baser sur un octet avec quelque fois des extensions qui mèneraient à des triplets d'octets ou plus.

Et je n'avais pas bien compris ce que tu voulais dire quand j'ai réfléchi aux possibilités de codage, ainsi ce que je t'attribuais ne correspond pas.
En tout cas vous êtes tous deux partis sur une idée de placer les codes de format à la fin de la table.

Il n'y a pas besoin de faire plusieurs programmes même sans application. Si le but est d'élaborer des modules (comme des fonctions à appeler) il suffit d'utiliser l'instruction call.
Quoique tu me diras peut-être que l'Axe ne le permet pas :trollface:

Je suis d'accord pour coder tout (ou presque*) sur deux octets, c'est utile si on utilise la majorité des codes.
*Cependant je pense qu'on peut coder certaines instructions courantes (dont des formats) sur un unique octet quitte à abandonner les codes à deux octets qui correspondent aux octets simples choisis. (256 pour chaque, comme pour des dizaines mais en base 256)
Cela peut permettre des économies de place (en sacrifiant de la simplicité de routine) et sera bien plus pratique que mon idée d'utiliser des instructions d'extension.

C'est a dire que je veux coder tout sur les octets de 00 a FF car en axe agir sur un octets c'est utile pour pas grand chose surtout si on fait une applications car il faut rechercher si l'octets est pair ou impair....

une applications me semble pas mal car j'ai fait des recherche pour voir et appeler des routine externe au programme en axe c'est sois tres simple en utilisant une applications (donc aucun interet autant tou mettre dans une applications dans ca cas la) soit c'est assez compliqué en utilisant la methode des appvar ce qui voudrait dire qu'il faudrait ajouter encore un programme a envoyer, c'est trop compliquer

donc ce que je propose c'est d'utiliser une applications comme ca on pourras mettre plein de truc dedans, presque autant de routine que l'on veut.

ET le gros avantage de cela c'est qu'on pourras agrandir un peu le header du fichier et permettre a l'utilisateur de mettre des nom plus long que 8 octets pour etre plus explicite car quand on a beaucoup de programme pour s'y retrouver c'est chiant

en plus grace a une applications on pourras changer de programme a lire facilement

(on peut meme ajouter une petite applications pour les programmeur qui montre les octets de chaque programme )

Tu as bien parlé de 65535, qui se code sur 2 octets, alors pourquoi parler maintenant d'octets uniques ?
Il semble que tu ais confondu les quartets (caractères hexadécimaux) qui codes sur 16 et les octets (paires de quartets) qui codent sur 256 et la paire d'octets sur 65536.
Maintenant j'enregistre ton idée de stocker tout sur un octet, mais je maintien l'idée de sacrifier quelques codes à 1 octet pour permettre des extensions à plusieurs octets.

Pourquoi tu aurais besoin d'un programme supplémentaire pour gérer les appvars ? Tu peux pas rassembler toutes les routines dans une seule application ou un seul programme ?

Parler de pair ou impair n'est pas net puisqu'un nombre est écrit à l'envers et donc que le poids fort est à droite. Ou alors tu penses déjà à une contrainte de l'Axe que j'ignore.

La routine peut lire un entête stocké dans l'appvar, pas forcément dans une application.
Mais stocker tout ensemble dans une unique appvar ou l'application évite bien des difficultés. (gestion et détection des fichiers, s'occuper de noms de 8 lettres malgré l'objectif des entêtes d'augmenter la capacité)

Je pense les stocker ensemble (appli ou appvar) et ajouter ou extraire des textes de la calculatrice via une appvar au nom fixe, enfin gérer le tout avec la routine.

On peut ajouter les text dans des programme/appvar ce que l'on vent en axe on s'en fiche en revanche le programme principal devra etre une applications on a pas le choix c'est trop compliquer d'acceder a des routine de programme externe en axe ! j'en discuterais bien mais c'est vraiment pas une bonne solution que de ne pas le mettre dans une applis crois moi...

ensuite je parle d'octets car si on a 100-200 caractere et que l'on place une bonne 20aine de commande on peut facilement faire rentrer ca sur un octets

RECAPITULATION N1
-texte generer en appvar/programme (c'est la meme chose en axe)
-code generer sur un octets pour les chiffre et lettre et autre charactere (on pourras toujours cree des extension)
-appels de routine de lecture generee par deux octets donc le premier est toujours FF (quand le programme detexte FF il sera qu'il faut lire une routine)
-programme de lecture dans une applications qui propose une liste de programme a lire
-les premier octets du code generee pour la lecture serviront a faire une longue chaine qui decrira les programme avant de les lire (pour que ca soit plus intuitif)

je suis sur de savoir coder tout ca pour le moment et je pense que samsam aussi !

L'ensemble me convient assez bien.

Pourquoi obligatoirement déclencher des routines avec FF ?
Cela marche mais tu ne l'avais pas encore dis je crois et puis samsam voulais FF comme fin de formats.

extensions : Je pense que quelques codes appelleraient avec le second octet des caractères d'une table secondaire et que quelques autres appelleraient des plug-in via des informations dans l'entête du programme et une table ajoûtée dans l'appli ou ailleurs.

Oui evidemment, j'ai dit FF comme ca par hasard pour dire comment ca fonctoneras !

Il faut que (comme c'est vpus qui vous vpous occuper des charactere ) combien vous en avez et tout !

je vais commencer ce soir a coder l'applis d'ensemble et la structure principales, on marche open source ou non ?

EDIT : il me faut un nom de programme aussi

Va pour l'opensource. Sur ce coup là on est 3 et c'est toujours intéressant quand d'autres personnes peuvent ajoûter leurs idées.
Remarque que n'importe qui peut travailler sur les caractères grâce à pixelscape
Comme nom, je pense à UltiText ou TINote ou SpaceTxt.

C'est une bonne idée pour le nom
Chaque caractère est écrit le plus bas possible dans une Pic(8 octets)
Pour les 5*7: saut entre lignes: 8 px saut entre caractères: 6 px
Pour les 8*8: saut entre lignes: 9 px saut entre caractères: 9 px

Je compléterai au fur et à mesure
à copier dans un notepad, c'est plus lisible

0 00 0 00708898A8C88870
1 01 1 0020602020202070
2 02 2 00708808102040F8
3 03 3 00F8081008088870
4 04 4 0010305090F81010
5 05 5 00F880F008088870
6 06 6 00304080F0888870
7 07 7 00F8081020404040
8 08 8 0070888870888870
9 09 9 0070888878081060
10 0A A 0020508888F88888
11 0B B 00F08888F08888F0
12 0C C 0070888080808870
13 0D D 00F08888888888F0
14 0E E 00F88080E08080F8
15 0F F 00F88080E0808080
16 10 G 0070888080988870
17 11 H 00888888F8888888
18 12 I 0070202020202070
19 13 J 0038101010109060
20 14 K 008890A0C0A09088
21 15 L 00808080808080F0
22 16 M 0088D8A888888888
23 17 N 008888C8A8988888
24 18 O 0070888888888870
25 19 P 00F08888F0808080
26 1A Q 0070888888A89068
27 1B R 00F08888F0A09088
28 1C S 0070888070088870
29 1D T 00F8202020202020
30 1E U 0088888888888870
31 1F V 0088888888885020
32 20 W 008888A8A8A8A850
33 21 X 0088885020508888
34 22 Y 0088885020202020
35 23 Z 00F80810204080F8
36 24 a 0000006010709070
37 25 b 0000008080E090E0
38 26 c 0000006090809060
39 27 d 0000001010709070
40 28 e 0000006090E08060
41 29 f 00000040A080C080
42 2A g 0000006080B09060
43 2B h 0000008080C0A0A0
44 2C i 0000004000404040
45 2D j 000000200020A040
46 2E k 00000090A0C0A090
47 2F l 0000004040404060
48 30 m 00000050A8A8A8A8 5
49 31 n 00000040A0A0A0A0
50 32 o 0000000060909060
51 33 p 000000E090E08080
52 34 q 0000006090701010
53 35 r 000000B0C0808080
54 36 s 00000070806010E0
55 37 t 00000080E0808060
56 38 u 000000009090B050
57 39 v 00000000A0A0A040
58 3A w 0000000088A8A850 5
59 3B x 0000008850205088 5
60 3C y 0000009090701060
61 3D z 000000E0204080E0
62 3E alpha 00000050A0A0A050
63 3F beta 00F088F088F08080
64 40 gamma 0088885020505020
65 41 delta 0020504020508870
66 42 epsilon 0070888060808870
67 43 zeta 00B048B080700870
68 44 eta 0050A82828280808
69 45 theta 00708888F8888870
70 46 iota 0000404040405020
71 47 kappa 008890A0C0E0B098
72 48 lambda 0080402010304888
73 49 mu 0090909090E08080
74 4A nu 0000909088485020
75 4B KHI 00F80000700000F8
76 4C omicron 0000007088888870
77 4D pi 0000F85050505050
78 4E rho 00609090E0808080
79 4F sigma 00003840F0888870
80 50 tau 000078A020202020
81 51 upsilon 0000909088484830
82 52 phi 0070A8A8A8702020
83 53 ksi 0088485020509088
84 54 psi 00A8A8A870202020
85 55 omega 00005088A8A8A870
86 56 DELTA 00000000205088F8
87 57 SIGMA 00F88040204080F8
88 58 OMEGA 00007088888850D8
89 59 + 0000002020F82020
90 5A - 0000000000F80000
91 5B * 000020A870A82000
92 5C / 0000000810204080
93 5D : 0000003030003030
94 5E . 0000000030300000
95 5F ( 0010204040402010
96 60 ) 0040201010102040
97 61 [ 0070404040404070
98 62 ] 0070101010101070
99 63 +- 002020F8202000F8
100 64 infini 00000050A8A8A850
101 65 sto 0000002010F81020
102 66 -négatif 0000000038000000
103 67 0 petits 40A0A0A040000000
104 68 1 3*5 40C04040E0000000
105 69 2 C0204080E0000000
106 6A 3 C0204020C0000000
107 6B 4 80A0E02020000000
108 6C 5 E080C020C0000000
109 6D 6 6080E0A0E0000000
110 6E 7 E020408080000000
111 6F 8 E0A0E0A0E0000000
112 70 9 E0A0E020E0000000
113 71 - 0040E04000000000
114 72 + 0000E00000000000
115 73
116 74
117 75
118 76
119 77

C'est quoi ? Un liste des données élaborées ou un listing de compilation ?

Stocker dans une Pic est-il un moyen de permettre des plug-ins ?
Si ce n'est pas le cas autant stocker dans l'executable.

J'immagine que les noms en majuscules représentent des caractères majuscules, mais il semble manquer une tripotée de mes caractères alors.
Cela me donne une idée pour refaire les étiquetages. J'édite mon message contenant mes caractères grecs.

OULA que vais je faire avec ca moi

donc j'ai pas mal codee et pas mal reflechis aujourd'huis et j'en suis arrivee a cette conclusion :

-programme principale en applcations qui montre la liste des programme.
-programme fais par l'ordi compilee en programme (car si on prends une appvar, l'utilisateur ne vas plus rien comprendre a la liste des appvar qui va se tenir devant lui alors que les programme c'est tranquille)

BIG EDIT : j'ai bosser pendant tout le film "le seigneur des anneaux" pour en arriver la, le graphique est pourris mais j'ai tout implanter il faut juste regler un peu la vitesse et commencer a remplir les routien mais bon dieux quel boulot de fou cette VAT va me rendre fou

[Vous devez être inscrit et connecté pour voir cette image]

Tu as donc changé d'avis ? Tu abandonnes ton idée de rassembler les textes dans l'application.

Si des textes sont sous forme de programmes, alors cette méthode d'usage ne convient plus.
En effet l'application de lecture gérant une liste n'a plus aucun intérêt si on ne peut plus gérer de noms étendus etc.
De plus les noobs vont confondre les programmes classiques et les textes.
>> Il est préférable de faire comme TI-Doc dans ce cas. (Sans Asm() tant qu'à faire)

Je suppose que tu as fais ainsi car tu voulais exploiter les fonctions de la VAT ? (que ce soit de l'Axe ou des romcalls)
On n'en n'a pas forcément besoin, tu peux même copier les routines de la TI.

Si tu crées un générateur de liste fouillant dans un seul fichier, il est possible que ce fichier porte un nom arbitraire, et idem pour les fichiers échangés par câble. Ce sera plus clair à gérer quand on est pas en train d'executer le lecteur, et on pourra quand même stocker des noms étendus etc dans les entêtes des textes.
Cela est valable que ce soit stocké en appvar ou en programme, et même préférable en appvar (pour être invisible à un noob).
Dans cette méthode il faudrait que le lecteur soit cappable d'intégrer à son fichier principal depuis l'autre fichier ou de l'extraire vers l'autre fichier.

Non il m'est impossible de faire comme TI-doc ! pas la peine d'en discuter

mais cela n'est pas finis, les programme afficher seront uniquement ceux qui seront du format du lecteur de texte evidemment cependant ls seront a envoyer sont la forme de programme archiver

EN gros les programme afficher seront :

-ceux avec la bonne cle en debut d'appvar

et il y auras de 1 a 20 charactere affchable pour la presentaton du programme.

EDIT :
header d'un fichier 8xp : [Vous devez être inscrit et connecté pour voir ce lien]

vat : [Vous devez être inscrit et connecté pour voir ce lien]




Samos s'est je crois surestimer....pour la partie ordi il nous faudras de l'aide...

OOOUUUUFFFFF

enfaite on ne peut pas reelement acceder au donne des programme archivee.... MAIS grace a runer112 j'ai trouvee un moyen >_< autant dire que j'ai passer du temps a coder mais maintenant ca marche

Super
Il faudrait que tu me donnes la charmap que tu as modifiée sinon je ne pourrai pas faire la partie compilateur, j'ai déjà commencé sa structure principale
N'oublie pas que c'est open source
Il faudrait trouver un nom attractif aussi, corriger tes fautes du lecteur de textes, faire une documentation pour le langage...
(Peut-être aussi traduire la doc dans plusieurs langues)
Dites moi si je n'ai rien oublié

Code:


#include <fstream>
#include <iostream>
#include <string>

using namespace std;

std::string compile(char code[] , unsigned int& cptr, bool& space){

string codes="";







return codes;
}

void checksize(unsigned int size[], bool& space){

if(size[0]>255){
size[1]++;
size[0]=0;
}

if(size[2]>255){
size[3]++;
size[2]=0;
}

if(size[3]>255){
cout<<"not enough space";
space=false;
}

}




int main()
{
    ifstream cinput("compile.txt");

//get name
    string title;
    char name[8]={0,0,0,0,0,0,0,0};

    getline(cinput,title);
    cinput.seekg(0, ios::beg);

    for(unsigned int xxxxx=0 ; xxxxx<title.size() ; xxxxx++)
    cinput.get(name[xxxxx]);
//end

//get size
    char a;
    unsigned int cptr=0;
    while(cinput.get(a))
    cptr++;
//end

//get code
    char code[cptr];
    cinput.seekg(title.size(), ios::beg);
    for(unsigned int xxxx=0; xxxx<cptr ; xxxx++)
    cinput.get(code[xxxx]);
//end

    unsigned int size[4];
    bool space=true;
//compile
    string hexcode=compile(code, cptr, space);
//end

//test
if(!space)
return 0;
//end

//create program
    title+=".8xp";
    ofstream program(title.c_str());
//end


    char header[57]={0x2A,0x2A,0x54,0x49,0x38,0x33,0x2A,0x1A,0x0A,0,'1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3','4','5','6',
    size[0],size[1],0x0D,0x00,0x06,name[0],name[1],name[2],name[3],name[4],name[5],name[6],name[7],
    0x00,0x00,size[2],size[3]};

//write

for(unsigned int x=0 ; x<57 ; x++)
    program<<header[x];
    program<<hexcode;

//end

    return 0;
}