Wie zu verwenden yylval mit strings in yacc -

Möchte ich weitergeben der eigentliche string des Tokens. Wenn ich ein token namens ID, dann will ich meine yacc-Datei, um tatsächlich zu wissen, welche ID aufgerufen wird. Ich Sache, die ich haben, um einen string in yylval den yacc-Datei aus der flex-Datei. Wie mache ich das?

Bitte, mindestens Blick in die Dokumentation, bevor Sie eine Frage stellen hier.

InformationsquelleAutor neuromancer | 2009-12-05

6

Sehen die Flex-Handbuch Abschnitt auf die Verknüpfung mit YACC.
15 zusammenspiel mit Yacc

Eines der Hauptziele der flex ist als
Begleiter der yacc
parser-generator. yacc-Parser erwarten
zum Aufruf einer routine mit dem Namen yylex()
finden Sie die nächste Eingabe-token. Die routine
ist zurückgeben sollte, die Art der
nächste token als auch die anderen
zugehörigen Wert in der globalen yylval.
Verwenden flex und yacc, die man angibt
die `-d' option yacc zu beauftragen
um die Datei zu generieren y.tab.h
enthält Definitionen für alle
%Token, die in der yacc-Eingabe.
Diese Datei wird dann in die flex
scanner. Zum Beispiel, wenn einer der
Token ist TOK_NUMBER, Teil der
der scanner könnte so Aussehen:
```
     %{
     #include "y.tab.h"
     %}

     %%

     [0-9]+        yylval = atoi( yytext ); return TOK_NUMBER;
