አዲስ የፕሮግራም ቋንቋ Mash

ለብዙ ዓመታት የራሴን የፕሮግራሚንግ ቋንቋ ለማዳበር እጄን ሞከርኩ። በእኔ አስተያየት በጣም ቀላል፣ ሙሉ በሙሉ የሚሰራ እና ምቹ ቋንቋ መፍጠር ፈልጌ ነበር።

በዚህ ጽሑፍ ውስጥ የሥራዬን ዋና ደረጃዎች ለማጉላት እፈልጋለሁ እና በመጀመር, የተፈጠረውን የቋንቋ ጽንሰ-ሀሳብ እና የመጀመሪያ አተገባበሩን አሁን እየሰራሁ ነው.

አስቀድሜ ልናገር ሙሉውን ፕሮጄክት በፍሪ ፓስካል የፃፍኩት ነው ምክንያቱም... በእሱ ላይ ያሉ ፕሮግራሞች ለብዙ የመሣሪያ ስርዓቶች ሊሰበሰቡ ይችላሉ ፣ እና አቀናባሪው ራሱ በጣም የተመቻቹ ሁለትዮሾችን ያዘጋጃል (ሁሉንም የፕሮጀክቱን ክፍሎች በ O2 ባንዲራ እሰበስባለሁ)።

የቋንቋ ሩጫ ጊዜ

በመጀመሪያ ፣ በቋንቋዬ የወደፊት አፕሊኬሽኖችን ለማሄድ መጻፍ ስላለብኝ ምናባዊ ማሽን ማውራት ጠቃሚ ነው። ቁልል አርክቴክቸርን ተግባራዊ ለማድረግ ወሰንኩ፣ ምናልባትም፣ ቀላሉ መንገድ ስለሆነ። ይህንን በሩሲያኛ እንዴት ማድረግ እንዳለብኝ አንድ የተለመደ ጽሑፍ አላገኘሁም, ስለዚህ በእንግሊዝኛ ቋንቋ ራሴን ካወቅኩ በኋላ, የራሴን ብስክሌት ለመንደፍ እና ለመጻፍ ተቀመጥኩ. በመቀጠል በዚህ ጉዳይ ላይ የእኔን "የላቁ" ሀሳቦች እና እድገቶች አቀርባለሁ.

የቁልል ትግበራ

በግልጽ ለማየት እንደሚቻለው, በቪኤም አናት ላይ ያለው ቁልል ነው. በእኔ አተገባበር ውስጥ በብሎኮች ውስጥ ይሠራል. በመሰረቱ ይህ ቀላል የጠቋሚዎች ድርድር እና የቁልል የላይኛውን መረጃ ጠቋሚ ለማከማቸት ተለዋዋጭ ነው።
ሲጀመር 256 ንጥረ ነገሮች ድርድር ይፈጠራል። ተጨማሪ ጠቋሚዎች ወደ ቁልል ከተገፉ፣ መጠኑ በሚቀጥሉት 256 ንጥረ ነገሮች ይጨምራል። በዚህ መሠረት ንጥረ ነገሮችን ከቁልል ውስጥ ሲያስወግዱ መጠኑ ይስተካከላል.

VM በርካታ ቁልል ይጠቀማል፡-

1. ዋና ቁልል.
2. የመመለሻ ነጥቦችን ለማከማቸት ቁልል.
3. የቆሻሻ ሰብሳቢ ቁልል.
4. ይሞክሩ/ያዝ/በመጨረሻ የተቆጣጣሪ ቁልል አግድ።

ቋሚዎች እና ተለዋዋጮች

ይሄኛው ቀላል ነው። ኮንስታንት በተለየ ትንሽ የኮድ ቁራጭ ይያዛሉ እና ለወደፊት አፕሊኬሽኖች በስታቲክ አድራሻዎች ይገኛሉ። ተለዋዋጮች የተወሰነ መጠን ያላቸው የጠቋሚዎች ስብስብ ናቸው, ወደ ሴሎቹ መድረስ በመረጃ ጠቋሚ ይከናወናል - ማለትም. የማይንቀሳቀስ አድራሻ. ተለዋዋጮች ወደ ቁልል አናት ሊገፉ ወይም ከዚያ ሊነበቡ ይችላሉ። በእውነቱ, ምክንያቱም የእኛ ተለዋዋጮች በመሠረቱ ጠቋሚዎችን ወደ እሴቶች በVM ማህደረ ትውስታ ውስጥ ሲያከማቹ፣ ቋንቋው የሚቆጣጠረው ከተዘዋዋሪ ጠቋሚዎች ጋር በመስራት ነው።

