yyparse imprime une patte principale

Question

Dans mon bison / programme flex, juste après yyparse () est appelée, un onglet de premier plan est imprimé, mais je ne sais pas pourquoi. Pouvez-vous voir ce qui ne va pas?

appelle le code du bison, et à droite après le retour de yyparse (), un onglet est imprimé.

void parseArguments(int argc, char** argv)
130 {
131     int i;
132 
133     int sum = 0;
134     // calculate the length of buffer we need
135     for(i = 1; i < argc; i++)
136     {
137         sum += strlen(argv[i]) + 1;
138     }
139 
140     if(sum <= 0)
141         return;
142 
143     // make us a buffer and zero it out
144     char tempBuffer[sum];
145     memset(tempBuffer, 0, sum);
146 
147     // pointer to walk through our buffer
148     int pos = 0;
149 
150     // copy arguments into the buffer
151     for(i = 1; i < argc; i++)
152     {
153         memcpy(tempBuffer+pos, argv[i], strlen(argv[i]));
154         pos += strlen(argv[i]);
155         sprintf(tempBuffer+pos++, " ");
156     }
157 
158     // give our arguments to lex for parsing
159     configBuffer(tempBuffer);
160 


// use bison parsing
163     int returnVal = yyparse(); // after this returns a tab character has been printed


164     if(returnVal != 0)                                                                                            
   165     {   
   166         printf("yyparse failed!\n");                                                                              
   167     }                                                                                                             
   168     

Toutes mes règles de bison ne sont que des expressions régulières jumelé avec une déclaration de retour. Le seul code d'intérêt pour le bison que je pouvais voir affecter ce serait ceci:

64 %%
 65 void configBuffer(char* arguments)
 66 {
 67 #ifdef DEBUG
 68     printf("Given the buffer: %s\n", arguments);
 69 #endif
 70     yy_delete_buffer(YY_CURRENT_BUFFER);
 71 
 72     yy_scan_string(arguments);
 73 }

J'ai essayé les suggestions données par plusieurs personnes, mais toujours pas de chance. Voici mon fichier complet flex:

%{
#include <string.h>
#include "CommandParser.tab.h"
%}

%%

\t {
    printf("TAB!\n");
}

" " {
    printf("SPACE!\n");
}

\n {
    return;
}

-p {
    return PRINTMODE; 
}

-x {
    return XORMODE;
}

-n {
    return NOTMODE;
}

-a {
    return ANDMODE;
}

-o {
    return ORMODE;
}

-r {
    return RANGEFLAG;
}

-l {
    return LENGTHFLAG;
}

0[xX][0-9a-fA-F]+ {
    int retVal = sscanf(yytext, "%x",&(yylval.int_val));
    if(retVal != 1)
        return;
    return NUMBER;
}

[0-9]+ {
    yylval.int_val = atoi(yytext);
    return NUMBER;
}

['"].*+['"] {
    yylval.string_val = strdup(yytext);
    return ARGUMENT;
}

[^ \t\n]+ {
    yylval.string_val = strdup(yytext);
    return ARGUMENT;
}


%%
void configBuffer(char* arguments)
{
#define DEBUG
#ifdef DEBUG
    printf("Given the buffer: %s:\n", arguments);
#endif
    yy_delete_buffer(YY_CURRENT_BUFFER);
    yy_scan_string(arguments);

}

Answer 1

est l'onglet non traitées en vous lexer et donc la mise en correspondance de règles par défaut et est appliquée en écho?

Mettre un match supplémentaire

\t { printf("TAB"); }

dans le code avant votre section de code final.

si cela montre TAB au lieu de \ t, puis tournez la printf dans une déclaration vide

\t { /*printf("TAB")*/; }

Après l'affichage Modifier lex:

Ok, après avoir testé votre lex il semblerait que vous correspondre correctement les choses.

J'ai utilisé ce code pour tester

#include <stdio.h>
#include "CommandParser.tab.h"

YYSTYPE yylval;

int main(int argc, char* argv[])
{
    while(1)
    {
        printf("lex:%d\r\n",yylex());
    }
    return 0;
}

extern "C" int yywrap();

int yywrap ()
{
    return 1;
}

Donc, avec l'entrée (via stdin)

-a<\ >-x<\t>-p<space>-c<\r>

Je reçois

lex:103
SPACE!
lex:101
TAB!
lex:100
SPACE!
lex:108
lex:3

pour ce fichier d'en-tête

#define PRINTMODE   100
#define XORMODE     101
#define NOTMODE     102
#define ANDMODE     103
#define ORMODE      104
#define LENGTHFLAG  105
#define RANGEFLAG   106
#define NUMBER      107
#define ARGUMENT    108
#define DEFUALT     0

typedef union {
    int int_val;
    char* string_val;
} YYSTYPE;

#ifdef __cplusplus
extern "C" int yylex();

extern "C" YYSTYPE yylval;
#else // __cplusplus
extern YYSTYPE yylval;
#endif // __cplusplus

Alors ce que je vais essayer de remplacer le prochain est avec ce code yyparse et voyez ce que vous obtenez.

while(1)
{
    printf("lex:%d\r\n",yylex());
}

Si vous obtenez toujours l'onglet, il est en quelque sorte imprimé vous lexer, sinon il est en quelque sorte votre analyseur / programme principal.

Pour le savoir je remplacer le bâtiment de chaîne magique que vous faites avec un const string, et voir ce qui se passe dans ce cas. Fondamentalement, la recherche binaire votre code pour trouver le point de problème.