In che modo i linguaggi di programmazione definiscono le funzioni?

In che modo i linguaggi di programmazione definiscono e salvano funzioni / metodi? Sto creando un linguaggio di programmazione interpretato in Ruby e sto cercando di capire come implementare la dichiarazione di funzione.

La mia prima idea è quella di salvare il contenuto della dichiarazione in una mappa. Ad esempio, se ho fatto qualcosa di simile

def a() {
    callSomething();
    x += 5;
}

Quindi aggiungerei una voce nella mia mappa:

{
    'a' => 'callSomething(); x += 5;'
}

Il problema è che sarebbe diventato ricorsivo, perché avrei dovuto chiamare il mio parsemetodo sulla stringa, che poi avrebbe richiamato di parsenuovo quando si fosse verificato doSomething, e alla fine avrei esaurito lo spazio dello stack.

Quindi, come gestiscono le lingue interpretate?

Sarei corretto supponendo che la tua funzione "analisi" non solo analizza il codice ma lo esegue anche allo stesso tempo? Se si desidera farlo in questo modo, invece di archiviare i contenuti di una funzione nella propria mappa, memorizzare la posizione della funzione.

Ma c'è un modo migliore. Ci vuole un po 'più di sforzo in anticipo, ma produce risultati molto migliori all'aumentare della complessità: utilizzare un albero di sintassi astratto.

L'idea di base è che analizzi il codice solo una volta, mai. Quindi hai un set di tipi di dati che rappresentano operazioni e valori e ne fai un albero, in questo modo:

def a() {
    callSomething();
    x += 5;
}

diventa:

Function Definition: [
   Name: a
   ParamList: []
   Code:[
      Call Operation: [
         Routine: callSomething
         ParamList: []
      ]
      Increment Operation: [
         Operand: x
         Value: 5
      ]
   ]
]

(Questa è solo una rappresentazione testuale della struttura di un ipotetico AST. Probabilmente l'albero reale non sarebbe in forma di testo.) Comunque, analizzi il tuo codice in un AST, e poi esegui direttamente il tuo interprete sull'AST, oppure utilizzare un secondo passaggio ("generazione del codice") per trasformare l'AST in una forma di output.

Nel caso della tua lingua, quello che probabilmente faresti è avere una mappa che associ i nomi delle funzioni alle AST, invece dei nomi delle funzioni alle stringhe delle funzioni.

Non dovresti chiamare parse dopo aver visto callSomething()(suppongo che tu intendessi callSomethingpiuttosto che doSomething). La differenza tra ae callSomethingè che una è una definizione di metodo mentre l'altra è una chiamata di metodo.

Quando vedi una nuova definizione, ti consigliamo di fare dei controlli per assicurarti di poter aggiungere quella definizione, quindi:

• Controlla se la funzione non esiste già con la stessa firma
• Accertarsi che la dichiarazione del metodo sia eseguita nel campo di applicazione appropriato (vale a dire che i metodi possono essere dichiarati all'interno di altre dichiarazioni di metodo?)

Supponendo che questi controlli superino, puoi aggiungerlo alla tua mappa e iniziare a controllare i contenuti di quel metodo.

Quando trovi una chiamata di metodo simile callSomething(), devi eseguire i seguenti controlli:

• Esiste callSomethingnella tua mappa?
• Viene chiamato correttamente (il numero di argomenti corrisponde alla firma che hai trovato)?
• Gli argomenti sono validi (se vengono utilizzati nomi di variabili, vengono dichiarati? È possibile accedervi in ​​questo ambito?)?
• CallSomething può essere chiamato da dove ti trovi (è privato, pubblico, protetto?)?

Se trovi che callSomething()va bene, a questo punto quello che vorresti fare davvero dipende da come desideri affrontarlo. A rigor di termini, una volta che sai che una tale chiamata va bene a questo punto, puoi solo salvare il nome del metodo e gli argomenti senza entrare in ulteriori dettagli. Quando esegui il tuo programma, invocherai il metodo con gli argomenti che dovresti avere in fase di esecuzione.

Se si desidera andare oltre, è possibile salvare non solo la stringa ma un collegamento al metodo effettivo. Questo sarebbe più efficiente, ma se devi gestire la memoria, può diventare confuso. Vorrei raccomandare semplicemente di tenere la stringa all'inizio. Successivamente puoi provare a ottimizzare.

Si noti che tutto questo presuppone che tu abbia lasciato il tuo programma, il che significa che hai riconosciuto tutti i token nel tuo programma e sai quali sono . Questo non vuol dire che sai se hanno ancora senso insieme, che è la fase di analisi. Se non sai ancora quali sono i token, ti suggerisco di concentrarti innanzitutto sull'ottenere tali informazioni.

Spero che aiuti! Benvenuti in Programmers SE!

Leggendo il tuo post, ho notato due domande nella tua domanda. Il più importante è come analizzare. Ci sono molti tipi di parser (per esempio ricorsivo discesa parser , LR parser , Packrat parser ) e generatori di parser (per esempio GNU bisonti , ANTLR ) è possibile utilizzare per attraversare un programma testuale "ricorsiva" data una grammatica (esplicita o implicita).

La seconda domanda riguarda il formato di archiviazione per le funzioni. Quando non si esegue la traduzione diretta dalla sintassi , si crea una rappresentazione intermedia del programma, che può essere un albero di sintassi astratto o un linguaggio intermedio personalizzato, al fine di eseguire ulteriori elaborazioni con esso (compilare, trasformare, eseguire, scrivere su un file, ecc.).

Da un punto di vista generico, la definizione di una funzione è poco più di un'etichetta, o segnalibro, nel codice. La maggior parte degli altri operatori di loop, scope e condizionali sono simili; sono stand-in per un comando "jump" o "goto" di base nei livelli inferiori di astrazione. Una chiamata di funzione si riduce sostanzialmente ai seguenti comandi di computer di basso livello:

• Concatena i dati di tutti i parametri, oltre a un puntatore all'istruzione successiva della funzione corrente, in una struttura nota come "call stack frame".
• Inserire questo frame nello stack di chiamate.
• Passa all'offset di memoria della prima riga del codice della funzione.

Un'istruzione "return" o simile farà quindi quanto segue:

• Carica il valore da restituire in un registro.
• Carica il puntatore sul chiamante in un registro.
• Pop il frame dello stack corrente.
• Vai al puntatore del chiamante.

Le funzioni, quindi, sono semplicemente astrazioni in una specifica del linguaggio di livello superiore, che consentono agli esseri umani di organizzare il codice in un modo più gestibile e intuitivo. Se compilato in un assembly o in un linguaggio intermedio (JIL, MSIL, ILX) e sicuramente reso come codice macchina, quasi tutte queste astrazioni scompaiono.