ಮ್ಯಾಶ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದ್ದು ಅದು ಸ್ವತಃ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ

2020 ರ ಹೊಸ ವರ್ಷದಲ್ಲಿ ಎಲ್ಲರಿಗೂ ಶುಭಾಶಯಗಳು.

ಮೊದಲನೆಯದನ್ನು ಪ್ರಕಟಿಸಿದಾಗಿನಿಂದ ಉಪವಾಸ ಮಾಶ್ ಬಗ್ಗೆ ಸರಿಯಾಗಿ 1 ವರ್ಷ ಕಳೆದಿದೆ.

ಈ ವರ್ಷದಲ್ಲಿ, ಭಾಷೆಯನ್ನು ಹೆಚ್ಚು ಸುಧಾರಿಸಲಾಯಿತು, ಅದರ ಹಲವು ಅಂಶಗಳನ್ನು ಯೋಚಿಸಲಾಯಿತು ಮತ್ತು ಅಭಿವೃದ್ಧಿಯ ವೆಕ್ಟರ್ ಅನ್ನು ನಿರ್ಧರಿಸಲಾಯಿತು.

ಇದೆಲ್ಲವನ್ನೂ ಸಮುದಾಯದೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಲು ನನಗೆ ಸಂತೋಷವಾಗಿದೆ.

ಹಕ್ಕುತ್ಯಾಗ

ಈ ಯೋಜನೆಯನ್ನು ಕೇವಲ ಉತ್ಸಾಹದ ಮೇಲೆ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಡೈನಾಮಿಕ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ಕ್ಷೇತ್ರದಲ್ಲಿ ವಿಶ್ವದ ಪ್ರಾಬಲ್ಯವನ್ನು ನಟಿಸುವುದಿಲ್ಲ!

ಈ ಅಭಿವೃದ್ಧಿಯನ್ನು ಶ್ರಮಿಸಬೇಕಾದ ಮಾನದಂಡವೆಂದು ಪರಿಗಣಿಸಬಾರದು; ಯೋಜನೆಯು ಸೂಕ್ತವಲ್ಲ, ಆದರೆ ಅದು ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತಿದೆ.

GitHub
ವೆಬ್ಸೈಟ್
ವೇದಿಕೆ

ಹೊಸ ಕಂಪೈಲರ್

ಪ್ರಾಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿಯ / mashc ಶಾಖೆಯಲ್ಲಿ, ನೀವು ಕಂಪೈಲರ್‌ನ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ನೋಡಬಹುದು, ಅದನ್ನು ಮ್ಯಾಶ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ (ಭಾಷೆಯ ಮೊದಲ ಆವೃತ್ತಿ).

ಕಂಪೈಲರ್ asm ಲಿಸ್ಟಿಂಗ್‌ನಲ್ಲಿ ಕೋಡ್ ಜನರೇಟರ್ ಅನ್ನು ಹೊಂದಿದೆ (ಸ್ಟಾಕ್-ಆಧಾರಿತ VM ಗಾಗಿ ಅಸೆಂಬ್ಲರ್‌ಗಾಗಿ).
ಪ್ರಸ್ತುತ ನಾನು ಜಾವಾ (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

ಪ್ಯಾಕೇಜುಗಳು/ಹೆಸರುಗಳು

ನಾಮಸ್ಪೇಸ್ ಸ್ವಚ್ಛವಾಗಿರಬೇಕು!
ಅದರಂತೆ, ಭಾಷೆ ಈ ಅವಕಾಶವನ್ನು ಒದಗಿಸಬೇಕು.
ಮ್ಯಾಶ್‌ನಲ್ಲಿ, ವರ್ಗ ವಿಧಾನವು ಸ್ಥಿರವಾಗಿದ್ದರೆ, ಅದನ್ನು ಕೋಡ್‌ನ ಯಾವುದೇ ಭಾಗದಿಂದ ಸುರಕ್ಷಿತವಾಗಿ ಕರೆಯಬಹುದು.

ಉದಾಹರಣೆ:

...
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 MyEnum [
  meFirst = "First",
  meSecond = 2,
  meThird
]
...
k ?= meSecond
...
if k in MyEnum:
  ...
end

ಎಂಬೆಡೆಡ್ ಭಾಷೆ

ಸಂಭಾವ್ಯವಾಗಿ, ಲುವಾಗೆ ಹೋಲುವ ಒಂದು ಎಂಬೆಡೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿ ಮ್ಯಾಶ್ ತನ್ನ ಸ್ಥಾನವನ್ನು ಕಂಡುಕೊಳ್ಳಬಹುದು.

ಈ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮ್ಯಾಶ್ ಅನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಯೋಜನೆಯನ್ನು ನೀವೇ ಜೋಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಮ್ಯಾಶ್ ರನ್ಟೈಮ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿದೆ - ಪೂರ್ಣ API ನೊಂದಿಗೆ ಡೈನಾಮಿಕ್ ಲೈಬ್ರರಿಯಾಗಿ ಕಂಪೈಲ್ ಮಾಡಲಾದ ಸ್ಟಾಕ್-ಆಧಾರಿತ VM.

ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಯೋಜನೆಯ ಅವಲಂಬನೆಗೆ ಸೇರಿಸಿ ಮತ್ತು ಒಂದೆರಡು ಕರೆಗಳನ್ನು ಮಾಡಿ.

ಎಂಬೆಡೆಡ್ ಭಾಷೆಯಾಗಿ ಕೆಲಸ ಮಾಡಲು ಭಾಷೆ ಸ್ವತಃ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಅದೇ ಸಮಯದಲ್ಲಿ, ಭಾಷೆ ಮತ್ತು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗಳ ಜೊತೆಗಿನ ಕಾರ್ಯಕ್ಷಮತೆಯು ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.
ಅದರಲ್ಲಿ ಬರೆಯಲಾದ ವಿವಿಧ ಚೌಕಟ್ಟುಗಳ ಸಂಪೂರ್ಣ ಶಕ್ತಿಯನ್ನು ಬಳಸಬಹುದಾದ ಎಂಬೆಡೆಡ್ ಭಾಷೆಯನ್ನು ನಾವು ಪಡೆಯುತ್ತೇವೆ.

ಮ್ಯಾಶ್ + ಜೆವಿಎಂ

ನಾನು JVM ಗಾಗಿ ಭಾಷಾಂತರಕಾರನ ಆವೃತ್ತಿಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಪ್ರಾರಂಭಿಸಿದೆ.
ಬಹುಶಃ, N ಸಮಯದ ನಂತರ, ಈ ವಿಷಯದ ಕುರಿತು ಪೋಸ್ಟ್ ಹಬ್ರೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಫಲಿತಾಂಶಗಳು

ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಫಲಿತಾಂಶಗಳಿಲ್ಲ. ಇದು ಫಲಿತಾಂಶಗಳ ಮಧ್ಯಂತರ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ.
2020 ರಲ್ಲಿ ಎಲ್ಲರಿಗೂ ಶುಭವಾಗಲಿ.

ಮೂಲ: www.habr.com