नवीन प्रोग्रामिंग भाषा मॅश

अनेक वर्षांपासून मी माझी स्वतःची प्रोग्रामिंग भाषा विकसित करण्याचा प्रयत्न केला. मला माझ्या मते, शक्य तितकी सोपी, पूर्णपणे कार्यक्षम आणि सोयीची भाषा तयार करायची होती.

या लेखात मी माझ्या कामाचे मुख्य टप्पे हायलाइट करू इच्छितो आणि सुरुवातीला, भाषेची तयार केलेली संकल्पना आणि तिच्या पहिल्या अंमलबजावणीचे वर्णन करू इच्छितो, ज्यावर मी सध्या काम करत आहे.

मी आधीच सांगू इच्छितो की मी संपूर्ण प्रकल्प फ्री पास्कलमध्ये लिहिला आहे, कारण... त्यावरील प्रोग्राम्स मोठ्या संख्येने प्लॅटफॉर्मसाठी एकत्र केले जाऊ शकतात आणि कंपाइलर स्वतःच खूप ऑप्टिमाइझ बायनरी तयार करतो (मी O2 ध्वजासह प्रकल्पाचे सर्व घटक गोळा करतो).

भाषा रनटाइम

सर्व प्रथम, व्हर्च्युअल मशीनबद्दल बोलणे योग्य आहे जे मला माझ्या भाषेत भविष्यातील अनुप्रयोग चालविण्यासाठी लिहावे लागले. मी स्टॅक आर्किटेक्चर लागू करण्याचा निर्णय घेतला, कदाचित, कारण तो सर्वात सोपा मार्ग होता. मला रशियन भाषेत हे कसे करायचे याबद्दल एकही सामान्य लेख सापडला नाही, म्हणून इंग्रजी भाषेतील सामग्रीशी परिचित झाल्यानंतर, मी माझी स्वतःची सायकल डिझाइन आणि लिहायला बसलो. पुढे मी या प्रकरणातील माझ्या "प्रगत" कल्पना आणि घडामोडी सादर करेन.

स्टॅक अंमलबजावणी

अर्थात, व्हीएमच्या शीर्षस्थानी स्टॅक आहे. माझ्या अंमलबजावणीमध्ये ते ब्लॉक्समध्ये कार्य करते. मूलत: हा पॉइंटरचा एक साधा अॅरे आहे आणि स्टॅकच्या वरच्या भागाचा निर्देशांक संचयित करण्यासाठी एक व्हेरिएबल आहे.
जेव्हा ते सुरू केले जाते, तेव्हा 256 घटकांची अॅरे तयार केली जाते. स्टॅकवर अधिक पॉइंटर ढकलल्यास, त्याचा आकार पुढील 256 घटकांनी वाढतो. त्यानुसार, स्टॅकमधून घटक काढून टाकताना, त्याचा आकार समायोजित केला जातो.

VM अनेक स्टॅक वापरते:

1. मुख्य स्टॅक.
2. रिटर्न पॉइंट्स साठवण्यासाठी स्टॅक.
3. कचरा गोळा करणारा स्टॅक.
4. हँडलर स्टॅक वापरून पहा/कॅच करा/शेवटी ब्लॉक करा.

स्थिरांक आणि चल

हे सोपे आहे. स्थिरांक कोडच्या एका वेगळ्या छोट्या तुकड्यात हाताळले जातात आणि स्थिर पत्त्यांद्वारे भविष्यातील अनुप्रयोगांमध्ये उपलब्ध असतात. व्हेरिएबल्स हे एका विशिष्ट आकाराच्या पॉइंटरचे अॅरे आहेत, त्याच्या सेलमध्ये प्रवेश अनुक्रमणिकेद्वारे केला जातो - म्हणजे. स्थिर पत्ता. व्हेरिएबल्स स्टॅकच्या शीर्षस्थानी ढकलले जाऊ शकतात किंवा तेथून वाचले जाऊ शकतात. खरं तर, कारण आमची व्हेरिएबल्स मूलत: व्हीएम मेमरीमधील मूल्यांसाठी पॉइंटर्स संचयित करत असताना, अंतर्निहित पॉइंटर्ससह कार्य करून भाषेचे वर्चस्व आहे.

