Qual è la differenza tra un token e un lexeme?

In Compiler Construction di Aho Ullman e Sethi, è dato che la stringa di caratteri di input del programma sorgente è divisa in sequenze di caratteri che hanno un significato logico, e sono conosciuti come token e lessemi sono sequenze che compongono il token quindi cosa è la differenza fondamentale?

Utilizzando " Compilers Principles, Techniques, & Tools, 2nd Ed. " (WorldCat) di Aho, Lam, Sethi e Ullman, AKA the Purple Dragon Book ,

Lexeme pag. 111

Un lessema è una sequenza di caratteri nel programma sorgente che corrisponde al modello di un token ed è identificato dall'analizzatore lessicale come un'istanza di quel token.

Token pag. 111

Un token è una coppia composta da un nome token e un valore di attributo opzionale. Il nome del token è un simbolo astratto che rappresenta una sorta di unità lessicale, ad esempio una particolare parola chiave o una sequenza di caratteri di input che denota un identificatore. I nomi dei token sono i simboli di input elaborati dal parser.

Modello pag. 111

Un pattern è una descrizione della forma che possono assumere i lessemi di un token. Nel caso di una parola chiave come token, il modello è solo la sequenza di caratteri che formano la parola chiave. Per gli identificatori e alcuni altri token, il modello è una struttura più complessa a cui corrispondono molte stringhe.

Figura 3.2: Esempi di token pag.112

[Token]       [Informal Description]                  [Sample Lexemes]
if            characters i, f                         if
else          characters e, l, s, e                   else
comparison    < or > or <= or >= or == or !=          <=, !=
id            letter followed by letters and digits   pi, score, D2
number        any numeric constant                    3.14159, 0, 6.02e23
literal       anything but ", surrounded by "'s       "core dumped"

Per comprendere meglio questa relazione con un lexer e un parser, inizieremo con il parser e lavoreremo a ritroso sull'input.

Per rendere più semplice la progettazione di un parser, un parser non funziona direttamente con l'input ma accetta un elenco di token generati da un lexer. Osservando la colonna gettone nella Figura 3.2 vediamo token come if, else, comparison, id, numbereliteral ; questi sono nomi di gettoni. Tipicamente con un lexer / parser un token è una struttura che contiene non solo il nome del token, ma i caratteri / simboli che compongono il token e la posizione iniziale e finale della stringa di caratteri che compone il token, con il posizione iniziale e finale utilizzata per la segnalazione degli errori, l'evidenziazione, ecc.

Ora il lexer prende l'input di caratteri / simboli e usando le regole del lexer converte i caratteri / simboli in input in token. Ora le persone che lavorano con lexer / parser hanno le loro parole per cose che usano spesso. Ciò che pensi come una sequenza di caratteri / simboli che compongono un token sono ciò che le persone che usano lexer / parser chiamano lexeme. Quindi, quando vedi lessema, pensa a una sequenza di caratteri / simboli che rappresentano un token. Nell'esempio di confronto, la sequenza di caratteri / simboli può essere diversi modelli come <o >o elseo 3.14, ecc.

Un altro modo per pensare alla relazione tra i due è che un token è una struttura di programmazione utilizzata dal parser che ha una proprietà chiamata lexeme che contiene il carattere / simboli dall'input. Ora se guardi la maggior parte delle definizioni di token nel codice potresti non vedere lexeme come una delle proprietà del token. Questo perché è più probabile che un token manterrà la posizione iniziale e finale dei caratteri / simboli che rappresentano il token e il lessema, la sequenza di caratteri / simboli può essere derivata dalla posizione iniziale e finale secondo necessità perché l'input è statico.

Quando un programma sorgente viene inserito nell'analizzatore lessicale, inizia suddividendo i caratteri in sequenze di lessemi. I lessemi vengono quindi utilizzati nella costruzione di token, in cui i lessemi vengono mappati in token. Una variabile chiamata myVar verrebbe mappata in un token che dichiara < id , "num">, dove "num" dovrebbe puntare alla posizione della variabile nella tabella dei simboli.

In breve:

• I lessemi sono le parole derivate dal flusso di input dei caratteri.
• I token sono lessemi mappati in un nome-token e un valore-attributo.

Un esempio include:
x = a + b * 2
che restituisce i lessemi: {x, =, a, +, b, *, 2}
con i token corrispondenti: {< id , 0>, <=>, < id , 1 >, <+>, < id , 2>, <*>, < id , 3>}

a) I token sono nomi simbolici per le entità che compongono il testo del programma; ad esempio if per la parola chiave if e id per qualsiasi identificatore. Questi costituiscono l'output dell'analizzatore lessicale. 5

