שפת תכנות חדשה Mash

במשך כמה שנים ניסיתי את כוחי בפיתוח שפת תכנות משלי. רציתי ליצור, לדעתי, את השפה הכי פשוטה, פונקציונלית ונוחה שאפשר.

במאמר זה אני רוצה להדגיש את השלבים המרכזיים בעבודתי ולכתחילה לתאר את תפיסת השפה שנוצרה ויישומה הראשון, עליו אני עובד כעת.

הרשו לי לומר מראש שכתבתי את כל הפרויקט בפסקל חופשי, כי... ניתן להרכיב תוכניות עליו למספר עצום של פלטפורמות, והמהדר עצמו מייצר קבצים בינאריים אופטימליים מאוד (אני אוסף את כל רכיבי הפרויקט עם דגל O2).

זמן ריצה של שפה

קודם כל, כדאי לדבר על המכונה הוירטואלית שהייתי צריך לכתוב כדי להפעיל יישומים עתידיים בשפה שלי. החלטתי ליישם ארכיטקטורת מחסנית, אולי, כי זו הייתה הדרך הקלה ביותר. לא מצאתי מאמר נורמלי אחד על איך לעשות את זה ברוסית, אז לאחר היכרות עם החומר בשפה האנגלית, ישבתי לעצב ולכתוב את האופניים שלי. בהמשך אציג את הרעיונות והפיתוחים ה"מתקדמים" שלי בעניין זה.

יישום מחסנית

ברור שבחלק העליון של ה-VM נמצאת הערימה. ביישום שלי זה עובד בבלוקים. בעיקרו של דבר זהו מערך פשוט של מצביעים ומשתנה לאחסון האינדקס של החלק העליון של הערימה.
כאשר הוא מאותחל, נוצר מערך של 256 אלמנטים. אם מצביעים נוספים נדחפים אל הערימה, הגודל שלה גדל ב-256 האלמנטים הבאים. בהתאם לכך, בעת הסרת אלמנטים מהערימה, גודלו מותאם.

ה-VM משתמש במספר ערימות:

1. מחסנית ראשית.
2. ערימה לאחסון נקודות החזרה.
3. ערימת אספנים.
4. נסה/תפוס/לבסוף חסום את ערימת המטפל.

קבועים ומשתנים

זה פשוט. קבועים מטופלים בחתיכת קוד קטנה נפרדת וזמינים ביישומים עתידיים באמצעות כתובות סטטיות. משתנים הם מערך של מצביעים בגודל מסוים, הגישה לתאים שלו מתבצעת על ידי אינדקס - כלומר. כתובת סטטית. ניתן לדחוף משתנים לראש הערימה או לקרוא משם. בעצם, כי בעוד שהמשתנים שלנו בעצם מאחסנים מצביעים לערכים בזיכרון VM, השפה נשלטת על ידי עבודה עם מצביעים מרומזים.

אוסף זבל

ב-VM שלי זה חצי אוטומטי. הָהֵן. היזם עצמו מחליט מתי להתקשר לאספן האשפה. זה לא עובד באמצעות מונה מצביע רגיל, כמו ב-Python, Perl, Ruby, Lua וכו'. זה מיושם באמצעות מערכת סמנים. הָהֵן. כאשר משתנה מיועד להקצות ערך זמני, מצביע לערך זה מתווסף לערימת אספן האשפה. בעתיד, האספן עובר במהירות את רשימת המצביעים שהוכנה כבר.

טיפול בניסיון/לתפוס/בסוף בלוקים

כמו בכל שפה מודרנית, טיפול בחריגים הוא מרכיב חשוב. ליבת ה-VM עטופה בלוק try..catch, שיכול לחזור לביצוע קוד לאחר תפיסת חריגה על ידי דחיפת מידע כלשהו לגביו לערימה. בקוד יישום, אתה יכול להגדיר בלוקים של קוד try/catch/finally, ציון נקודות כניסה ב-catch (מטפל בחריג) ולבסוף/סוף (סוף הבלוק).

ריבוי השרשורים

זה נתמך ברמת VM. זה פשוט ונוח לשימוש. זה עובד ללא מערכת פסיקה, כך שהקוד צריך להתבצע במספר שרשורים פי כמה מהר יותר, בהתאמה.

ספריות חיצוניות עבור מחשבי VM

אין דרך לעשות בלי זה. VM תומך בייבוא, בדומה לאופן שבו הוא מיושם בשפות אחרות. אתה יכול לכתוב חלק מהקוד ב-Mash וחלק מהקוד בשפות מקומיות, ואז לקשר אותם לשפות אחת.

מתרגם משפת Mash ברמה גבוהה ל-bytecode עבור מחשבי VM

שפת ביניים

כדי לכתוב במהירות מתרגם משפה מורכבת לקוד VM, פיתחתי תחילה שפת ביניים. התוצאה הייתה מחזה נורא כמו אסמבלר שאין טעם מיוחד להתייחס אליו כאן. אני רק אגיד שברמה זו המתרגם מעבד את רוב הקבועים והמשתנים, מחשב את הכתובות הסטטיות שלהם ואת הכתובות של נקודות הכניסה.

ארכיטקטורת מתרגם

לא בחרתי את הארכיטקטורה הטובה ביותר ליישום. המתרגם אינו בונה עץ קוד, כפי שעושים מתרגמים אחרים. הוא מסתכל על תחילת המבנה. הָהֵן. אם קטע הקוד שמנתח נראה כמו "while <condition>:", אז ברור שזוהי בניית לולאת while ויש לעבד אותה כמבנה לולאת while. משהו כמו מקרה מתג מורכב.

הודות לפתרון הארכיטקטוני הזה, התברר שהמתרגם לא מהיר במיוחד. עם זאת, קלות השינוי שלו גדלה באופן משמעותי. הוספתי את המבנים הדרושים מהר יותר ממה שהקפה שלי יכול להתקרר. תמיכת 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
• Label & Goto: <name>:, jump <name>
• מנה ספירות ומערכים קבועים.

משתנים

המתרגם יכול לקבוע אותם באופן אוטומטי, או אם המפתח כותב 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, אז מבחינת ביצועים היא כרגע תחרותית רק עם Python. אני מקווה שאוכל ליישם קומפילציה של JIT על בסיס GraalVM או LLVM.

מאגר

אתה יכול לשחק עם ההתפתחויות ולעקוב אחר הפרויקט בעצמך.

אתר
מאגר ב-GitHub

תודה שקראת עד הסוף אם קראת.

מקור: www.habr.com