ახალი პროგრამირების ენა Mash

რამდენიმე წლის განმავლობაში ვცდილობდი ძალებს საკუთარი პროგრამირების ენის შემუშავებაში. მინდოდა შემექმნა, ჩემი აზრით, ყველაზე მარტივი, სრულად ფუნქციონალური და მოსახერხებელი ენა.

ამ სტატიაში მინდა გამოვყო ჩემი მუშაობის ძირითადი ეტაპები და, დასაწყისისთვის, აღვწერო ენის შექმნილი კონცეფცია და მისი პირველი განხორციელება, რომელზეც ამჟამად ვმუშაობ.

წინასწარ გეტყვით, რომ მთელი პროექტი დავწერე უფასო პასკალში, რადგან... მასზე პროგრამების აწყობა შესაძლებელია უზარმაზარი რაოდენობის პლატფორმისთვის, ხოლო შემდგენელი თავად აწარმოებს ძალიან ოპტიმიზებულ ბინარებს (პროექტის ყველა კომპონენტს ვაგროვებ O2 დროშით).

ენის გაშვების დრო

უპირველეს ყოვლისა, ღირს ვირტუალურ მანქანაზე საუბარი, რომლის დაწერა მომიწია მომავალი აპლიკაციების ჩემს ენაზე გასაშვებად. გადავწყვიტე სტეკის არქიტექტურის დანერგვა, ალბათ იმიტომ, რომ ეს ყველაზე მარტივი გზა იყო. მე ვერ ვიპოვე ერთი ნორმალური სტატია იმის შესახებ, თუ როგორ უნდა გავაკეთო ეს რუსულად, ამიტომ ინგლისურენოვანი მასალის გაცნობის შემდეგ, დავჯექი ჩემი ველოსიპედის დიზაინზე და დაწერაზე. შემდეგ მე წარმოგიდგენთ ჩემს "მოწინავე" იდეებს და განვითარებებს ამ საკითხთან დაკავშირებით.

სტეკის განხორციელება

ცხადია, VM-ის ზედა ნაწილში არის სტეკი. ჩემი განხორციელებისას ის მუშაობს ბლოკებში. არსებითად, ეს არის მაჩვენებლების მარტივი მასივი და ცვლადი სტეკის ზედა ნაწილის ინდექსის შესანახად.
მისი ინიციალიზაციისას იქმნება 256 ელემენტისგან შემდგარი მასივი. თუ დასტაზე მეტი მაჩვენებლის გადატანა ხდება, მისი ზომა იზრდება შემდეგი 256 ელემენტით. შესაბამისად, დასტიდან ელემენტების ამოღებისას, მისი ზომა რეგულირდება.

VM იყენებს რამდენიმე დასტას:

1. მთავარი დასტა.
2. დასტა დაბრუნების ქულების შესანახად.
3. ნაგვის შემგროვებელი დასტა.
4. სცადეთ/დაჭერა/საბოლოოდ დაბლოკეთ დამმუშავებლის სტეკი.

მუდმივები და ცვლადები

ეს ერთი მარტივია. მუდმივები დამუშავებულია კოდის ცალკეულ პატარა ნაწილად და ხელმისაწვდომია მომავალ აპლიკაციებში სტატიკური მისამართების საშუალებით. ცვლადები არის გარკვეული ზომის მაჩვენებლების მასივი, მის უჯრედებზე წვდომა ხორციელდება ინდექსით - ე.ი. სტატიკური მისამართი. ცვლადები შეიძლება გადაიტანონ სტეკის ზედა ნაწილში ან წაიკითხონ იქიდან. რეალურად იმიტომ მიუხედავად იმისა, რომ ჩვენი ცვლადები არსებითად ინახავს მითითებებს მნიშვნელობებზე VM მეხსიერებაში, ენაში დომინირებს იმპლიციტური მაჩვენებლებთან მუშაობა.

ნაგვის კოლექციონერი

ჩემს VM-ში ის ნახევრად ავტომატურია. იმათ. დეველოპერი თავად წყვეტს როდის დაურეკოს ნაგვის შემგროვებელს. ის არ მუშაობს ჩვეულებრივი მრიცხველის გამოყენებით, როგორც Python, Perl, Ruby, Lua და ა.შ. იგი ხორციელდება მარკერის სისტემის მეშვეობით. იმათ. როდესაც ცვლადს განზრახული აქვს დროებითი მნიშვნელობის მინიჭება, ამ მნიშვნელობის მაჩვენებელი ემატება ნაგვის შემგროვებლის დასტას. მომავალში, კოლექციონერი სწრაფად გადის მაჩვენებლების უკვე მომზადებულ სიას.

ცდის/დაჭერის/საბოლოო ბლოკების მართვა

როგორც ნებისმიერ თანამედროვე ენაში, გამონაკლისების მართვა მნიშვნელოვანი კომპონენტია. VM ბირთვი შეფუთულია try..catch ბლოკში, რომელიც შეიძლება დაუბრუნდეს კოდის შესრულებას გამონაკლისის დაჭერის შემდეგ, მის შესახებ გარკვეული ინფორმაციის დასტაზე გადატანით. აპლიკაციის კოდში შეგიძლიათ განსაზღვროთ სცადეთ/დაჭერა/საბოლოოდ კოდის ბლოკები, მიუთითოთ შესვლის წერტილები catch-ზე (გამონაკლისის დამმუშავებელი) და ბოლოს/ბოლო (ბლოკის დასასრული).