(b) Un pattern è una regola che specifica quando una sequenza di caratteri dall'input costituisce un token; es. la sequenza i, f per il token if, e qualsiasi sequenza di caratteri alfanumerici che iniziano con una lettera per il token id.

(c) Un lessema è una sequenza di caratteri dall'input che corrispondono a un modello (e quindi costituiscono un'istanza di un token); per esempio if corrisponde al pattern per if, e foo123bar corrisponde al pattern per id.

LEXEME - Sequenza di caratteri abbinati da PATTERN che formano il TOKEN

PATTERN - L'insieme di regole che definiscono un TOKEN

TOKEN - La raccolta significativa di caratteri sul set di caratteri del linguaggio di programmazione, ad es .: ID, costante, parole chiave, operatori, punteggiatura, stringa letterale

Lexeme : un lessema è una sequenza di caratteri nel programma sorgente che corrisponde al modello di un token ed è identificato dall'analizzatore lessicale come un'istanza di quel token.

Token : il token è una coppia composta da un nome di token e un valore di token opzionale. Il nome del token è una categoria di un'unità lessicale, i nomi comuni del token sono

• identificatori: nomi scelti dal programmatore
• parole chiave: nomi già presenti nel linguaggio di programmazione
• separatori (noti anche come punteggiatura): caratteri di punteggiatura e delimitatori accoppiati
• operatori: simboli che operano su argomenti e producono risultati
• letterali: numerici, logici, testuali, letterali di riferimento

Considera questa espressione nel linguaggio di programmazione C:

somma = 3 + 2;

Tokenizzato e rappresentato dalla seguente tabella:

 Lexeme        Token category
------------------------------
sum      |    Identifier
 =       |    Assignment operator
 3       |    Integer literal
 +       |    Addition operator
 2       |    Integer literal
 ;       |    End of statement

Vediamo il funzionamento di un analizzatore lessicale (chiamato anche Scanner)

Facciamo un'espressione di esempio:

INPUT : cout << 3+2+3;

FORMATTING PERFORMED BY SCANNER :  {cout}|space|{<<}|space|{3}{+}{2}{+}{3}{;} 

non l'output effettivo però.

LO SCANNER CERCA SEMPLICEMENTE RIPETUTAMENTE UN LEXEME NEL TESTO DEL PROGRAMMA SORGENTE FINO A QUANDO L'INPUT NON È ESAURITO

Lexeme è una sottostringa di input che forma una stringa di terminali valida presente nella grammatica. Ogni lessema segue uno schema che viene spiegato alla fine (la parte che il lettore può finalmente saltare)

(La regola importante è cercare il prefisso più lungo possibile che formi una stringa di terminali valida fino a quando non si incontra il successivo spazio bianco ... spiegato di seguito)

LEXEMES:

1. cout
2. <<

(sebbene "<" sia anche una stringa di terminale valida, ma la regola sopra menzionata deve selezionare il modello per lexeme "<<" al fine di generare il token restituito dallo scanner)

3. 3
4. +
5. 2
6. ;

TOKENS: i token vengono restituiti uno alla volta (da Scanner quando richiesto da Parser) ogni volta che Scanner trova un lessema (valido). Scanner crea, se non già presente, una voce di tabella dei simboli (avente attributi: principalmente token-category e pochi altri) , quando trova un lessema, per generarne il token

'#' denota una voce della tabella dei simboli. Ho indicato il numero del lessema nell'elenco sopra per facilità di comprensione, ma tecnicamente dovrebbe essere l'indice di record effettivo nella tabella dei simboli.

I seguenti token vengono restituiti dallo scanner al parser nell'ordine specificato per l'esempio precedente.

1. <identificatore, # 1>

2. <Operatore, # 2>

3. <Letterale, # 3>

4. <Operatore, # 4>

5. <Letterale, # 5>

6. <Operatore, # 4>

7. <Letterale, # 3>

8. <Punctuator, # 6>

Come puoi vedere la differenza, un token è una coppia a differenza del lessema che è una sottostringa di input.

E il primo elemento della coppia è la classe / categoria del token

Le classi di token sono elencate di seguito:

E ancora una cosa, Scanner rileva gli spazi bianchi, li ignora e non forma alcun segno per uno spazio bianco. Non tutti i delimitatori sono spazi bianchi, uno spazio bianco è una forma di delimitatore utilizzata dagli scanner per il suo scopo. Tabulazioni, Newline, Spazi, Caratteri di escape in input sono tutti chiamati collettivamente delimitatori di spazi bianchi. Pochi altri delimitatori sono ";" ',' ':' ecc, che sono ampiamente riconosciuti come lessemi che formano token.

