TOUSSAINT on a plus la patience !!! - Page 1

Ouais, y revient quand [pollux] ??? y ne sort pas de petite bêta de gtc en fin de compte ? NSpirit, j'espère que t'aura pratiquement fini tes nvg avant la fin des vacances Et SBibi !!! faut l'encourager !!! il tue son moteur !!! SCOOP : le clipping, qui plantait complètement, ne plante plus qu'à moitié !!!

allez, on programme tous et on sort des beta attendu (qui a parlé de chrono )

arf g pas de vacances donc les map c pas ca ki fera avancé
peut etre chikensaver il ma dit kil en ferai

qu'est ce qui manque à chrono???
juste les maps??

euh nan pas que ca ms pour la beta c a 75% des maps

et la beta, elle en est à combien de %??

sur calc 0%
sinon ya pratikement tout les elements a part fo juste les mettre ensemble

eh ben, allez y

il nous fo de la motivation
et une panne de magnetoscope pour pphd

pas, de pbl! je peux me déplacer et l'en débarasser gratos!

Allez, on encourage la Time To Team

on la veut cette beta

OUAIS !

et à propos de pollux ? Thibault, pas de nouvelle ?

Non, il ne doit pas avoir de vacances. Attendons Noël.

Mais bientôt y'aura l'Azur, alors...

Mais si il a des vacances! Je vais pouvoir avancer un peu GTC...

Et sinon il sort qd l'Azur?

Je ne sais pas, mais il avance beaucoup.
Le code produit sera moins optimisé que celui de GTC, mais en contrepartie :
- plus rapide à compiler que GTC
- _nostub
- librairie (ensemble des fonctions statiques) en open-source
- plus clair que le C, et très très proche à la fois (plus que le SMALL)

GTC peut très bien fonctionner en _nostub et rien ne t'empêche de faire une librairie en open-source

Tu pourrais me montrer un exemple de code Azur?

ouais mais cmieux avec genlib

Pollux :

1) l'Azur peut très bien fonctionner en kernel... Moi je parlais du compilo lui-même : GTC nécessite un kernel (64 ko ), Azur tourne sans rien (17 ko à l'heure actuelle, mais j'en suis qu'à la moitié ).

2) avec l'Azur pas besoin de se programmer une lib en open-source, c'est déjà fait

3) Exemple de code : ici, parceque le pre de yAro est foireux.

[edit]Edité par Thibaut le 01-11-2001 à 15:07:14[/edit]

beurk! http 404

c proche du C tout ça
qques questions :
1) il sort qd?
2) il gère les struct/union & co?
3) tu peux me montrer le code généré?

>> c proche du C tout ça
ben oui
* Avec quelques inspirations de l'ASM : il n'y a que 3 types : byte / word / long et on précise s'ils sont signés ou non avec un '+' ou un '-' (facultatif, car signés par défaut)

* quelques inspirations du Pascal (pour la clarté ) : @ pour obtenir l'adresse d'une variable, structures algorithmiques "en toutes lettres" : for expr to expr step expr do ...

* Des nouveautés, principalement les déclarations qui se font entre crochets. A ce propos, en Azur elles peuvent se faire n'importe où dans un bloc d'instructions, contrairement au C où tout doit être placé au début. Autre nouveauté : un opérateur inédit en C, l'opérateur de permutation : '<>', qui produit un code de bas niveau bien plus efficace que ce qu'on obtiendrait avec l'équivalent C "a= b; b= c; c= a;"

* Tout le reste (90 c'est du C


1) je ne sais pas trop, et je crois que je ne serais pas prêt pour le concours TI-fr

2) pas encore mais ça viendra, je me prend la tête sur des trucs plus vitaux actuellement.

2) oui, mais tu sais il n'est pas terminé mon compilo. Il ne sait que :
* gerer les includes et d'autres petits trucs de ce genre
* interpreter les déclarations
* déréférencer les pointeurs
* interpreter les égalités
Il me reste à implémenter plein d'opérateurs et les structures algorithmiques

Donc voici un code qui entre dans ses capacités actuelles :

#common                                : pour qu'il commente le code asm produit

