Reprise du message précédent :

 
Le C n'est de toute façon pas parsable directment avec une grammaire LALR (même en faisant abstraction du préprocesseur, évidemment).

 
ah tiens ? me semblait pourtant avoir vu des grammaires yacc/bison pour le C.  
 
edit : A part le cast bien merdique a faire, y'a quoi de pas LALR1 dans le C ?
 
Anyway et dans tous les cas, c'est pas une raison pour faire une cochonnerie pareille

ouais mais bon, c'est trop quoi
c'est comme si kadreg disait: "comme je suis HEUREUX "

Je lui souhaite qu'un jour, il puisse le dire et le penser vraiment.

Bah, rien que les commentaires, t'as tout intérêt à les consommer à la main dès que tu trouves le /* d'ouverture, sinon t'es partir pour avoir une regexp de folie pour les définir.
Mais le C n'est pas déterministe: ta grammaire se change au fur et à mesure où tu parses (tu inclues les symboles dedans). Les .yacc ou .bison que tu as vu étaient là pour simplifier grandement le parsing, mais ce n'était pas du 100% LALR.
 
Kad simplifie un peu le fonctionnement de Gcc, mais ça reste vrai dans le fond. Dans la mesure où il y a un seul espace de nommage pour tout en C (stat est à la fois un type, un nom de fonction, et peut être un nom de variable ou de label), ça donne des trucs qui sont hyper dépendant du contexte (donc de la définition connue de chaque token). Si gcc ne sait pas ce qu'est un mot, il ne va donc même pas chercher à savoir ce que ça veut dire.  

Et, Bon Dieu de Merde, quelle etait l'idée geniale qui a pousser les concepteurs du C a n'autoriser les decls de variables qu'en debut de block ???

 
oué ca je sais, c'est comme ca que je fais. (D'ailleurs quitte a faire on peut meme rebricoler un coup le lexer pour qu'il accepte les commentaires imbriqués, ca coute pas cher et c'est pratique)
 

 
Ca par contre je comprends pas ?
 
si ma grammaire me dit (en gros)
 

 
bin elle change pas ? jbalance les symboles trouvés dans la table du meme nom, certes, mais je fais pas bouger ma grammaire (apres par contre je verifie tout ca soigneusement (ce que je dois faire de toute facon), mais apres seulement, une fois le parse fini)
 
 
 
 

ptain ya des gens balaise qd mm pour ecrire des compilos si javais un peu de temps jme ferais bien ca moi  

 
A (*p);
 
Ca peut être la déclaration d'une fonction p qui retourne un A,  
 
ou bien ça peut être l'appel de la fonction A en déréférencant p.

ouais mais voilà, pas en 1 mois quoi
 
(et puis va chier pour ton post qui mets toute ma crédibilité à la poubelle )
 
ps: je parle un peu gras non?

 
l'analyseur lexical du C sépare les tokens en utilisant "plus" que des expressions régulières???
 
remarque en C++ à cause des token "angle bracket" pour les templates, il sont peut être obligés de faire plus qu'un simple lexer à regex

Bah, si, en un mois ça me paraît crédible. Il peut se passer un tas de choses en un mois: un collègue a décidé de se marier avec une femme rencontrée 15 jours auparavant, ils sont toujours ensemble, ont une fille très intelligente (et prometteuse: veut faire ingénieur en informatique et un doctorat en maths)
 

Pas selon mes critères

 
fait gaffe on y perd rapidement sa sanity

 
Stun peu le meme souc que le cast, ca, non ?

b'jour