მრავალძაფიანი

ის მხარდაჭერილია VM დონეზე. ეს არის მარტივი და მოსახერხებელი გამოსაყენებლად. ის მუშაობს შეფერხების სისტემის გარეშე, ამიტომ კოდი უნდა შესრულდეს რამდენიმე თემაში, შესაბამისად, რამდენჯერმე უფრო სწრაფად.

გარე ბიბლიოთეკები VM-ებისთვის

ამის გარეშე არ არსებობს გზა. VM მხარს უჭერს იმპორტს, ისევე როგორც სხვა ენებზე დანერგილი. შეგიძლიათ დაწეროთ კოდის ნაწილი Mash-ში და კოდის ნაწილი მშობლიურ ენებზე, შემდეგ დააკავშიროთ ისინი ერთში.

თარჯიმანი მაღალი დონის Mash ენიდან VM-ებისთვის ბაიტიკოდამდე

შუალედური ენა

რთული ენიდან VM კოდში მთარგმნელის სწრაფად ჩასაწერად, პირველად შევიმუშავე შუალედური ენა. შედეგი იყო ასამბლერის მსგავსი საშინელი სანახაობა, რომლის განხილვას აქ განსაკუთრებული აზრი არ აქვს. მე მხოლოდ ვიტყვი, რომ ამ დონეზე მთარგმნელი ამუშავებს მუდმივებსა და ცვლადებს, ითვლის მათ სტატიკურ მისამართებს და შესვლის წერტილების მისამართებს.

მთარგმნელის არქიტექტურა

მე არ ავირჩიე საუკეთესო არქიტექტურა განსახორციელებლად. მთარგმნელი არ აშენებს კოდის ხეს, როგორც ამას სხვა მთარგმნელები აკეთებენ. ის უყურებს სტრუქტურის საწყისს. იმათ. თუ კოდის ნაწილი, რომელიც ანალიზდება, ჰგავს „while <condition>:“-ს, მაშინ აშკარაა, რომ ეს არის while მარყუჟის კონსტრუქცია და უნდა დამუშავდეს, როგორც while მარყუჟის კონსტრუქცია. რაღაც რთული გადამრთველის მსგავსი.

ამ არქიტექტურული გადაწყვეტის წყალობით, მთარგმნელი არც თუ ისე სწრაფი აღმოჩნდა. თუმცა, მისი მოდიფიკაციის სიმარტივე მნიშვნელოვნად გაიზარდა. საჭირო სტრუქტურები უფრო სწრაფად დავამატე, ვიდრე ჩემი ყავა გაცივდა. სრული OOP მხარდაჭერა განხორციელდა ერთ კვირაზე ნაკლებ დროში.

კოდის ოპტიმიზაცია

აქ, რა თქმა უნდა, უკეთესადაც შეიძლებოდა განხორციელებულიყო (და განხორციელდება, მაგრამ მოგვიანებით, როგორც კი მიუახლოვდებით). ჯერჯერობით, ოპტიმიზატორმა მხოლოდ იცის, როგორ ამოიღოს გამოუყენებელი კოდი, მუდმივები და იმპორტი ასამბლეიდან. ასევე, რამდენიმე მუდმივი ერთი და იგივე მნიშვნელობით იცვლება ერთით. Სულ ეს არის.

ენის ბადაგი

ენის ძირითადი კონცეფცია

მთავარი იდეა იყო მაქსიმალურად ფუნქციონალური და მარტივი ენის შემუშავება. მე ვფიქრობ, რომ განვითარება უმკლავდება თავის დავალებას.

კოდის ბლოკები, პროცედურები და ფუნქციები

ენაში ყველა კონსტრუქცია იხსნება ორწერტილით. : და დახურულია ოპერატორის მიერ ბოლო.

პროცედურები და ფუნქციები გამოცხადებულია, როგორც proc და func, შესაბამისად. არგუმენტები ჩამოთვლილია ფრჩხილებში. ყველაფერი სხვა ენების უმეტესობას ჰგავს.

ოპერატორი დაბრუნების შეგიძლიათ დააბრუნოთ მნიშვნელობა ფუნქციიდან, ოპერატორიდან შესვენება საშუალებას გაძლევთ გახვიდეთ პროცედურის/ფუნქციიდან (თუ ის მარყუჟების გარეთაა).

კოდის ნიმუში:

...

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

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

მხარდაჭერილი დიზაინები

• მარყუჟები: დასასრულისთვის, ხოლო..ბოლომდე, ბოლომდე
• პირობები: თუ..[სხვა..]დასრულდება, გადართვა..[საქმე..დასრულდება..][სხვა..]დასრულება
• მეთოდები: proc <name>():... დასასრული, func <სახელი>():... დასასრული
• ეტიკეტი და წადით: <სახელი>:, გადადით <სახელი>
• ჩამოთვლა და მუდმივი მასივები.

ცვლადები

მთარგმნელს შეუძლია ავტომატურად განსაზღვროს ისინი, ან თუ დეველოპერი წერს var-ს მათ განსაზღვრამდე.

კოდის მაგალითები:

a ?= 10
b ?= a + 20

var a = 10, b = a + 20

მხარდაჭერილია გლობალური და ლოკალური ცვლადები.

OOP

ისე, ჩვენ მივედით ყველაზე გემრიელ თემაზე. 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.

სცადე..[დაჭერა..][საბოლოოდ..]დასრულდეს

კოდის ნიმუში:

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