ភាសាសរសេរកម្មវិធីថ្មី Mash

អស់រយៈពេលជាច្រើនឆ្នាំខ្ញុំបានព្យាយាមដៃរបស់ខ្ញុំក្នុងការអភិវឌ្ឍភាសាសរសេរកម្មវិធីផ្ទាល់ខ្លួនរបស់ខ្ញុំ។ តាមគំនិតរបស់ខ្ញុំ ខ្ញុំចង់បង្កើតភាសាសាមញ្ញបំផុត មុខងារពេញលេញ និងងាយស្រួលបំផុតដែលអាចធ្វើទៅបាន។

នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់បង្ហាញពីដំណាក់កាលសំខាន់នៃការងាររបស់ខ្ញុំ ហើយដើម្បីចាប់ផ្តើមជាមួយនឹង ការពិពណ៌នាអំពីគំនិតដែលបានបង្កើតនៃភាសា និងការអនុវត្តដំបូងរបស់វា ដែលខ្ញុំកំពុងធ្វើការនាពេលបច្ចុប្បន្ននេះ។

ខ្ញុំសូមនិយាយជាមុនថាខ្ញុំបានសរសេរគម្រោងទាំងមូលនៅក្នុង Free Pascal ពីព្រោះ ... កម្មវិធីនៅលើវាអាចត្រូវបានផ្គុំឡើងសម្រាប់វេទិកាមួយចំនួនធំ ហើយអ្នកចងក្រងខ្លួនឯងផលិតប្រព័ន្ធគោលពីរដែលបានកែលម្អយ៉ាងខ្លាំង (ខ្ញុំប្រមូលសមាសធាតុទាំងអស់នៃគម្រោងជាមួយនឹងទង់ O2) ។

ម៉ោងរត់ភាសា

ជាដំបូងវាមានតម្លៃនិយាយអំពីម៉ាស៊ីននិម្មិតដែលខ្ញុំត្រូវសរសេរដើម្បីដំណើរការកម្មវិធីនាពេលអនាគតជាភាសារបស់ខ្ញុំ។ ខ្ញុំបានសម្រេចចិត្តអនុវត្តស្ថាបត្យកម្មជង់ ប្រហែលជាព្រោះវាជាមធ្យោបាយងាយស្រួលបំផុត។ ខ្ញុំមិនបានរកឃើញអត្ថបទធម្មតាមួយអំពីរបៀបធ្វើវាជាភាសារុស្សីទេ ដូច្នេះបន្ទាប់ពីស្គាល់ខ្លួនឯងជាមួយនឹងសម្ភារៈជាភាសាអង់គ្លេស ខ្ញុំបានអង្គុយចុះដើម្បីរចនា និងសរសេរកង់ផ្ទាល់ខ្លួនរបស់ខ្ញុំ។ បន្ទាប់ខ្ញុំនឹងបង្ហាញគំនិត និងការអភិវឌ្ឍន៍ "កម្រិតខ្ពស់" របស់ខ្ញុំនៅក្នុងបញ្ហានេះ។

ការអនុវត្តជង់

ជាក់ស្តែងនៅផ្នែកខាងលើនៃ VM គឺជាជង់។ នៅក្នុងការអនុវត្តរបស់ខ្ញុំវាដំណើរការជាប្លុក។ សំខាន់នេះគឺជាអារេសាមញ្ញនៃទ្រនិច និងអថេរសម្រាប់រក្សាទុកសន្ទស្សន៍នៃកំពូលនៃជង់។
នៅពេលដែលវាត្រូវបានចាប់ផ្តើម អារេនៃធាតុ 256 ត្រូវបានបង្កើត។ ប្រសិនបើទ្រនិចច្រើនត្រូវបានរុញលើជង់ ទំហំរបស់វាកើនឡើងដោយធាតុ 256 បន្ទាប់។ ដូច្នោះហើយនៅពេលយកធាតុចេញពីជង់ទំហំរបស់វាត្រូវបានកែតម្រូវ។