कचरा गोळा करणारा

माझ्या VM मध्ये ते अर्ध-स्वयंचलित आहे. त्या. कचरा वेचणाऱ्याला कधी कॉल करायचा हे विकसक स्वतः ठरवतो. पायथन, पर्ल, रुबी, लुआ इ. प्रमाणे हे नियमित पॉइंटर काउंटर वापरून कार्य करत नाही. मार्कर प्रणालीद्वारे त्याची अंमलबजावणी केली जाते. त्या. जेव्हा व्हेरिएबलला तात्पुरते मूल्य नियुक्त करायचे असते, तेव्हा या मूल्यासाठी एक पॉइंटर कचरा गोळा करणाऱ्याच्या स्टॅकमध्ये जोडला जातो. भविष्यात, संग्राहक त्वरीत पॉइंटर्सच्या आधीच तयार केलेल्या सूचीमधून धावतात.

प्रयत्न/पकडी/शेवटी अवरोध हाताळणे

कोणत्याही आधुनिक भाषेप्रमाणे, अपवाद हाताळणी हा एक महत्त्वाचा घटक आहे. व्हीएम कोर ट्राय..कॅच ब्लॉकमध्ये गुंडाळलेला आहे, जो अपवाद पकडल्यानंतर त्याबद्दल काही माहिती स्टॅकवर पुश करून कोड एक्झिक्यूशनवर परत येऊ शकतो. ऍप्लिकेशन कोडमध्ये, तुम्ही कोडचे ट्राय/कॅच/शेवटी ब्लॉक्स परिभाषित करू शकता, कॅच (अपवाद हँडलर) आणि शेवटी/एंड (ब्लॉकच्या शेवटी) एंट्री पॉइंट्स निर्दिष्ट करू शकता.

मल्टीथ्रेडिंग

हे VM स्तरावर समर्थित आहे. हे सोपे आणि वापरण्यास सोयीस्कर आहे. हे व्यत्यय प्रणालीशिवाय कार्य करते, म्हणून कोड अनेक थ्रेड्समध्ये अनुक्रमे अनेक वेळा वेगाने कार्यान्वित केला पाहिजे.

VM साठी बाह्य लायब्ररी

याशिवाय मार्ग नाही. व्हीएम इतर भाषांमध्ये कसे अंमलात आणले जाते त्याप्रमाणेच आयातीचे समर्थन करते. तुम्ही कोडचा काही भाग मॅशमध्ये आणि कोडचा काही भाग स्थानिक भाषांमध्ये लिहू शकता, नंतर त्यांना एकामध्ये लिंक करू शकता.

VM साठी उच्च-स्तरीय मॅश भाषेतून बायकोडमध्ये अनुवादक

मध्यवर्ती भाषा

जटिल भाषेतून VM कोडमध्ये अनुवादक पटकन लिहिण्यासाठी, मी प्रथम एक मध्यवर्ती भाषा विकसित केली. परिणाम एक असेंबलरसारखा भयंकर देखावा होता ज्याचा येथे विचार करण्यात काही विशेष अर्थ नाही. मी फक्त असे म्हणेन की या स्तरावर अनुवादक बहुतेक स्थिरांक आणि चलांवर प्रक्रिया करतो, त्यांचे स्थिर पत्ते आणि प्रवेश बिंदूंचे पत्ते मोजतो.

अनुवादक आर्किटेक्चर

मी अंमलबजावणीसाठी सर्वोत्तम आर्किटेक्चर निवडले नाही. इतर अनुवादकांप्रमाणे अनुवादक कोड ट्री बनवत नाही. तो संरचनेच्या सुरुवातीला पाहतो. त्या. जर पार्स केलेला कोडचा भाग “while <condition>:” सारखा दिसत असेल, तर हे स्पष्ट आहे की हे एक while लूप कन्स्ट्रक्ट आहे आणि त्यावर एक while loop construct म्हणून प्रक्रिया करणे आवश्यक आहे. एक जटिल स्विच-केस सारखे काहीतरी.

