ਮੈਸ਼ ਇੱਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਨੂੰ ਕੰਪਾਇਲ ਕਰਦੀ ਹੈ

ਨਵੇਂ ਸਾਲ 2020 ਦੀਆਂ ਸਾਰਿਆਂ ਨੂੰ ਸ਼ੁਭਕਾਮਨਾਵਾਂ।

ਪਹਿਲੀ ਦੇ ਪ੍ਰਕਾਸ਼ਨ ਦੇ ਬਾਅਦ ਪੋਸਟ ਮੈਸ਼ ਨੂੰ ਲਗਭਗ 1 ਸਾਲ ਬੀਤ ਗਿਆ ਹੈ।

ਇਸ ਸਾਲ ਦੇ ਦੌਰਾਨ, ਭਾਸ਼ਾ ਵਿੱਚ ਬਹੁਤ ਸੁਧਾਰ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸਦੇ ਬਹੁਤ ਸਾਰੇ ਪਹਿਲੂਆਂ ਨੂੰ ਵਿਚਾਰਿਆ ਗਿਆ ਸੀ ਅਤੇ ਵਿਕਾਸ ਦਾ ਵੈਕਟਰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਸੀ।

ਮੈਨੂੰ ਇਹ ਸਭ ਕਮਿਊਨਿਟੀ ਨਾਲ ਸਾਂਝਾ ਕਰਕੇ ਖੁਸ਼ੀ ਹੋ ਰਹੀ ਹੈ।

ਬੇਦਾਅਵਾ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਸਿਰਫ ਉਤਸ਼ਾਹ 'ਤੇ ਵਿਕਸਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਗਤੀਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੇ ਖੇਤਰ ਵਿੱਚ ਵਿਸ਼ਵ ਦੇ ਦਬਦਬੇ ਦਾ ਦਿਖਾਵਾ ਨਹੀਂ ਕਰਦਾ!

ਇਸ ਵਿਕਾਸ ਨੂੰ ਇੱਕ ਮਿਆਰ ਵਜੋਂ ਨਹੀਂ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਲਈ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ; ਪ੍ਰੋਜੈਕਟ ਆਦਰਸ਼ ਨਹੀਂ ਹੈ, ਪਰ ਫਿਰ ਵੀ ਇਹ ਵਿਕਾਸ ਕਰ ਰਿਹਾ ਹੈ.

GitHub
ਦੀ ਵੈੱਬਸਾਈਟ
ਫੋਰਮ

ਨਵਾਂ ਕੰਪਾਈਲਰ

ਪ੍ਰੋਜੈਕਟ ਰਿਪੋਜ਼ਟਰੀ ਦੀ /mashc ਸ਼ਾਖਾ ਵਿੱਚ, ਤੁਸੀਂ ਕੰਪਾਈਲਰ ਦਾ ਇੱਕ ਨਵਾਂ ਸੰਸਕਰਣ ਦੇਖ ਸਕਦੇ ਹੋ, ਜੋ Mash (ਭਾਸ਼ਾ ਦਾ ਪਹਿਲਾ ਸੰਸਕਰਣ) ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।

ਕੰਪਾਈਲਰ ਕੋਲ asm ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਕੋਡ ਜਨਰੇਟਰ ਹੈ (ਇੱਕ ਸਟੈਕ-ਅਧਾਰਿਤ VM ਲਈ ਅਸੈਂਬਲਰ ਲਈ)।
ਵਰਤਮਾਨ ਵਿੱਚ ਮੈਂ Java (JDK 1.8) ਲਈ ਜਨਰੇਟਰ ਦਾ ਇੱਕ ਸੰਸਕਰਣ ਵਿਕਸਤ ਕਰ ਰਿਹਾ ਹਾਂ.

ਕੰਪਾਈਲਰ ਦਾ ਨਵਾਂ ਸੰਸਕਰਣ ਭਾਸ਼ਾ ਦੇ ਪਹਿਲੇ ਸੰਸਕਰਣ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪੂਰਕ ਕਰਦਾ ਹੈ।

ਨਵਾਂ ਓ.ਓ.ਪੀ

ਭਾਸ਼ਾ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਵਿੱਚ, ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਕੰਮ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਹੈ।
ਕਲਾਸ ਵਿਧੀਆਂ ਨੂੰ ਕਲਾਸ ਬਾਡੀ ਵਿੱਚ ਅਤੇ ਇਸਦੇ ਬਾਹਰ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਕਲਾਸ ਵਿੱਚ ਹੁਣ ਇੱਕ ਸਪਸ਼ਟ ਕੰਸਟਰਕਟਰ ਹੈ: 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 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

ਏਮਬੈਡਡ ਭਾਸ਼ਾ

ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ, ਮੈਸ਼ ਲੁਆ ਦੇ ਸਮਾਨ, ਏਮਬੈਡਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਰੂਪ ਵਿੱਚ ਆਪਣਾ ਸਥਾਨ ਲੱਭ ਸਕਦਾ ਹੈ।

ਇਹਨਾਂ ਉਦੇਸ਼ਾਂ ਲਈ ਮੈਸ਼ ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਖੁਦ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਮੈਸ਼ ਵਿੱਚ ਇੱਕ ਰਨਟਾਈਮ ਵਾਤਾਵਰਣ ਹੈ - ਇੱਕ ਸਟੈਕ-ਅਧਾਰਿਤ VM ਇੱਕ ਪੂਰੇ API ਦੇ ਨਾਲ ਇੱਕ ਡਾਇਨਾਮਿਕ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਰੂਪ ਵਿੱਚ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ।

ਤੁਹਾਨੂੰ ਬੱਸ ਇਸ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਨਿਰਭਰਤਾ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਅਤੇ ਕੁਝ ਕਾਲਾਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਭਾਸ਼ਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਏਮਬੈਡਡ ਭਾਸ਼ਾ ਵਜੋਂ ਕੰਮ ਕਰਨ ਲਈ ਕਾਰਜਸ਼ੀਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।
ਉਸੇ ਸਮੇਂ, ਭਾਸ਼ਾ ਅਤੇ ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਸਾਨੂੰ ਇੱਕ ਏਮਬੇਡਡ ਭਾਸ਼ਾ ਮਿਲਦੀ ਹੈ ਜੋ ਇਸ ਵਿੱਚ ਲਿਖੇ ਵੱਖ-ਵੱਖ ਫਰੇਮਵਰਕ ਦੀ ਪੂਰੀ ਸ਼ਕਤੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੀ ਹੈ।

ਮੈਸ਼ + ਜੇਵੀਐਮ

ਮੈਂ JVM ਲਈ ਅਨੁਵਾਦਕ ਦਾ ਇੱਕ ਸੰਸਕਰਣ ਵਿਕਸਿਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕੀਤਾ।
ਸ਼ਾਇਦ, N ਸਮੇਂ ਦੇ ਬਾਅਦ, ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਇੱਕ ਪੋਸਟ Habré' ਤੇ ਦਿਖਾਈ ਦੇਵੇਗੀ.

ਨਤੀਜੇ

ਕੋਈ ਖਾਸ ਨਤੀਜੇ ਨਹੀਂ ਹਨ। ਇਹ ਨਤੀਜਿਆਂ ਦੀ ਇੱਕ ਵਿਚਕਾਰਲੀ ਨੁਮਾਇੰਦਗੀ ਹੈ।
2020 ਵਿੱਚ ਸਾਰਿਆਂ ਲਈ ਸ਼ੁਭਕਾਮਨਾਵਾਂ।

ਸਰੋਤ: www.habr.com