Rappresentazione astratta della struttura della sintassi in C++

Question

Ho già l'interfaccia tokenizer che crea un elenco di token. Ho il meccanismo di lavoro per il parser. È davvero unico e funziona come un fascino. L'unica cosa che mi manca è la struttura di base dell'AST. Come l'albero, i nodi e le dichiarazioni dovrebbero essere rappresentati a livello di astrazione. Non ho bisogno di alcuna implementazione solo una veloce idea di come dovrebbe essere nella gerarchia delle classi? Sto lavorando su un linguaggio orientato agli oggetti. Sì, ho già capito che avrò bisogno di due tipi di dichiarazioni. Alcuni valori che restituiscono l'istruzione di tipo "espressione" e un'istruzione di tipo di controllo del flusso di istruzioni non di ritorno. Grazie mille.

Answer 1

Se la lingua è imperativo/c-like, lo scenario comune inizia con top-gerarchia essendo diviso in 2 supertipi:

• Espressione
• Dichiarazione

Il programma è una lista di affermazione, che è un'affermazione stessa.

Probabilmente vorrete avere una classe per tipo di istruzione che estenda la classe base dell'istruzione.

Uno scenario tipico assomiglia:

• blocco di istruzioni (un elenco di istruzioni)
• ite (se poi il resto)
• per (un'espressione per il ciclo con la sua lista dichiarazioni di inizializzazione, controllare, incrementare le istruzioni e bloccare
• mentre (simile, ma solo controllare espressione
• dichiarazione variabile
• assegnazione (Compresi i + = - = ++ -, si può avvolgere tutto in una classe con un campo operatore, un lval e un rval)
• chiamata di funzione (void uno)

Per le espressioni:

• Bop (operazione binaria, qualsiasi cosa che abbia 2 operandi e 1 operatore cioè + - * /% | & & & || == <
• Uop (operazione unaria, tutto ciò che ha 1 operando e 1 operatore cioè ~!)
• chiamata di funzione (quelli non-nulli)
• espressione condizionale (exp vero val:? Falsa val)

La cosa buona di avere queste 2 astrazioni (espressioni e dichiarazioni) è che all'interno di tutte le classi, si avranno tipi astratti e sarà possibile visitare l'AST con il modello di visitatore, ad esempio.

Per esempio, alcune classi avrebbero simile a questo (pseudocodice):

class Ite extends Statement { 
    Expression condition; 
    Statement ifBranch; 
    Statement elseBranch; 
} 


class Bop extends Expression { 
    BOperator operator; // +, -. * or whatever 
    Expression left;  // Left operand 
    Expression right; // Right operand 
} 


class StatementBlock extends Statement { 
    List<Statement> statements; 
} 


class Assignment extends Statement { 
    AOperator assignOp; // = += -= etc. 
    LVal lvalue;   // The lvalue cannot be an arbitrary expression, you will usually have a specific type for it 
    Expression rvalue; // Right value 
} 

Inoltre, avrete bisogno di qualche modo per rappresentare tipi (per l'AST, a soli tipi statici sono sufficienti, se si proietti per implementare anche alcuni back-end, avrete bisogno anche di alcuni tipi dinamici).

I tipi statici possono in genere essere specificati con alcune enumerazioni, se non si prevede di supportare matrici di dimensioni fisse che necessitano di informazioni sulle dimensioni. Se si desidera che le matrici di dimensione fissa con, dimensione, è possibile implementare una classe per tipo e il tipo di matrice contenere informazioni di dimensioni aggiuntive.

enum Type { 
    CHAR, 
    SHORT, 
    INT, 
    LONG, 
    FLOAT, 
    DOUBLE, 
    ARRAY 
} 

class Float extends StaticType { 
    final Type type = Type.FLOAT; 
} 

class Array extends StaticArray { 
    final Type type = Type.ARRAY; 

    int size; 
} 

Sarà quindi istanziare un'istanza StaticType per ogni tipo nella AST, ad esempio quando l'utente dichiara una variabile. Sarai in grado di utilizzare la stessa gerarchia anche se prevedi di eseguire controlli di tipo statici in futuro.

Per quanto riguarda l'esecuzione/interpretazione del codice nel modulo AST, sarà necessaria una memoria che contenga uno stack/heap contenente informazioni sulla memoria di runtime. A quel punto sarà necessario memorizzare i valori insieme alle informazioni sul tipo.