Як мови програмування визначають функції?

Як мови програмування визначають і зберігають функції / методи? Я створюю інтерпретовану мову програмування в Ruby, і я намагаюся зрозуміти, як реалізувати декларацію функції.

Моя перша ідея - зберегти вміст декларації на карті. Наприклад, якщо я зробив щось подібне

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

Тоді я б додав запис до своєї карти:

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

Проблема в цьому полягає в тому, що він став би рекурсивним, тому що я повинен був би викликати свій parseметод на рядку, який потім зателефонував би parseзнову, коли він зіткнувся doSomething, і тоді мені б в кінцевому підсумку не вистачило місця у стеці.

Отже, як з цим впораються інтерпретовані мови?

Чи правильно я припускаю, що ваша функція "розбору" не тільки аналізує код, але й виконує його одночасно? Якщо ви хотіли зробити це саме так, замість того, щоб зберігати вміст функції у вашій карті, збережіть розташування функції.

Але є кращий спосіб. Це вимагає трохи більше зусиль наперед, але це дає набагато кращі результати, оскільки складність збільшується: використовуйте абстрактне синтаксичне дерево.

Основна ідея полягає в тому, що ви аналізуєте код лише раз, коли-небудь. Тоді у вас є набір типів даних, що представляють операції та значення, і ви складаєте з них дерево таким чином:

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

стає:

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

(Це лише текстове зображення структури гіпотетичного AST. Фактичне дерево, мабуть, не буде в текстовій формі.) У будь-якому випадку, ви розбираєте свій код в AST, а потім або запускаєте інтерпретатора над AST безпосередньо, або використовувати другий ("генерація коду") переходу для перетворення AST в якусь форму виводу.

Що стосується вашої мови, то, напевно, ви могли б зробити карту, яка відображає назви функцій для функціонування AST, а не імена функцій для функціональних рядків.

Ви не повинні викликати розбір, побачивши callSomething()(я вважаю, що ви мали на увазі, callSomethingа не doSomething). Різниця між aі callSomethingполягає в тому, що один - це визначення методу, а інший - виклик методу.

Коли ви побачите нове визначення, ви хочете зробити перевірки, пов’язані із тим, щоб переконатися, що ви можете додати це визначення, так:

• Перевірте, чи функція вже не існує з такою ж підписом
• Переконайтесь, що декларування методу виконується у належному масштабі (тобто чи можуть бути оголошені методи всередині декларацій інших методів?)

Припускаючи, що ці чеки проходять, ви можете додати їх на свою карту і почати перевірку вмісту цього методу.

Коли ви знайдете такий виклик методу callSomething(), вам слід виконати такі перевірки:

• Чи callSomethingіснує на вашій карті?
• Чи правильно його називають (кількість аргументів відповідає підпису, який ви знайшли)?
• Чи є аргументи дійсними (якщо використовуються імена змінних, вони оголошені? Чи можна отримати доступ до цього обсягу?)?
• Чи можна зателефонувати чомусь звідки ви перебуваєте (це приватний, громадський, захищений?)?

Якщо ви вважаєте, що callSomething()це нормально, то на даний момент, що ви хотіли б зробити насправді, залежить від того, як ви хочете підійти до цього. Власне кажучи, щойно ви знаєте, що в даний момент такий виклик нормальний, ви могли зберегти лише ім'я методу та аргументи, не вникаючи в деталі. Під час запуску програми ви будете викликати метод з аргументами, які ви повинні мати під час виконання.

Якщо ви хочете піти далі, ви можете зберегти не просто рядок, а посилання на фактичний метод. Це було б ефективніше, але якщо вам доведеться керувати пам'яттю, це може заплутатися. Я б рекомендував вам спочатку просто потримати рядок. Пізніше ви можете спробувати оптимізувати.

Зауважте, що це все, припускаючи, що ви лексикували свою програму, а це означає, що ви розпізнали всі маркери у вашій програмі та знаєте, що вони є . Це не означає, що ви знаєте, якщо вони мають сенс разом, що є етапом розбору. Якщо ви ще не знаєте, що таке маркери, пропоную вам спочатку зосередитися на отриманні цієї інформації.

Я сподіваюся, що це допомагає! Ласкаво просимо до програмістів SE!

Читаючи вашу публікацію, я помітив у вашому запитання два питання. Найголовніше - як розібратися. Існує багато видів парсерів (наприклад, аналізатор рекурсивного зниження , LR Parsers , Packrat Parsers ) і генератори парсерів (наприклад, GNU bison , ANTLR ), які можна використовувати для переходу текстової програми "рекурсивно" з урахуванням (явного або неявного) граматики.

Друге питання стосується формату зберігання для функцій. Коли ви не робите перекладу , спрямованого на синтаксис , ви створюєте проміжне представлення вашої програми, яке може бути абстрактним синтаксичним деревом або якоюсь спеціальною проміжною мовою, щоб зробити подальшу обробку з ним (компілювати, перетворювати, виконувати, писати далі файл тощо).

З загальної точки зору, визначення функції трохи більше, ніж мітка або закладка в коді. Більшість інших операторів циклу, обсягу та умовності схожі; вони стоять за основні команди "стрибок" або "гото" в нижчих рівнях абстракції. Виклик функції в основному зводиться до таких низькорівневих команд комп'ютера:

• Об'єднайте дані всіх параметрів плюс покажчик на наступну інструкцію поточної функції в структуру, відому як "кадр стека викликів".
• Натисніть на цей кадр на стек викликів.
• Перейти до зміщення пам'яті першого рядка коду функції.

Виписка "return" або подібне буде робити наступне:

• Завантажте значення, яке потрібно повернути в реєстр.
• Завантажте покажчик абоненту в регістр.
• Розмістіть поточну рамку стека.
• Перейти до вказівника абонента.

Отже, функції - це просто абстракції в специфікації мови вищого рівня, які дозволяють людині організовувати код більш ремонтованим та інтуїтивно зрозумілим способом. Коли вони складаються на збірну або проміжну мову (JIL, MSIL, ILX) і, безумовно, коли вони відображаються як машинні коди, майже всі такі абстракції відпадають.