या आर्किटेक्चरल सोल्यूशनबद्दल धन्यवाद, अनुवादक फार वेगवान नाही. तथापि, त्याच्या सुधारणेची सुलभता लक्षणीय वाढली आहे. माझी कॉफी थंड होण्यापेक्षा मी जलद आवश्यक रचना जोडल्या. पूर्ण OOP समर्थन एका आठवड्यापेक्षा कमी कालावधीत लागू केले गेले.

कोड ऑप्टिमायझेशन

इथे अर्थातच त्याची अंमलबजावणी अधिक चांगल्या प्रकारे करता आली असती (आणि अंमलात आणली जाईल, पण नंतर, जसे की एखाद्याला जवळ येईल तसे). आतापर्यंत, ऑप्टिमायझरला केवळ असेंब्लीमधून न वापरलेले कोड, स्थिरांक आणि आयात कसे कापायचे हे माहित आहे. तसेच, समान मूल्यासह अनेक स्थिरांक एकाने बदलले जातात. इतकंच.

मॅश भाषा

भाषेची मूलभूत संकल्पना

सर्वात कार्यक्षम आणि सोपी भाषा विकसित करणे ही मुख्य कल्पना होती. मला असे वाटते की विकास त्याच्या कार्याचा सामना करतो.

कोड ब्लॉक, कार्यपद्धती आणि कार्ये

भाषेतील सर्व बांधकामे कोलनने उघडली जातात. : आणि ऑपरेटरद्वारे बंद आहेत शेवट.

प्रक्रिया आणि कार्ये अनुक्रमे proc आणि func म्हणून घोषित केली जातात. युक्तिवाद कंसात सूचीबद्ध आहेत. सर्व काही इतर भाषांप्रमाणेच आहे.

ऑपरेटर परत तुम्ही फंक्शन, ऑपरेटरकडून मूल्य परत करू शकता ब्रेक तुम्हाला प्रक्रिया/फंक्शनमधून बाहेर पडण्याची परवानगी देते (जर ते लूपच्या बाहेर असेल).

नमुना कोड:

...

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

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

समर्थित डिझाईन्स

• लूप: for..end, while..end, to..end
• अटी: जर..[else..]एंड करा, स्विच करा..[केस..एंड..][अन्य...]शेवट
• पद्धती: proc <name>():... end, func <name>():... end
• लेबल करा आणि जा: <name>:, जंप <name>
• एनम गणने आणि स्थिर अॅरे.

चल

अनुवादक त्यांना स्वयंचलितपणे निर्धारित करू शकतो, किंवा विकसकाने त्यांना परिभाषित करण्यापूर्वी var लिहिल्यास.

कोड उदाहरणे:

a ?= 10
b ?= a + 20

var a = 10, b = a + 20

जागतिक आणि स्थानिक चल समर्थित आहेत.

OOP

बरं, आम्ही सर्वात स्वादिष्ट विषयावर आलो आहोत. मॅश सर्व ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग पॅराडाइम्सचे समर्थन करते. त्या. वर्ग, वारसा, बहुरूपता (डायनॅमिकसह), डायनॅमिक स्वयंचलित प्रतिबिंब आणि आत्मनिरीक्षण (पूर्ण).

पुढील अडचण न करता, फक्त कोड उदाहरणे देणे चांगले आहे.

एक साधा वर्ग आणि त्यासह कार्य करणे:

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

आउटपुट होईल: काही संख्या, 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 कंपाइलर नाही, त्यामुळे कार्यक्षमतेच्या बाबतीत ते सध्या केवळ पायथनशी स्पर्धात्मक आहे. मला आशा आहे की मी GraalVM किंवा LLVM वर आधारित JIT संकलन कार्यान्वित करू शकेन.

भांडार

आपण घडामोडींसह खेळू शकता आणि स्वतः प्रकल्पाचे अनुसरण करू शकता.

वेबसाइट
GitHub वर रेपॉजिटरी

आपण केले असल्यास शेवटपर्यंत वाचल्याबद्दल धन्यवाद.

स्त्रोत: www.habr.com