Entrée de la chaîne de caractères dans le lexer flex

Question

Je veux créer une boucle de lecture-évaluation-impression en utilisant le parseur flex/bison. Le problème est que le lexer généré par flex veut une entrée de type FILE* et je voudrais qu'elle soit de type char*. Existe-t-il un moyen de faire cela ?

Une suggestion a été de créer un tube, de lui fournir la chaîne de caractères, d'ouvrir le descripteur de fichier et de l'envoyer au lexer. C'est assez simple, mais cela semble alambiqué et pas très indépendant de la plate-forme. Existe-t-il une meilleure solution ?

Answer 1

Les routines suivantes sont disponibles pour configurer les tampons d'entrée afin d'analyser les chaînes en mémoire au lieu des fichiers (comme le fait yy_create_buffer) :

• YY_BUFFER_STATE yy_scan_string(const char *str) : scanne une chaîne de caractères terminée par NUL``.
• YY_BUFFER_STATE yy_scan_bytes(const char *bytes, int len) : parcourt len octets (y compris éventuellement les NULs) en commençant par les octets d'emplacement.

Notez que ces deux fonctions créent, renvoient un handle YY_BUFFER_STATE correspondant (que vous devez supprimer avec yy_delete_buffer() quand vous en avez fini avec lui) afin que yylex() scanne une copie de la chaîne ou des octets. Ce comportement peut être souhaitable puisque yylex() modifie le contenu du tampon qu'il analyse).

Si vous voulez éviter la copie (et yy_delete_buffer) en utilisant :

• YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)

échantillon principal :

int main() {
    yy_scan_buffer("a test string");
    yylex();
}

Answer 2

Ver cet article du manuel Flex pour obtenir des informations sur la manière d'analyser les tampons en mémoire, tels que les chaînes de caractères.

Answer 3

flex peut analyser char * en utilisant l'une des trois fonctions suivantes : yy_scan_string() , yy_scan_buffer() y yy_scan_bytes() (voir le documentation ). Voici un exemple du premier :

typedef struct yy_buffer_state * YY_BUFFER_STATE;
extern int yyparse();
extern YY_BUFFER_STATE yy_scan_string(char * str);
extern void yy_delete_buffer(YY_BUFFER_STATE buffer);

int main(){
    char string[] = "String to be parsed.";
    YY_BUFFER_STATE buffer = yy_scan_string(string);
    yyparse();
    yy_delete_buffer(buffer);
    return 0;
}

Les déclarations équivalentes pour yy_scan_buffer() (qui nécessite une chaîne de caractères à double terminaison nulle) :

char string[] = "String to be parsed.\0";
YY_BUFFER_STATE buffer = yy_scan_buffer(string, sizeof(string));

Ma réponse reprend certaines des informations fournies par @dfa et @jlholland, mais le code d'aucune de leurs réponses ne semble fonctionner pour moi.

Answer 4

Voici ce que je devais faire :

extern yy_buffer_state;
typedef yy_buffer_state *YY_BUFFER_STATE;
extern int yyparse();
extern YY_BUFFER_STATE yy_scan_buffer(char *, size_t);

int main(int argc, char** argv) {

  char tstr[] = "line i want to parse\n\0\0";
  // note yy_scan_buffer is is looking for a double null string
  yy_scan_buffer(tstr, sizeof(tstr));
  yy_parse();
  return 0;
}

vous ne pouvez pas externaliser le typedef, ce qui est logique quand on y pense.

Answer 5

La réponse acceptée est incorrecte. Elle entraînera des fuites de mémoire.

En interne, yy_scan_string appelle yy_scan_bytes qui, à son tour, appelle yy_scan_buffer.

yy_scan_bytes alloue de la mémoire pour une COPIE du tampon d'entrée.

yy_scan_buffer travaille directement sur le tampon fourni.

Avec ces trois formes, vous DEVEZ appeler yy_delete_buffer pour libérer les informations sur l'état de la mémoire tampon flexible (YY_BUFFER_STATE).

Cependant, avec yy_scan_buffer, vous évitez l'allocation/copie/libération du tampon interne.

Le prototype de yy_scan_buffer ne prend PAS un const char* et vous NE DEVEZ PAS vous attendre à ce que le contenu reste inchangé.

Si vous avez alloué de la mémoire pour contenir votre chaîne, vous êtes responsable de la libérer APRÈS avoir appelé yy_delete_buffer.

N'oubliez pas non plus de faire en sorte que yywrap renvoie 1 (non nul) lorsque vous analysez JUST cette chaîne.

Vous trouverez ci-dessous un exemple COMPLET.

%%

<<EOF>> return 0;

.   return 1;

%%

int yywrap()
{
    return (1);
}

int main(int argc, const char* const argv[])
{
    FILE* fileHandle = fopen(argv[1], "rb");
    if (fileHandle == NULL) {
        perror("fopen");
        return (EXIT_FAILURE);
    }

    fseek(fileHandle, 0, SEEK_END);
    long fileSize = ftell(fileHandle);
    fseek(fileHandle, 0, SEEK_SET);

    // When using yy_scan_bytes, do not add 2 here ...
    char *string = malloc(fileSize + 2);

    fread(string, fileSize, sizeof(char), fileHandle);

    fclose(fileHandle);

    // Add the two NUL terminators, required by flex.
    // Omit this for yy_scan_bytes(), which allocates, copies and
    // apends these for us.   
    string[fileSize] = '\0';
    string[fileSize + 1] = '\0';

    // Our input file may contain NULs ('\0') so we MUST use
    // yy_scan_buffer() or yy_scan_bytes(). For a normal C (NUL-
    // terminated) string, we are better off using yy_scan_string() and
    // letting flex manage making a copy of it so the original may be a
    // const char (i.e., literal) string.
    YY_BUFFER_STATE buffer = yy_scan_buffer(string, fileSize + 2);

    // This is a flex source file, for yacc/bison call yyparse()
    // here instead ...
    int token;
    do {
        token = yylex(); // MAY modify the contents of the 'string'.
    } while (token != 0);

    // After flex is done, tell it to release the memory it allocated.    
    yy_delete_buffer(buffer);

    // And now we can release our (now dirty) buffer.
    free(string);

    return (EXIT_SUCCESS);
}