Нов език за програмиране Mash

В продължение на няколко години се опитвах да разработя собствен език за програмиране. Исках да създам, по мое мнение, възможно най-простия, напълно функционален и удобен език.

В тази статия искам да подчертая основните етапи от моята работа и като начало да опиша създадената концепция на езика и първата му реализация, върху която работя в момента.

Позволете ми да кажа предварително, че написах целия проект на Free Pascal, защото... програмите върху него могат да бъдат компилирани за огромен брой платформи, а самият компилатор произвежда много оптимизирани двоични файлове (събирам всички компоненти на проекта с O2 флаг).

Езикова среда за изпълнение

Преди всичко си струва да поговорим за виртуалната машина, която трябваше да напиша, за да стартирам бъдещи приложения на моя език. Реших да внедря стекова архитектура, може би, защото това беше най-лесният начин. Не намерих нито една нормална статия за това как да направя това на руски, така че след като се запознах с англоезичния материал, седнах да проектирам и напиша собствения си велосипед. След това ще представя моите „напреднали“ идеи и разработки по този въпрос.

Реализация на стека

Очевидно в горната част на VM е стекът. В моята реализация работи на блокове. По същество това е прост масив от указатели и променлива за съхраняване на индекса на върха на стека.
Когато се инициализира, се създава масив от 256 елемента. Ако повече указатели се избутат в стека, неговият размер се увеличава със следващите 256 елемента. Съответно, при премахване на елементи от стека, неговият размер се коригира.

VM използва няколко стека:

1. Основен стек.
2. Стек за съхраняване на точки за връщане.
3. Стек за събиране на боклук.
4. Опитайте/уловете/накрая блокирайте стека на манипулатора.

Константи и променливи

Този е прост. Константите се обработват в отделен малък код и са достъпни в бъдещи приложения чрез статични адреси. Променливите са масив от указатели с определен размер, достъпът до неговите клетки се осъществява по индекс - т.е. статичен адрес. Променливите могат да бъдат избутани в горната част на стека или прочетени от там. Всъщност, защото Докато нашите променливи по същество съхраняват указатели към стойности във VM паметта, езикът е доминиран от работа с неявни указатели.

Събирач на боклук

В моята виртуална машина е полуавтоматично. Тези. разработчикът сам решава кога да се обади на събирача на отпадъци. Не работи с обикновен брояч на указатели, както в Python, Perl, Ruby, Lua и др. Реализира се чрез маркерна система. Тези. когато на променлива е предназначена да бъде присвоена временна стойност, указател към тази стойност се добавя към стека на събирача на отпадъци. В бъдеще колекторът бързо преминава през вече подготвения списък с указатели.

Обработка на блокове try/catch/finally

Както във всеки съвременен език, обработката на изключения е важен компонент. Ядрото на виртуалната машина е обвито в блок try..catch, който може да се върне към изпълнение на кода след улавяне на изключение чрез натискане на информация за него в стека. В кода на приложението можете да дефинирате блокове от код try/catch/finally, като посочите входни точки при catch (манипулатор на изключения) и finally/end (края на блока).

Многопоточност

Поддържа се на ниво VM. Той е лесен и удобен за използване. Работи без система за прекъсване, така че кодът трябва да се изпълнява в няколко нишки съответно няколко пъти по-бързо.

Външни библиотеки за виртуални машини

Без това няма как. VM поддържа импортиране, подобно на това как се прилага в други езици. Можете да напишете част от кода в Mash и част от кода на родните езици, след което да ги свържете в едно.

Преводач от Mash език на високо ниво към байт код за виртуални машини

Междинен език

За да напиша бързо преводач от сложен език във VM код, първо разработих междинен език. Резултатът беше ужасно зрелище като асемблер, което няма особен смисъл да разглеждаме тук. Ще кажа само, че на това ниво транслаторът обработва повечето константи и променливи, изчислява техните статични адреси и адресите на входните точки.

Архитектура на преводача

Не избрах най-добрата архитектура за реализация. Преводачът не изгражда кодово дърво, както правят другите преводачи. Той гледа към началото на структурата. Тези. ако частта от кода, който се анализира, изглежда като “while <условие>:”, тогава е очевидно, че това е конструкция на цикъл while и трябва да бъде обработена като конструкция на цикъл while. Нещо като сложна кутия.

Благодарение на това архитектурно решение преводачът не се оказа много бърз. Въпреки това, лекотата на неговата модификация се е увеличила значително. Добавих необходимите структури по-бързо, отколкото кафето ми изстина. Пълната OOP поддръжка беше внедрена за по-малко от седмица.

Оптимизация на кода

Тук, разбира се, можеше да се приложи по-добре (и ще бъде приложено, но по-късно, щом се стигне до него). Досега оптимизаторът знае само как да отреже неизползван код, константи и импортирания от асемблира. Освен това няколко константи с една и съща стойност се заменят с една. Това е всичко.

Маш език

Основно понятие за език

Основната идея беше да се разработи възможно най-функционалният и прост език. Мисля, че разработката се справя с гръм и трясък със задачата си.