ቆሻሻ ሰብሳቢ

በእኔ ቪኤም ውስጥ ከፊል-አውቶማቲክ ነው. እነዚያ። ገንቢው ራሱ የቆሻሻ ሰብሳቢውን መቼ እንደሚጠራ ይወስናል. እንደ ፓይዘን፣ ፐርል፣ ሩቢ፣ ሉአ፣ ወዘተ የመሳሰሉ መደበኛ ጠቋሚ ቆጣሪዎችን በመጠቀም አይሰራም። የሚተገበረው በጠቋሚ ስርዓት ነው. እነዚያ። ተለዋዋጭ ጊዜያዊ እሴት ለመመደብ ሲታቀድ፣ የዚህ እሴት ጠቋሚ ወደ ቆሻሻ ሰብሳቢው ቁልል ይጨመራል። ለወደፊቱ, ሰብሳቢው ቀድሞውኑ በተዘጋጀው የጠቋሚዎች ዝርዝር ውስጥ በፍጥነት ይሮጣል.

መሞከር/መያዝ/በመጨረሻ ማገድ

እንደ ማንኛውም ዘመናዊ ቋንቋ፣ ልዩ አያያዝ አስፈላጊ አካል ነው። የቪኤም ኮር በሙከራ..catch block ተጠቅልሏል፣ይህም የተለየ መረጃን ወደ ቁልል በመጫን ወደ ኮድ አፈፃፀም ሊመለስ ይችላል። በአፕሊኬሽን ኮድ ውስጥ መሞከር/መያዝ/በመጨረሻም የኮድ ብሎኮችን መግለጽ ይችላሉ፣የሚያዙበትን ቦታ (ከተቆጣጣሪ በስተቀር) እና በመጨረሻ/መጨረሻ (የእገዳው መጨረሻ) ይግለጹ።

ባለ ብዙ ማነበብ

በቪኤም ደረጃ ይደገፋል. ለመጠቀም ቀላል እና ምቹ ነው። ያለማቋረጥ ስርዓት ይሰራል, ስለዚህ ኮዱ በበርካታ ክሮች ውስጥ ብዙ ጊዜ በፍጥነት መከናወን አለበት.

የውጪ ቤተ-መጻሕፍት ለቪኤም

ያለዚህ ምንም ማድረግ አይቻልም. VM በሌሎች ቋንቋዎች እንዴት እንደሚተገበር አይነት ከውጭ የሚመጡ ምርቶችን ይደግፋል። የኮዱን ከፊል በማሽ እና የኮዱን ከፊሉን በአፍ መፍቻ ቋንቋዎች መፃፍ እና ከዚያ ወደ አንድ ማገናኘት ይችላሉ።

ከከፍተኛ ደረጃ የማሽ ቋንቋ ወደ ባይትኮድ ለቪኤምዎች ተርጓሚ

መካከለኛ ቋንቋ

ተርጓሚ ከተወሳሰበ ቋንቋ ወደ VM ኮድ በፍጥነት ለመጻፍ፣ መጀመሪያ መካከለኛ ቋንቋ ፈጠርኩ። ውጤቱ እዚህ ግምት ውስጥ ምንም የተለየ ነጥብ የሌለበት ሰብሳቢ የሚመስል አስፈሪ ትዕይንት ነበር። በዚህ ደረጃ ተርጓሚው ብዙ ቋሚዎችን እና ተለዋዋጮችን ያካሂዳል ፣ የማይንቀሳቀስ አድራሻቸውን እና የመግቢያ ነጥቦችን አድራሻ ያሰላል እላለሁ ።

ተርጓሚ አርክቴክቸር

ለትግበራ ምርጡን አርክቴክቸር አልመረጥኩም። ሌሎች ተርጓሚዎች እንደሚያደርጉት ተርጓሚው የኮድ ዛፍ አይገነባም። እሱ የአሠራሩን መጀመሪያ ይመለከታል. እነዚያ። እየተተነተነ ያለው የኮድ ቁራጭ “በ<ሁኔታ> ላይ” የሚመስል ከሆነ፣ ይህ ለተወሰነ ጊዜ ሉፕ ግንባታ እንደሆነ እና ለተወሰነ ጊዜ loop ሲገነባ መከናወን እንዳለበት ግልጽ ነው። እንደ ውስብስብ መቀየሪያ መያዣ ያለ ነገር።