Oui, largement:
 - il mange les chaînes de caractères, et les commentaiers plutôt que de se taper des regexps à la con de 3 Kms
 - il utilise la table des symboles pour décider ce que chaque symbole est (sinon yacc n'en sortirait pas)
 - il utilise ça pour essayer de déméler un peu ce qui se passe et savoir si un mot est un type, un nom de fonction, une valeur, etc.
 
Typiquement, comme je l'ai dit, va faire un parser juste pour ça:
 

ha ha.

 
mais une déclaration n'est pas un "statement".
Une decl de fonction ne peut apparaitre dans un corps de fonction et au contraire un appel de fonction ne peut apparaitre que dans le corps d'un fonction.
Donc au priori le distingo decl/appel doit pouvoir se faire dans la grammaire non?
 
par ex:
 
global -> definitions de fonctions | declaration de fonctions | ...
 
definitions -> signature + corps  
 
corps -> ensemble de statements | statement
 
statement -> appel de fonction | ...

 
disons alors
 
A(*p)();
 
soit tu declares un ptr sur fonction, soit tu appeles A() en dereferencant P et tu rapelles ce que A te renvoie.
 

 
Tiens, j'ai pas répondu à ça.  
 
De cette manière, toutes tes variables sont en début de pile, et tu ne te fais pas chier à intercaler des push/pop pour ton code avec des push/pop pour tes données.  
 
En plus, ça te permet d'éviter des trucs vicieux à parser comme:
if (1)
  int j;
else if (int x)  
  int i;
 
Bref, le principe même du C, c'est que tout ce qui n'est pas une déclaration est une instruction, non ?
 
Donc, au prix d'une légère lourdeur syntaxique (devoir rajouter des blocks à la main), tu simplifies grandement la définition du langage.

 
moi je le trouve bien MySQL, suffit de pas s'en servir betement  

 
bin la, pas trop d'accord, vu que j'ai le droit d'ecrire :
 

 
la difference entre ca et  
 

 
ne me saute pas trop aux yeux ?
(en plus bon, de ce que j'ai lu et de ce que j'ai fait, un compilo rajoute une chié de var temporaire a chaque expression. La != entre var temporaire et var de l'utilisateur n'existe pas, ou peu (genre pour le debug))
 
 
 
 

 
ouais c'est vrai que déjà à cause de ça il faut faire un lookup dans la tables des fonctions déjà définies.

une chiéE

skoi ce smiley tout moche qui merite a peine le nom 'smiley'

 
raconte

Et tu justifies d'ailleurs par là même l'existence de l'opérateur ternaire: tu as le droit d'appeller des fonctions, mais tu ne peux pas mettre de blocs ou de structure dans ta déclaration.  
Donc:

mais pas:

 
M'enfin, je suis très très loin d'être un spécialiste, je sais juste que c'est très dur, et qu'il y a plein de complications, c'est tout.  
Pour le reste, vous demandez à Kad ou Taz, ou vous allez sur usenet, sur fr.comp.lang.c++.  

oui mais la non, ton message sert à rien et ton smiley est ultramoche (genre pire que le mien)
 

C'est le mien

KQMOUASLLOOOSKKK §§ç@#!!&!

 
d'accord mais ca repond pas a ma question

 
sale fourbe, tu as efface ton post

j'lai quoté  
 
le drap nettoyé, les traces restent quand même

Bah oui, je sais, et c'est pas pour rien que le C++ rajoute ça. Moi je te donnes juste des raisons historiques. Au niveau du parser, si tu peux avoir la garantie qu'il n'y a pas de déclaration de variable dans un bloc complexe (ainsi que la réciproque), alors tu t'enlève une jolie épine du pied.  
 
D'autre part, ça te permet de connaître efficacement la position de chaque variable par rapport au début du cadre de pile (en ASM: push ESP dans l'appellant, POP EBP dans l'appellé, ou un truc dans le genre). Tu sais que la variable a sera toujours à EBP+4, et b sera toujours à EBP+6, indépendemment des calculs en cours, de l'appel de fonctions ou autres. Alors que en déclarant au milieu de ton code, tu n'as pas la garantie que tu n'as pas déjà empilé une dizaine de registres pour faire un calcul compliqué. Ca t'oblige alors à reserver de l'espace pour la future variable.

au s'cours, quoi.