Il numero totale di token restituiti qui è 8, tuttavia per i lessemi vengono inserite solo 6 voci nella tabella dei simboli. Anche i lessemi sono 8 in totale (vedere la definizione di lessema)

--- Puoi saltare questa parte

A ***pattern*** is a rule ( say, a regular expression ) that is used to check if a string-of-terminals is valid or not.

If a substring of input composed only of grammar terminals is following the rule specified by any of the listed patterns , it is validated as a lexeme and selected pattern will identify the category of lexeme, else a lexical error is reported due to either (i) not following any of the rules or (ii) input consists of a bad terminal-character not present in grammar itself.

for example :

1. No Pattern Exists : In C++ , "99Id_Var" is grammar-supported string-of-terminals but is not recognised by any of patterns hence lexical error is reported .

2. Bad Input Character : $,@,unicode characters may not be supported as a valid character in few programming languages.`

Lexeme - Un lessema è una stringa di caratteri che è l'unità sintattica di livello più basso nel linguaggio di programmazione.

Token - Il token è una categoria sintattica che forma una classe di lessemi, il che significa a quale classe appartiene il lessema è una parola chiave o un identificatore o qualsiasi altra cosa. Uno dei compiti principali dell'analizzatore lessicale è creare una coppia di lessemi e gettoni, ovvero raccogliere tutti i caratteri.

Facciamo un esempio:-

se (y <= t)

y = y-3;

Token Lexeme

se PAROLA CHIAVE

(PARENTESI SINISTRA

y IDENTIFICATORE

<= CONFRONTO

t IDENTIFICATORE

) GIUSTA PARENTESI

y IDENTIFICATORE

= ASSEGNAZIONE

y IDENTIFICATORE

_ ARITMATICO

3 INTERO

;                                    PUNTO E VIRGOLA

Relazione tra Lexeme e Token

Token: il tipo di (parole chiave, identificatore, carattere di punteggiatura, operatori multi-carattere) è, semplicemente, un token.

Pattern: una regola per la formazione di token da caratteri di input.

Lexeme: è una sequenza di caratteri nel PROGRAMMA SORGENTE abbinati a uno schema per un token. Fondamentalmente, è un elemento di Token.

Token: Token è una sequenza di caratteri che può essere trattata come una singola entità logica. I token tipici sono:
1) Identificatori
2) parole chiave
3) operatori
4) simboli speciali
5) costanti

Pattern: un insieme di stringhe nell'input per le quali viene prodotto lo stesso token come output. Questo insieme di stringhe è descritto da una regola chiamata pattern associata al token.
Lexema: un lessema è una sequenza di caratteri nel programma di origine che corrisponde al modello per un token.

Lexeme Si dice che i lessemi siano una sequenza di caratteri (alfanumerici) in un token.

Gettone Un token è una sequenza di caratteri che può essere identificata come una singola entità logica. Tipicamente i token sono parole chiave, identificatori, costanti, stringhe, simboli di punteggiatura, operatori. numeri.

Pattern Un insieme di stringhe descritte dalla regola chiamata pattern. Un pattern spiega cosa può essere un token e questi pattern sono definiti tramite espressioni regolari, che sono associate al token.

I ricercatori di CS, come quelli di Math, amano creare termini "nuovi". Le risposte sopra sono tutte belle ma a quanto pare, non c'è un così grande bisogno di distinguere token e lessemi IMHO. Sono come due modi per rappresentare la stessa cosa. Un lessema è concreto - qui un insieme di caratteri; un token, d'altra parte, è astratto - di solito si riferisce al tipo di un lessema insieme al suo valore semantico se ha senso. Solo i miei due centesimi.

Lexical Analyzer prende una sequenza di caratteri che identifica un lessema che corrisponde all'espressione regolare e lo classifica ulteriormente come token. Pertanto, a un lessema viene associata una stringa e un nome token è la categoria di quel lessema.

Ad esempio, considera l'espressione regolare di seguito per un identificatore con input "int foo, bar;"

lettera (lettera | cifra | _) *

Qui, fooe barcorrispondono all'espressione regolare quindi sono entrambi lessemi, ma sono classificati come un token, IDovvero l'identificatore.

Notare inoltre che la fase successiva, ovvero l'analizzatore di sintassi, non deve necessariamente conoscere il lessema ma un token.

Lexeme è fondamentalmente l'unità di un token ed è fondamentalmente una sequenza di caratteri che corrisponde al token e aiuta a suddividere il codice sorgente in token.

Per esempio: se la fonte è x=b, allora i lessemi sarebbero x, =, bed i gettoni sarebbero <id, 0>, <=>, <id, 1>.