VM ប្រើជង់ជាច្រើន៖

1. ជង់ចម្បង។
2. ជង់សម្រាប់រក្សាទុកពិន្ទុត្រឡប់។
3. ជង់អ្នកប្រមូលសំរាម។
4. សាកល្បង/ចាប់/ចុងក្រោយ រារាំងជង់អ្នកដោះស្រាយ។

អថេរ និងអថេរ

មួយនេះគឺសាមញ្ញ។ Constants ត្រូវបានគ្រប់គ្រងក្នុងផ្នែកតូចមួយដាច់ដោយឡែកនៃកូដ ហើយមាននៅក្នុងកម្មវិធីនាពេលអនាគតតាមរយៈអាសយដ្ឋានឋិតិវន្ត។ អថេរគឺជាអារេនៃទ្រនិចនៃទំហំជាក់លាក់មួយ ការចូលទៅកាន់ក្រឡារបស់វាត្រូវបានអនុវត្តដោយលិបិក្រម - i.e. អាសយដ្ឋានឋិតិវន្ត។ អថេរអាចត្រូវបានរុញទៅកំពូលនៃជង់ឬអានពីទីនោះ។ តាមពិតដោយសារតែ ខណៈពេលដែលអថេររបស់យើងរក្សាទុកទ្រនិចទៅតម្លៃនៅក្នុងអង្គចងចាំ VM ភាសាត្រូវបានគ្របដណ្ដប់ដោយធ្វើការជាមួយទ្រនិចដែលបង្កប់ន័យ។

អ្នក​ប្រមូល​សំរាម

នៅក្នុង VM របស់ខ្ញុំ វាគឺពាក់កណ្តាលស្វ័យប្រវត្តិ។ ទាំងនោះ។ អ្នកអភិវឌ្ឍន៍ខ្លួនឯងសម្រេចចិត្តថាពេលណាត្រូវហៅអ្នកប្រមូលសំរាម។ វាមិនដំណើរការដោយប្រើទ្រនិចទ្រនិចធម្មតាដូចនៅក្នុង Python, Perl, Ruby, Lua ជាដើម។ វាត្រូវបានអនុវត្តតាមរយៈប្រព័ន្ធសម្គាល់។ ទាំងនោះ។ នៅពេលដែលអថេរត្រូវបានបម្រុងទុកសម្រាប់កំណត់តម្លៃបណ្តោះអាសន្ន ទ្រនិចទៅតម្លៃនេះត្រូវបានបន្ថែមទៅជង់របស់អ្នកប្រមូលសំរាម។ នៅពេលអនាគត អ្នកប្រមូលបានដំណើរការយ៉ាងលឿនតាមរយៈបញ្ជីចង្អុលដែលបានរៀបចំរួចហើយ។

ដោះស្រាយការសាកល្បង/ចាប់/ចុងក្រោយរារាំង

ដូចនៅក្នុងភាសាទំនើបណាមួយ ការដោះស្រាយករណីលើកលែងគឺជាសមាសធាតុសំខាន់មួយ។ ស្នូល VM ត្រូវបានរុំនៅក្នុងប្លុក try..catch ដែលអាចត្រឡប់ទៅដំណើរការកូដវិញ បន្ទាប់ពីចាប់បានករណីលើកលែងដោយរុញព័ត៌មានមួយចំនួនអំពីវាទៅលើជង់។ នៅក្នុងកូដកម្មវិធី អ្នកអាចកំណត់ try/catch/finally blocks នៃ code បញ្ជាក់ចំនុចចូលនៅ catch (exception handler) និងចុងក្រោយ/end (end of block)។

ពហុខ្សែ

វាត្រូវបានគាំទ្រនៅកម្រិត VM ។ វាសាមញ្ញ និងងាយស្រួលប្រើ។ វាដំណើរការដោយគ្មានប្រព័ន្ធរំខាន ដូច្នេះកូដគួរតែត្រូវបានប្រតិបត្តិក្នុងខ្សែស្រឡាយជាច្រើនដងលឿនជាងមុនរៀងៗខ្លួន។