void main[long exemple_de_paramètre]   : les lettres accentuées sont parfaitement autorisées :)
{
  [
    byte @Pointeur, Tableau[32];
  ]
  
  Pointeur= "Bonjour Pollux !";
  Pointeur?= Tableau?;                 : en C ça donnerait '*Pointeur= *Tableau' tout simplement :)
  exemple_de_paramètre= %111;          : et oui ! En Azur le format binaire est reconnu !
}

Et le fichier de sortie, 'azur_asm' (note bien que les commentaires c'est le compilo qui les a générés) :

; Generated by the Azur compiler
; Last revision : Nov  1 2001 (V 1.0)

 nolist
 lea      REGS_SVG(pc),a0 ; to avoid relocation bugs...
 movem.l  d0-a7,(a0)
 move.l   $C8,a6
 lea      AZUR_GLOBAL(pc),a5
 bsr      main
HALT_PROGRAM:
 movem.l  REGS_SVG(pc),d0-a7
 rts
REGS_SVG:
 ds.l     16

main: ;main
 ;exemple_de_paramètre via 8(a4)
 link     a4,#00036
 ;Pointeur via -4(a4)
 ;Tableau via -36(a4)
 lea      0(a5),a0
 move.l   a0,-4(a4)
 move.l   -4(a4),a3
 move.b   -36(a4),0(a3)
 move.l   #7,8(a4)
 unlk     a4
 rts

AZUR_GLOBAL:
 dc.b     "Bonjour Pollux !",0
 dc.b     0 ;even

[edit]Edité par Thibaut le 02-11-2001 à 12:12:19[/edit]

Tiens j'ai pas pensé, un petit exemple de transtypage implicite, en reprenant les mêmes variables : exemple_de_parametre= Pointeur?; donne :

 move.l   -4(a4),a3
 move.b   0(a3),d0
 ext.w    d0
 ext.l    d0
 move.l   d0,8(a4)

Si tu veux la bêta, y'a pas d'p

avec GTC :

void main(long p) {
	char *ptr,tbl[32];
	ptr="Bonjour Thibaut!";
	*ptr=*tbl;
	p=7;
}

donne:

L1:
	dc.b 66,111,110,106,111,117,114,32,84,104,105,98
	dc.b 97,117,116,33,0,0

	even
main:
	link	a6,#-36
	move.l	a2,-(a7)
	lea	L1(pc),a2
	move.b	-36(a6),(a2)
	move.l	#7,8(a6)
	move.l	(a7)+,a2
	unlk	a6
	rts

[edit]Edité par Pollux le 02-11-2001 à 15:50:09[/edit]

ben ouai je sais, j'ai comparé GTC et Azur depuis longtemps... J'ai bien dit que l'optimisation c'était presque zéro en Azur

A mon tour, 1 question : pour GTC tu as repris une partie d'une source déjà existante, ou tu as tout programmé de A à Z ?

>Thibaut: l'opérateur de permutation : '<>', qui produit un code de bas niveau bien plus efficace que ce qu'on obtiendrait avec l'équivalent C "a= b; b= c; c= a;"

On peut se passer de la variable c: b^=a;a^=b;b^=a;:

variables            a                         b
valeurs au début     a0                        b0
valeurs après b^=a;  a0                        b0^a0
valeurs après a^=b;  a0^(b0^a0)=(b0^a0)^a0=b0  b0^a0
valeurs après b^=a;  b0                        (b0^a0)^b0=(a0^b0)^b0=a0
valeurs finales      b0                        a0

(^ = XOR dans tout ceci)

Mais ce n'est pas très efficace non plus.

j'ai repris c68k de Matthew Brandt (comme Ontic), mais ça n'a plus gd chose à voir

Au fait, vous avez fait une compile: interpretation C + compilation as92 ou non..
parce que ce serait interessant de matter les sources une fois qu'on compile du C...

Oui nos compilateurs produisent du code ASM (comme l'immense majorité des progs qu'on nomme compilateurs ).
Celui de Pollux s'assemble avec AS692
Le mien s'assemble avec AS de Nitro.

Pollux : dans ce cas je comprend que GTC soit aussi avancé. Moi je suis parti de zéro, et sans la moindre connaissance sur les techniques de compilation. J'en ai appris des choses depuis t'1

Au fait Pollux, ça serait cool de répondre à tes mini-messages, même si la réponse est négative