ለዚህ የስነ-ህንፃ መፍትሄ ምስጋና ይግባውና ተርጓሚው በጣም ፈጣን አይደለም. ይሁን እንጂ የመቀየሩ ቀላልነት በከፍተኛ ሁኔታ ጨምሯል. ቡናዬ ሊቀዘቅዝ ከሚችለው በላይ አስፈላጊዎቹን መዋቅሮች በፍጥነት ጨምሬያለሁ. ሙሉ የOOP ድጋፍ ከአንድ ሳምንት ባነሰ ጊዜ ውስጥ ተተግብሯል።

ኮድ ማመቻቸት

እዚህ ፣ በእርግጥ ፣ በተሻለ ሁኔታ ሊተገበር ይችል ነበር (እና ይተገበራል ፣ ግን በኋላ ፣ አንድ ሰው ወደ እሱ እንደመጣ)። እስካሁን ድረስ አመቻቹ የሚያውቀው ጥቅም ላይ ያልዋለውን ኮድ, ቋሚ እና ከስብሰባ ወደ ሀገር ውስጥ የሚገቡትን እንዴት እንደሚቆረጥ ብቻ ነው. እንዲሁም, ተመሳሳይ እሴት ያላቸው በርካታ ቋሚዎች በአንድ ይተካሉ. ይኼው ነው.

ማሽ ቋንቋ

መሰረታዊ የቋንቋ ጽንሰ-ሀሳብ

ዋናው ሃሳብ በተቻለ መጠን ተግባራዊ እና ቀላል ቋንቋን ማዳበር ነበር። እኔ እንደማስበው ልማቱ ሥራውን በብጥብጥ ይቋቋማል።

ኮድ ብሎኮች, ሂደቶች እና ተግባራት

በቋንቋው ውስጥ ያሉ ሁሉም ግንባታዎች በኮሎን ተከፍተዋል. : እና በኦፕሬተሩ ተዘግተዋል መጨረሻ.

ቅደም ተከተሎች እና ተግባራት እንደ ቅደም ተከተላቸው እንደ ፕሮክ እና አዝናኝ ታውጃል። ክርክሮቹ በቅንፍ ውስጥ ተዘርዝረዋል. ሁሉም ነገር ልክ እንደሌሎች ቋንቋዎች ነው።

ኦፕሬተር መመለስ ዋጋን ከአንድ ተግባር ፣ ከዋኝ መመለስ ይችላሉ። ቆረጣ የአሰራር ሂደቱን / ተግባሩን (ከሉፕስ ውጭ ከሆነ) ለመውጣት ያስችልዎታል.

የኮድ ምሳሌ፡-

...

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

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

የሚደገፉ ንድፎች

• ቀለበቶች፡ ለ..መጨረሻ፣ ሳለ.. መጨረሻ፣ እስከ.. መጨረሻ
• ሁኔታዎች፡- ከሆነ...[ሌላ..] ካለቀ፣ ቀይር
• ዘዴዎች፡ proc <ስም>():...መጨረሻ፣func <ስም>():... መጨረሻ
• መለያ & goto: <ስም>:, ዝለል <ስም>
• የቁጥር ቁጥሮች እና ቋሚ ድርድሮች።

ተለዋዋጮች

ተርጓሚው በራስ-ሰር ሊወስናቸው ይችላል፣ ወይም ገንቢው እነሱን ከመግለጽ በፊት 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።

ይሞክሩ..[መያዝ..][ በመጨረሻ..] መጨረሻ

የኮድ ምሳሌ፡-

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 compiler የለውም፣ ስለዚህ በአፈጻጸም ረገድ በአሁኑ ጊዜ ከፓይዘን ጋር ብቻ ነው የሚወዳደረው። በGalVM ወይም LLVM ላይ በመመስረት የጂአይቲ ማጠናቀርን ተግባራዊ ማድረግ እንደምችል ተስፋ አደርጋለሁ።

ማከማቻ

ከእድገቱ ጋር መጫወት እና ፕሮጀክቱን እራስዎ መከተል ይችላሉ.

ድር ጣቢያ
GitHub ላይ ማከማቻ

ካነበብክ እስከ መጨረሻው ስላነበብክ እናመሰግናለን።

ምንጭ: hab.com