បណ្ណាល័យខាងក្រៅសម្រាប់ VMs

គ្មានវិធីធ្វើដោយគ្មានរឿងនេះទេ។ VM គាំទ្រការនាំចូល ស្រដៀងនឹងរបៀបដែលវាត្រូវបានអនុវត្តជាភាសាផ្សេងទៀត។ អ្នកអាចសរសេរផ្នែកនៃកូដជា Mash និងផ្នែកនៃកូដជាភាសាកំណើត បន្ទាប់មកភ្ជាប់ពួកវាទៅជាមួយ។

អ្នកបកប្រែពីភាសា Mash កម្រិតខ្ពស់ទៅជា bytecode សម្រាប់ VMs

ភាសាកម្រិតមធ្យម

ដើម្បី​សរសេរ​អ្នក​បក​ប្រែ​ពី​ភាសា​ស្មុគស្មាញ​ទៅ​ជា​កូដ VM យ៉ាង​ឆាប់​រហ័ស ខ្ញុំ​បាន​បង្កើត​ភាសា​កម្រិត​មធ្យម​ដំបូង។ លទ្ធផល​គឺ​ជា​ទស្សនីយភាព​ដ៏​គួរ​ឱ្យ​ភ័យខ្លាច​មួយ​ដែល​គ្មាន​ចំណុច​ពិសេស​ក្នុង​ការ​ពិចារណា​នៅ​ទីនេះ។ ខ្ញុំគ្រាន់តែនិយាយថានៅកម្រិតនេះ អ្នកបកប្រែដំណើរការអថេរ និងអថេរភាគច្រើន គណនាអាសយដ្ឋានឋិតិវន្តរបស់ពួកគេ និងអាសយដ្ឋាននៃចំណុចចូល។

ស្ថាបត្យកម្មអ្នកបកប្រែ

ខ្ញុំមិនបានជ្រើសរើសស្ថាបត្យកម្មល្អបំផុតសម្រាប់ការអនុវត្តទេ។ អ្នកបកប្រែមិនបង្កើតមែកធាងកូដដូចអ្នកបកប្រែផ្សេងទៀតធ្វើទេ។ គាត់មើលនៅដើមដំបូងនៃរចនាសម្ព័ន្ធ។ ទាំងនោះ។ ប្រសិនបើបំណែកនៃកូដដែលកំពុងញែកមើលទៅដូចជា "while <condition>:" នោះវាច្បាស់ណាស់ថានេះគឺជា while loop construct ហើយត្រូវការដំណើរការជា while loop construct ។ អ្វីមួយដូចជាករណីប្តូរស្មុគ្រស្មាញ។

អរគុណចំពោះដំណោះស្រាយស្ថាបត្យកម្មនេះ អ្នកបកប្រែប្រែថាមិនលឿនទេ។ ទោះជាយ៉ាងណាក៏ដោយភាពងាយស្រួលនៃការកែប្រែរបស់វាបានកើនឡើងយ៉ាងខ្លាំង។ ខ្ញុំបានបន្ថែមរចនាសម្ព័ន្ធចាំបាច់លឿនជាងកាហ្វេរបស់ខ្ញុំអាចត្រជាក់ចុះ។ ការគាំទ្រ OOP ពេញលេញត្រូវបានអនុវត្តក្នុងរយៈពេលតិចជាងមួយសប្តាហ៍។

ការបង្កើនប្រសិទ្ធភាពកូដ

នៅទីនេះ ជាការពិត វាអាចត្រូវបានអនុវត្តបានប្រសើរជាងមុន (ហើយនឹងត្រូវបានអនុវត្ត ប៉ុន្តែនៅពេលក្រោយ ដរាបណាមនុស្សម្នាក់ទទួលបានវា)។ រហូតមកដល់ពេលនេះ អ្នកបង្កើនប្រសិទ្ធភាពគ្រាន់តែដឹងពីរបៀបកាត់កូដដែលមិនប្រើ ថេរ និងការនាំចូលពីសន្និបាត។ ដូចគ្នានេះផងដែរ ថេរជាច្រើនដែលមានតម្លៃដូចគ្នាត្រូវបានជំនួសដោយមួយ។ អស់ហើយ។