```
Dies erklärt nicht bei allen, wie man einen string zurückgeben, da YYSTYPE (hier nicht erwähnt) ist int standardmäßig.

InformationsquelleAutor

Den Schlüssel zum zurückgeben einer Zeichenfolge oder einer beliebigen komplexen Typ über yylval ist die YYSTYPE union erstellt yacc in der y -.tab.h-Datei. Die YYSTYPE ist eine union mit einem Mitglied für jede Art von token definiert, das yacc-Quelldatei. Zum Beispiel auf den string, verbunden mit einem SYMBOL token in den yacc-Quelldatei, die Sie erklären, dass diese YYSTYPE union mit %union in den yacc-Quelldatei:

/*** Yacc's YYSTYPE Union ***/

/* The yacc parser maintains a stack (array) of token values while
   it is parsing.  This union defines all the possible values tokens
   may have.  Yacc creates a typedef of YYSTYPE for this union. All
   token types (see %type declarations below) are taken from
   the field names of this union.  The global variable yylval which lex
   uses to return token values is declared as a YYSTYPE union.
 */

    %union {
        long int4;              /* Constant integer value */
        float fp;               /* Constant floating point value */
        char *str;              /* Ptr to constant string (strings are malloc'd) */
        exprT expr;             /* Expression -  constant or address */
        operatorT *operatorP;   /* Pointer to run-time expression operator */
    };

%type <str> SYMBOL

Dann in der LEX-Quelldatei gibt es ein Muster, das entspricht dem SYMBOL token. Es liegt in der Verantwortung der code zugeordnet ist, die Regel zurück die tatsächliche Zeichenfolge repräsentiert das SYMBOL. Sie können nicht nur übergeben Sie einen Zeiger auf die yytext Puffer, weil es einen statischen Puffer, der wiederverwendet wird für jedes token entspricht. Die Rückkehr der übereinstimmende text der statischen yytext Puffer muss repliziert werden auf dem heap mit _strdup() und einem Zeiger auf diesen string übergeben über yyval.str. Es ist dann die yacc-Regel, entspricht der SYMBOL-token in der Verantwortung frei heap zugewiesene Zeichenfolge, wenn es fertig ist.

[A-Za-z_][A-Za-z0-9_]*  {{
    int i;

    /*
    * condition letter followed by zero or more letters
    * digits or underscores
    *      Convert matched text to uppercase
    *      Search keyword table
    *      if found
    *          return <keyword>
    *      endif
    * 
    *      set lexical value string to matched text
    *      return <SYMBOL>
    */

    /*** KEYWORDS and SYMBOLS ***/
    /* Here we match a keywords or SYMBOL as a letter
    * followed by zero or more letters, digits or 
    * underscores.
    */

    /* Convert the matched input text to uppercase */
    _strupr(yytext);         /* Convert to uppercase */

    /* First we search the keyword table */
    for (i = 0; i<NITEMS(keytable); i++) {
        if (strcmp(keytable[i].name, yytext)==0)
            return (keytable[i].token);
    }

    /* Return a SYMBOL since we did not match a keyword */
    yylval.str=_strdup(yytext);
    return (SYMBOL);
}}

Super Antwort, dude, schöne und klare Erklärung.

InformationsquelleAutor JonN

3

Einrichten Kontext

Syntax-Analyse (um zu überprüfen ob ein input-text folgt einer festgelegten Grammatik) bestehen aus zwei Phasen:
1. tokenisierung, was getan wird, durch Werkzeuge wie lex oder flex, mit Schnittstelle yylex()) und
2. Analyse der Strom von token erzeugt, die in Schritt 1 ( als pro Benutzer angegebene Grammatik), der durchgeführt wird, durch tools wie bison/yacc mit der Schnittstelle yyparse()).
Während phase 1, gegeben einen input-stream, für jeden Aufruf von yylex() gibt ein token (char string) und yytext Punkte, um zum ersten Zeichen dieses Strings.Zum Beispiel: Bei einem input-stream von "int x = 10;" und mit lex-Regeln für die übersetzung in Token gemäß C-Sprache, die dann die ersten 5 Aufrufe yylex() erkennen Sie die folgenden 5 Token "int", "x", "=", "10", ";" und jedes mal, wenn die yytext zeigt auf das erste Zeichen der Rückkehr token.

Phase 2, Der parser (die du erwähnt hast wie yacc ) ist ein Programm, welches beim aufrufen dieser Funktion yylex jeder Zeit zu bekommen ein token und nutzt diese Token, um zu sehen, wenn es passt, die Regeln einer Grammatik. Diese Aufrufe yylex zurück tokens, da einige integer-codes. Zum Beispiel in dem vorherigen Beispiel, die ersten 5 Aufrufe yylex() zurückkehren können, die folgenden zahlen der parser: TYP, ID, EQ_OPERATOR und INTEGER ( deren eigentliche integer-Werte sind definiert in einigen header-Datei).

Nun alle parser sehen kann, ist diese integer-codes, die möglicherweise nicht nützlich sein, zu Zeiten. Zum Beispiel, in dem Beispiel können Sie zuordnen möchten, GEBEN Sie int ID, um einige Symboltabelle Zeiger und GANZZAHL dezimal 10. Um das zu erleichtern, jedes token zurückgegeben yylex mit im Zusammenhang mit einem anderen WERT, dessen Standard-Typ int, aber Sie können benutzerdefinierte Typen. In der lex Umgebung dieser WERT wird zugegriffen, als yylval.

Beispielsweise wieder als pro der Beispiel, yylex kann die folgende Regel zur Identifikation 10
```
[0-9]+   {  yylval.intval = atoi(yytext); return INTEGER; }
```
und nach zu identifizieren, x
```
[a-zA-Z][a-zA-Z0-9]*   {yylval.sym_tab_ptr = SYM_TABLE(yytext); return ID;}
```
Beachten Sie, dass hier habe ich definiert, wird der WERT ( oder yylval) geben Sie als union mit einer int (intval) und ein int* - Zeiger (sym_tab_ptr).

Aber in der yacc-Welt, ist dieser WERT identifiziert /abgerufen als $n. Betrachten Sie beispielsweise das folgende yacc-Regel zum identifizieren einer bestimmten Zuordnung Anweisung
```
TYPE ID '=' VAL:  { //In this action part of the yacc rule, use $2 to get the symbol table pointer associated with ID, use $4 to get decimal 10.}
```
, Deine Frage zu beantworten

Wenn Sie möchten, um Zugriff auf die yytext Wert einer bestimmten token (die mit lex Welt) in yacc Welt, Nutzung, Alter Freund WERT wie folgende:
1. Vermehren die union Art von WERT, fügen Sie ein anderes Feld aus, sagen wir char* lex_token_str
2. In die lex-Regel, yylval.lex_token_str = strdup(yytext)
3. Dann in yacc Welt den Zugriff auf das entsprechende $n.
4. In Fall, dass Sie Zugang zu mehr, dass ein einzelner Wert eines Tokens (zum Beispiel für die lex identifizierten token-ID, die der parser kann wollen, um den Zugriff auf den Namen und das symbol table pointer), dann vermehren sich die union Typ des WERTES mit einer Struktur, Mitglied, mit char* (für Namen) und int*(für symtab Zeiger).
InformationsquelleAutor Sandeep Dasgupta

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

15 zusammenspiel mit Yacc