Кодови блокове, процедури и функции

Всички конструкции в езика се отварят с двоеточие. : и се затварят от оператора край.

Процедурите и функциите се декларират съответно като proc и func. Аргументите са изброени в скоби. Всичко е като повечето други езици.

Оператор връщане можете да върнете стойност от функция, оператор почивка ви позволява да излезете от процедурата/функцията (ако е извън циклите).

Примерен код:

...

func summ(a, b):
  return a + b
end

proc main():
  println(summ(inputln(), inputln()))
end

Поддържани дизайни

• Цикли: for..end, while..end, until..end
• Условия: if.[else..]end, switch..[case..end..][else..]end
• Методи: proc <име>():... край, func <име>():... край
• Етикет & goto: <име>:, скок <име>
• Enum изброявания и постоянни масиви.

променливи

Преводачът може да ги определи автоматично или ако разработчикът напише var преди да ги дефинира.

Примери за кодове:

a ?= 10
b ?= a + 20

var a = 10, b = a + 20

Поддържат се глобални и локални променливи.

ООП

Е, стигнахме до най-вкусната тема. Mash поддържа всички парадигми за обектно-ориентирано програмиране. Тези. класове, наследство, полиморфизъм (включително динамичен), динамично автоматично отражение и интроспекция (пълна).

Без повече шум, по-добре е просто да дадете примери за код.

Прост клас и работа с него:

uses <bf>
uses <crt>

class MyClass:
  var a, b
  proc Create, Free
  func Summ
end

proc MyClass::Create(a, b):
  $a = new(a)
  $b = new(b)
end

proc MyClass::Free():
  Free($a, $b)
  $rem()
end

func MyClass::Summ():
  return $a + $b
end

proc main():
  x ?= new MyClass(10, 20)
  println(x->Summ())
  x->Free()
end

Ще изведе: 30.

Наследяване и полиморфизъм:

uses <bf>
uses <crt>

class MyClass:
  var a, b
  proc Create, Free
  func Summ
end

proc MyClass::Create(a, b):
  $a = new(a)
  $b = new(b)
end

proc MyClass::Free():
  Free($a, $b)
  $rem()
end

func MyClass::Summ():
  return $a + $b
end

class MyNewClass(MyClass):
  func Summ
end

func MyNewClass::Summ():
  return ($a + $b) * 2
end

proc main():
  x ?= new MyNewClass(10, 20)
  println(x->Summ())
  x->Free()
end

Ще изведе: 60.

Какво ще кажете за динамичния полиморфизъм? Да, това е отражение!:

uses <bf>
uses <crt>

class MyClass:
  var a, b
  proc Create, Free
  func Summ
end

proc MyClass::Create(a, b):
  $a = new(a)
  $b = new(b)
end

proc MyClass::Free():
  Free($a, $b)
  $rem()
end

func MyClass::Summ():
  return $a + $b
end

class MyNewClass(MyClass):
  func Summ
end

func MyNewClass::Summ():
  return ($a + $b) * 2
end

proc main():
  x ?= new MyClass(10, 20)
  x->Summ ?= MyNewClass::Summ
  println(x->Summ())
  x->Free()
end

Ще изведе: 60.

Сега нека отделим малко време, за да разгледаме прости стойности и класове:

uses <bf>
uses <crt>

class MyClass:
  var a, b
end

proc main():
  x ?= new MyClass
  println(BoolToStr(x->type == MyClass))
  x->rem()
  println(BoolToStr(typeof(3.14) == typeReal))
end

Ще изведе: вярно, вярно.

Относно операторите за присвояване и изричните указатели

Операторът ?= се използва за присвояване на променлива като указател към стойност в паметта.
Операторът = променя стойност в паметта, използвайки указател от променлива.
А сега малко за изричните указатели. Добавих ги към езика, за да съществуват.
@<променлива> — взема явен указател към променлива.
?<променлива> — получаване на променлива чрез указател.
@= — присвояване на стойност на променлива чрез явен указател към нея.

Примерен код:

uses <bf>
uses <crt>

proc main():
  var a = 10, b
  b ?= @a
  PrintLn(b)
  b ?= ?b
  PrintLn(b)
  b++
  PrintLn(a)
  InputLn()
end

Ще изведе: някакво число, 10, 11.

Опитайте.[catch..][finally..]end

Примерен код:

uses <bf>
uses <crt>

proc main():
  println("Start")
  try:
    println("Trying to do something...")
    a ?= 10 / 0
  catch:
    println(getError())
  finally:
    println("Finally")
  end
  println("End")
  inputln()
end

Планове за бъдещето

Продължавам да гледам и разглеждам GraalVM & Truffle. Моята среда за изпълнение няма JIT компилатор, така че по отношение на производителността в момента е конкурентна само на Python. Надявам се, че ще мога да внедря JIT компилация, базирана на GraalVM или LLVM.

хранилище

Можете сами да си играете с развитието и да следвате проекта.

Място
Хранилище в GitHub

Благодаря ви, че прочетохте до края, ако сте го направили.

Източник: www.habr.com