ភាសាម៉ាស

គំនិតជាមូលដ្ឋាននៃភាសា

គំនិតចម្បងគឺដើម្បីអភិវឌ្ឍភាសាដែលមានមុខងារ និងសាមញ្ញបំផុតដែលអាចធ្វើទៅបាន។ ខ្ញុំ​គិត​ថា​ការ​អភិវឌ្ឍ​ត្រូវ​ដោះស្រាយ​ជាមួយ​នឹង​កិច្ចការ​របស់​ខ្លួន​ដោយ​សំឡេង​ខ្លាំង។

ប្លុកកូដ នីតិវិធី និងមុខងារ

សំណង់ទាំងអស់នៅក្នុងភាសាត្រូវបានបើកដោយសញ្ញា។ : ហើយត្រូវបានបិទដោយប្រតិបត្តិករ បញ្ចប់.

នីតិវិធី និងមុខងារត្រូវបានប្រកាសថាជា proc និង func រៀងគ្នា។ អាគុយម៉ង់ត្រូវបានរាយក្នុងវង់ក្រចក។ អ្វីគ្រប់យ៉ាងគឺដូចជាភាសាផ្សេងទៀតភាគច្រើន។

ប្រតិបត្តិករ ត្រឡប់មកវិញ អ្នកអាចត្រឡប់តម្លៃពីអនុគមន៍ ប្រតិបត្តិករ បំបែក អនុញ្ញាតឱ្យអ្នកចេញពីនីតិវិធី / មុខងារ (ប្រសិនបើវានៅខាងក្រៅរង្វិលជុំ) ។

កូដគំរូ៖

...

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

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

ការរចនាដែលគាំទ្រ

• រង្វិលជុំ៖ សម្រាប់..បញ្ចប់ ខណៈពេល..បញ្ចប់ រហូតដល់..បញ្ចប់
• លក្ខខណ្ឌ៖ if..[else..] end, switch..[case..end..][else..] end
• វិធីសាស្រ្ត៖ proc <name>():... end, func <name>():... end
• Label & goto: <name>:, jump <name>
• ការ​រាប់​បញ្ចូល​គ្នា​និង​អារេ​ថេរ។

អថេរ

អ្នកបកប្រែអាចកំណត់ពួកវាដោយស្វ័យប្រវត្តិ ឬប្រសិនបើអ្នកអភិវឌ្ឍន៍សរសេរ 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

លទ្ធផលនឹង៖ ពិត, ពិត។

អំពីប្រតិបត្តិករចាត់តាំង និងសញ្ញាចង្អុលច្បាស់លាស់

ប្រតិបត្តិករ ?= ត្រូវ​បាន​ប្រើ​ដើម្បី​កំណត់​អថេរ​ទ្រនិច​ទៅ​តម្លៃ​ក្នុង​អង្គ​ចងចាំ។
ប្រតិបត្តិករ = ផ្លាស់ប្តូរតម្លៃក្នុងអង្គចងចាំដោយប្រើទ្រនិចពីអថេរ។
ហើយឥឡូវនេះបន្តិចអំពីទ្រនិចច្បាស់លាស់។ ខ្ញុំបានបន្ថែមពួកវាទៅក្នុងភាសាដើម្បីឱ្យពួកគេមាន។
@<variable> — យកទ្រនិចជាក់លាក់មួយទៅអថេរ។
?<variable> — ទទួលបានអថេរដោយទ្រនិច។
@= — កំណត់តម្លៃទៅអថេរដោយទ្រនិចច្បាស់លាស់ទៅវា។

កូដគំរូ៖

uses <bf>
uses <crt>

proc main():
  var a = 10, b
  b ?= @a
  PrintLn(b)
  b ?= ?b
  PrintLn(b)
  b++
  PrintLn(a)
  InputLn()
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