Mash គឺជាភាសាសរសេរកម្មវិធីដែលចងក្រងដោយខ្លួនវាផ្ទាល់

សួស្តីឆ្នាំថ្មី ឆ្នាំសកល ២០២០ ទាំងអស់គ្នា។

ចាប់តាំងពីការបោះពុម្ពលើកដំបូង ប្រកាស ស្ទើរតែ 1 ឆ្នាំបានកន្លងផុតទៅអំពី Mash ។

ក្នុងអំឡុងឆ្នាំនេះ ភាសាត្រូវបានកែលម្អយ៉ាងខ្លាំង ទិដ្ឋភាពជាច្រើនរបស់វាត្រូវបានគិតគូរ ហើយវ៉ិចទ័រនៃការអភិវឌ្ឍន៍ត្រូវបានកំណត់។

ខ្ញុំរីករាយក្នុងការចែករំលែកទាំងអស់នេះជាមួយសហគមន៍។

ការមិនទទួលខុសត្រូវ

គម្រោងនេះកំពុងត្រូវបានបង្កើតឡើងតែលើភាពរីករាយប៉ុណ្ណោះ និងមិនធ្វើពុតជាការគ្រប់គ្រងពិភពលោកនៅក្នុងផ្នែកនៃភាសាសរសេរកម្មវិធីថាមវន្ត!

ការអភិវឌ្ឍន៍នេះមិនគួរត្រូវបានចាត់ទុកថាជាស្តង់ដារដែលត្រូវខិតខំនោះទេ គម្រោងនេះមិនសមស្របទេ ប៉ុន្តែវានៅតែកំពុងអភិវឌ្ឍ។

GitHub
គេហទំព័រ
វេទិកា

កម្មវិធីចងក្រងថ្មី។

នៅក្នុងសាខា /mashc នៃឃ្លាំងគម្រោង អ្នកអាចឃើញកំណែថ្មីនៃកម្មវិធីចងក្រងដែលត្រូវបានសរសេរជា Mash (កំណែដំបូងនៃភាសា)។

កម្មវិធីចងក្រងមានម៉ាស៊ីនបង្កើតកូដនៅក្នុងបញ្ជី asm (សម្រាប់ assembler សម្រាប់ VM ដែលមានមូលដ្ឋានលើ stack)។
បច្ចុប្បន្នខ្ញុំកំពុងបង្កើតកំណែរបស់ម៉ាស៊ីនភ្លើងសម្រាប់ Java (JDK 1.8)។

កំណែថ្មីនៃកម្មវិធីចងក្រងគាំទ្រយ៉ាងពេញលេញនូវមុខងារនៃកំណែដំបូងនៃភាសា និងបំពេញបន្ថែមវា។

OOP ថ្មី។

នៅក្នុងកំណែថ្មីនៃភាសា ការងារជាមួយថ្នាក់ត្រូវបានរៀបចំឡើងវិញដោយផ្នែក។
វិធីសាស្រ្តថ្នាក់អាចត្រូវបានប្រកាសទាំងនៅក្នុងតួនៃថ្នាក់ និងនៅខាងក្រៅវា។
ឥឡូវនេះ ថ្នាក់មានអ្នកសាងសង់ច្បាស់លាស់៖ init ។

កូដគំរូ៖

...
class MyClass:
  private:
    var a, b

  public:
    init(a, b):
      $a ?= a
      $b ?= b
    end

    func Foo():
      return $a + $b   
    end
end

func MyClass::Bar(c):
  return $a + $b + c
end
...

ប្រសិនបើការទទួលមរតកកើតឡើង នោះយើងមានឱកាសបានយ៉ាងងាយស្រួលក្នុងការហៅមរតក (អស្ចារ្យ)។

កូដគំរូ៖

...
class MySecondClass(MyClass):
  public:
    var c

    init(a, b, c):
      super(a, b)
      $c ?= c
    end

    func Bar():
      super($c)  
    end
end
...

x ?= new MySecondClass(10, 20, 30)
println( x -> Bar() )     // 60

ការបដិសេធថាមវន្តនៃវិធីសាស្រ្តនៅលើឧទាហរណ៍ថ្នាក់៖

...
func Polymorph::NewFoo(c):
  return $a + $b + c  
end
...
x -> Foo ?= Polymorph -> NewFoo
x -> Foo(30)    // 60

កញ្ចប់/ចន្លោះឈ្មោះ

ចន្លោះឈ្មោះត្រូវតែស្អាត!
ដូច្នោះហើយ ភាសាត្រូវតែផ្តល់ឱកាសនេះ។
នៅក្នុង Mash ប្រសិនបើ class method គឺឋិតិវន្ត វាអាចត្រូវបានហៅដោយសុវត្ថិភាពពីផ្នែកណាមួយនៃកូដ។

ឧទាហរណ៍:

...
class MyPackage:
  func MyFunc(a, b):
    return a + b  
  end
end
...
println( MyPackage -> MyFunc(10, 20) )    // 30

ដោយវិធីនេះ ប្រតិបត្តិករទំនើបនឹងដំណើរការបានត្រឹមត្រូវនៅពេលហៅតាមវិធីនេះ។

ករណីលើកលែង

នៅក្នុងកំណែថ្មីនៃភាសា ពួកគេត្រូវបានចាត់ទុកដូចជាថ្នាក់៖

...
try:
  raise new Exception(
    "My raised exception!"
  )
catch E:
  if E is Exception:
    println(E)
  else:
    println("Unknown exception class!")
  end
end
...

enum ថ្មី។

ឥឡូវនេះធាតុរាប់បញ្ចូលអាចត្រូវបានកំណត់តម្លៃថេរ៖

enum MyEnum [
  meFirst = "First",
  meSecond = 2,
  meThird
]
...
k ?= meSecond
...
if k in MyEnum:
  ...
end

ភាសាបង្កប់

សក្តានុពល Mash អាចស្វែងរកពិសេសរបស់ខ្លួនជាភាសាសរសេរកម្មវិធីដែលបានបង្កប់ ស្រដៀងទៅនឹង Lua ។

ដើម្បីចាប់ផ្តើមប្រើ Mash សម្រាប់គោលបំណងទាំងនេះ អ្នកមិនចាំបាច់ប្រមូលផ្តុំគម្រោងដោយខ្លួនឯងទេ។

Mash មាន Runtime Environment - VM ផ្អែកលើជង់ដែលបានចងក្រងជាបណ្ណាល័យថាមវន្តជាមួយនឹង API ពេញលេញ។

អ្វីដែលអ្នកត្រូវធ្វើគឺបន្ថែមវាទៅភាពអាស្រ័យនៃគម្រោង ហើយធ្វើការហៅទូរស័ព្ទពីរបីដង។

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

Mash + JVM

ខ្ញុំចាប់ផ្តើមបង្កើតកំណែអ្នកបកប្រែសម្រាប់ JVM ។
ប្រហែលជាបន្ទាប់ពីរយៈពេល N ការបង្ហោះលើប្រធានបទនេះនឹងបង្ហាញនៅលើHabre។

លទ្ធផល

មិនមានលទ្ធផលជាក់លាក់ទេ។ នេះគឺជាការតំណាងកម្រិតមធ្យមនៃលទ្ធផល។
សូមសំណាងល្អទាំងអស់គ្នាក្នុងឆ្នាំ ២០២០។

ប្រភព: www.habr.com