IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Autres éditeurs Discussion :

Erreur dans un fichier Yacc


Sujet :

Autres éditeurs

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    20
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 20
    Points : 19
    Points
    19
    Par défaut Erreur dans un fichier Yacc
    Bonjour à tous,

    Je débute en informatique/programmation.
    Je travaille sur un fichier .y (Yacc), et à la compilation de celui_ci (yacc fichier.y), j' ai cette erreur:
    conflicts: 1 shift/reduce
    Je n' arrive pas à trouver d' où elle vient... Je crois qu' elle signifie que le code peut etre interpreté de plusieurs façon, mais je ne sais même pas à quelle ligne!

    Si vous savez comment procéder pour trouver la ligne erronée, je vous en remercie d' avance !
    Voici la partie grammaire du .y pour ceux que ça interessent:



    %token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
    %token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
    %token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
    %token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
    %token XOR_ASSIGN OR_ASSIGN TYPE_NAME

    %token TYPEDEF EXTERN STATIC AUTO REGISTER
    %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
    %token STRUCT UNION ENUM ELLIPSIS

    %token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN

    %start translation_unit
    %%

    primary_expression
    : IDENTIFIER
    | CONSTANT
    | STRING_LITERAL
    | '(' expression ')'
    ;

    postfix_expression
    : primary_expression
    | postfix_expression '[' expression ']'
    | postfix_expression '(' ')'
    | postfix_expression '(' argument_expression_list ')'
    | postfix_expression '.' IDENTIFIER
    | postfix_expression PTR_OP IDENTIFIER
    | postfix_expression INC_OP
    | postfix_expression DEC_OP
    ;

    argument_expression_list
    : assignment_expression
    | argument_expression_list ',' assignment_expression
    ;

    unary_expression
    : postfix_expression
    | INC_OP unary_expression
    | DEC_OP unary_expression
    | unary_operator cast_expression
    | SIZEOF unary_expression
    | SIZEOF '(' type_name ')'
    ;

    unary_operator
    : '&'
    | '*'
    | '+'
    | '-'
    | '~'
    | '!'
    ;

    cast_expression
    : unary_expression
    | '(' type_name ')' cast_expression
    ;

    multiplicative_expression
    : cast_expression
    | multiplicative_expression '*' cast_expression
    | multiplicative_expression '/' cast_expression
    | multiplicative_expression '%' cast_expression
    ;

    additive_expression
    : multiplicative_expression
    | additive_expression '+' multiplicative_expression
    | additive_expression '-' multiplicative_expression
    ;

    shift_expression
    : additive_expression
    | shift_expression LEFT_OP additive_expression
    | shift_expression RIGHT_OP additive_expression
    ;

    relational_expression
    : shift_expression
    | relational_expression '<' shift_expression
    | relational_expression '>' shift_expression
    | relational_expression LE_OP shift_expression
    | relational_expression GE_OP shift_expression
    ;

    equality_expression
    : relational_expression
    | equality_expression EQ_OP relational_expression
    | equality_expression NE_OP relational_expression
    ;

    and_expression
    : equality_expression
    | and_expression '&' equality_expression
    ;

    exclusive_or_expression
    : and_expression
    | exclusive_or_expression '^' and_expression
    ;

    inclusive_or_expression
    : exclusive_or_expression
    | inclusive_or_expression '|' exclusive_or_expression
    ;

    logical_and_expression
    : inclusive_or_expression
    | logical_and_expression AND_OP inclusive_or_expression
    ;

    logical_or_expression
    : logical_and_expression
    | logical_or_expression OR_OP logical_and_expression
    ;

    conditional_expression
    : logical_or_expression
    | logical_or_expression '?' expression ':' conditional_expression
    ;

    assignment_expression
    : conditional_expression
    | unary_expression assignment_operator assignment_expression
    ;

    assignment_operator
    : '='
    | MUL_ASSIGN
    | DIV_ASSIGN
    | MOD_ASSIGN
    | ADD_ASSIGN
    | SUB_ASSIGN
    | LEFT_ASSIGN
    | RIGHT_ASSIGN
    | AND_ASSIGN
    | XOR_ASSIGN
    | OR_ASSIGN
    ;

    expression
    : assignment_expression
    | expression ',' assignment_expression
    ;

    constant_expression
    : conditional_expression
    ;

    declaration
    : declaration_specifiers ';'
    | declaration_specifiers init_declarator_list ';'
    ;

    declaration_specifiers
    : storage_class_specifier
    | storage_class_specifier declaration_specifiers
    | type_specifier
    | type_specifier declaration_specifiers
    | type_qualifier
    | type_qualifier declaration_specifiers
    ;

    init_declarator_list
    : init_declarator
    | init_declarator_list ',' init_declarator
    ;

    init_declarator
    : declarator
    | declarator '=' initializer
    ;

    storage_class_specifier
    : TYPEDEF
    | EXTERN
    | STATIC
    | AUTO
    | REGISTER
    ;

    type_specifier
    : VOID
    | CHAR
    | SHORT
    | INT
    | LONG
    | FLOAT
    | DOUBLE
    | SIGNED
    | UNSIGNED
    | struct_or_union_specifier
    | enum_specifier
    | TYPE_NAME
    ;

    struct_or_union_specifier
    : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
    | struct_or_union '{' struct_declaration_list '}'
    | struct_or_union IDENTIFIER
    ;

    struct_or_union
    : STRUCT
    | UNION
    ;

    struct_declaration_list
    : struct_declaration
    | struct_declaration_list struct_declaration
    ;

    struct_declaration
    : specifier_qualifier_list struct_declarator_list ';'
    ;

    specifier_qualifier_list
    : type_specifier specifier_qualifier_list
    | type_specifier
    | type_qualifier specifier_qualifier_list
    | type_qualifier
    ;

    struct_declarator_list
    : struct_declarator
    | struct_declarator_list ',' struct_declarator
    ;

    struct_declarator
    : declarator
    | ':' constant_expression
    | declarator ':' constant_expression
    ;

    enum_specifier
    : ENUM '{' enumerator_list '}'
    | ENUM IDENTIFIER '{' enumerator_list '}'
    | ENUM IDENTIFIER
    ;

    enumerator_list
    : enumerator
    | enumerator_list ',' enumerator
    ;

    enumerator
    : IDENTIFIER
    | IDENTIFIER '=' constant_expression
    ;

    type_qualifier
    : CONST
    | VOLATILE
    ;

    declarator
    : pointer direct_declarator
    | direct_declarator
    ;

    direct_declarator
    : IDENTIFIER
    | '(' declarator ')'
    | direct_declarator '[' constant_expression ']'
    | direct_declarator '[' ']'
    | direct_declarator '(' parameter_type_list ')'
    | direct_declarator '(' identifier_list ')'
    | direct_declarator '(' ')'
    ;

    pointer
    : '*'
    | '*' type_qualifier_list
    | '*' pointer
    | '*' type_qualifier_list pointer
    ;

    type_qualifier_list
    : type_qualifier
    | type_qualifier_list type_qualifier
    ;


    parameter_type_list
    : parameter_list
    | parameter_list ',' ELLIPSIS
    ;

    parameter_list
    : parameter_declaration
    | parameter_list ',' parameter_declaration
    ;

    parameter_declaration
    : declaration_specifiers declarator
    | declaration_specifiers abstract_declarator
    | declaration_specifiers
    ;

    identifier_list
    : IDENTIFIER
    | identifier_list ',' IDENTIFIER
    ;

    type_name
    : specifier_qualifier_list
    | specifier_qualifier_list abstract_declarator
    ;

    abstract_declarator
    : pointer
    | direct_abstract_declarator
    | pointer direct_abstract_declarator
    ;

    direct_abstract_declarator
    : '(' abstract_declarator ')'
    | '[' ']'
    | '[' constant_expression ']'
    | direct_abstract_declarator '[' ']'
    | direct_abstract_declarator '[' constant_expression ']'
    | '(' ')'
    | '(' parameter_type_list ')'
    | direct_abstract_declarator '(' ')'
    | direct_abstract_declarator '(' parameter_type_list ')'
    ;

    initializer
    : assignment_expression
    | '{' initializer_list '}'
    | '{' initializer_list ',' '}'
    ;

    initializer_list
    : initializer
    | initializer_list ',' initializer
    ;

    statement
    : labeled_statement
    | compound_statement
    | expression_statement
    | selection_statement
    | iteration_statement
    | jump_statement
    ;

    labeled_statement
    : IDENTIFIER ':' statement
    | CASE constant_expression ':' statement
    | DEFAULT ':' statement
    ;

    compound_statement
    : '{' '}'
    | '{' statement_list '}'
    | '{' declaration_list '}'
    | '{' declaration_list statement_list '}'
    ;

    declaration_list
    : declaration
    | declaration_list declaration
    ;

    statement_list
    : statement
    | statement_list statement
    ;

    expression_statement
    : ';'
    | expression ';'
    ;

    selection_statement
    : IF '(' expression ')' statement
    | IF '(' expression ')' statement ELSE statement
    | SWITCH '(' expression ')' statement
    ;

    iteration_statement
    : WHILE '(' expression ')' statement
    | DO statement WHILE '(' expression ')' ';'
    | FOR '(' expression_statement expression_statement ')' statement
    | FOR '(' expression_statement expression_statement expression ')' statement
    ;

    jump_statement
    : GOTO IDENTIFIER ';'
    | CONTINUE ';'
    | BREAK ';'
    | RETURN ';'
    | RETURN expression ';'
    ;

    translation_unit
    : external_declaration
    | translation_unit external_declaration
    ;

    external_declaration
    : function_definition
    | declaration
    ;

    function_definition
    : declaration_specifiers declarator declaration_list compound_statement
    | declaration_specifiers declarator compound_statement
    | declarator declaration_list compound_statement
    | declarator compound_statement
    ;

    %%
    #include <stdio.h>

    extern char yytext[];
    extern int column;

    yyerror(s)
    char *s;
    {
    fflush(stdout);
    printf("\n%*s\n%*s\n", column, "^", column, s);
    }
    a bientot

  2. #2
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Points : 15 920
    Points
    15 920
    Par défaut
    Hum ben finalement tu l'as trouvée ta grammaire C

    Ta grammaire est trop longue pour que je regarde en détail, mais si ça peut t'aider, le conflit shift / reduce se produit effectivement lorsque l'analyseur a deux choix : soit reconnaître le motif courant, soit continuer. En gros, tu as une séquence qui constitue le débtut d'une autre séquence. Par exemple "chat" et "chateau".

    Enfin si mes souvenirs sont bons...

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    20
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 20
    Points : 19
    Points
    19
    Par défaut grammaire du C: erreur Yacc
    Et je l'ai trouvé, mais avec des erreurs... donc si je pouvais en avoir une autre sans erreurs, ou reussir à corriger celle qui s'est glissée dans la grammaire ci-dessus ce serait super ( car apparement, il n'y en a qu'une)...

    a bientot

  4. #4
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    20
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 20
    Points : 19
    Points
    19
    Par défaut voia l'erreur
    selection_statement
    : IF '(' expression ')' statement
    | IF '(' expression ')' statement ELSE statement
    | SWITCH '(' expression ')' statement
    ;
    l'erreur qui provoque un "conflits"... (if..if..else)
    Mais en fait , cela n'empeche pas la compilation de créer comme il se doit, un fichier .c et .h

    Il faut simplement trouvr si le else fait référence au premier if ou au deuxième ou n ieme (soit le dernier)...

    a bientot

  5. #5
    Membre averti

    Profil pro
    Inscrit en
    Avril 2004
    Messages
    289
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 289
    Points : 342
    Points
    342
    Par défaut Re: voia l'erreur
    Citation Envoyé par gRaNdLeMuRieN
    Il faut simplement trouvr si le else fait référence au premier if ou au deuxième ou n ieme (soit le dernier)...
    Citation Envoyé par la norme C99, 6.8.4.1-3
    An else is associated with the lexically nearest preceding if that is allowed by the syntax.

  6. #6
    Membre averti
    Profil pro
    Inscrit en
    Août 2005
    Messages
    417
    Détails du profil
    Informations personnelles :
    Âge : 73
    Localisation : France

    Informations forums :
    Inscription : Août 2005
    Messages : 417
    Points : 372
    Points
    372
    Par défaut
    Règle: un conflit de type shift/reduce peut toujours être résolu par une règle de précédence/association, c'est à dire une déclaration du type %left, %right ou %nonassoc, or je n'en vois aucune dans le fichier proposé. Eventuellement d'ailleurs, il est parfois nécessaire d'ajouter un niveau de précédence explicite sur une règle (en général exempte de symbole terminal) à l'aide de %prec.

    Par ailleurs, le compilateur YACC (pour ma part, j'utilise BISON) produit un fichier ?.output dans lequel tous les conflits sont soigneusement répertoriés. Il suffit de rechercher les crochets [ pour les trouver. Il y est indiqué quelle règle entre en conflit avec quel token. Généralement c'est très facile à corriger. La difficulté étant plutôt de décider de la façon de régler les précédences. Le conflit reduce/reduce par contre est beaucoup plus difficile à régler en général, et peut relever d'un excès de symboles non terminaux, c'est à dire d'un défaut de conception de la gammaire.

    Cordialement.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Erreur dans le fichier de lancement
    Par sboober dans le forum JWS
    Réponses: 2
    Dernier message: 14/04/2009, 18h41
  2. erreur dans un fichier include
    Par gandf dans le forum Delphi
    Réponses: 6
    Dernier message: 04/04/2007, 16h28
  3. erreur dans un fichier include
    Par gandf dans le forum C++Builder
    Réponses: 3
    Dernier message: 02/04/2007, 15h44
  4. [C#] Comment serializer l'écriture des erreurs dans un fichier
    Par LE NEINDRE dans le forum Windows Forms
    Réponses: 9
    Dernier message: 17/11/2006, 15h54
  5. [Servlet] Erreur dans le fichier web.xml
    Par Crazyblinkgirl dans le forum Servlets/JSP
    Réponses: 4
    Dernier message: 05/07/2004, 16h20

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo