Create A Programming Language - The Easiest Way

1

1 +  2 + 3

1

I Love You

1

mkdir calcLang

1
2
3

cd calcLang
touch parser.js
npm init -y 

1

npm install --save nearley

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

const nearley = require("nearley");
const grammar = require("./grammar.js");

// Create a Parser object from our grammar.
const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));

// Parse something!
parser.feed("foo\n");

// parser.results is an array of possible parsings.
console.log(parser.results); // [[[[ "foo" ],"\n" ]]]

1

touch grammar.ne

1

number -> [0-9]:+

1

npx nearleyc grammar.ne -o grammar.js

1

[ [ [ '1' ] ] ]

1
2
3

number -> [0-9]:+ {%
data => data[0]
%}

1

npx nearleyc grammar.ne -o grammar.js

1
2
3

{%
data => data[0]
%}

1

number -> [0-9]:+ {% id %}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# ကျွန်တော်တို့ရဲ့ Language Design က 1 +1 ဖြစ်တဲ့အတွက် Expression မဧနဲ့အတူတူပဲတယ်။ဒီ့အတွက် ကျွန်တော်တို့ရဲ့ Program သည် Expression တွေပဲဖြစ်ပါတယ်လို့ကြေညာလိုက်ပါတယ်။ Index 0 ကိုပဲလိုချင်တာဖြစ်လို့ {% id %} ကိုသုံးထားတာဖြစ်ပါတယ်။

program -> expressions {% id %}

# ခု Expression တွေကို သတ်မှတ်ပါမယ်။
# Expression ဆိုတာ Expression တစ်ခုသို့မဟုတ် Expression အကြောင်းများစွာပါနေတဲ့ကောင်ဖြစ်ပါတယ်။
# Pipe Sign (|) သည် OR ကိုပြောတာဖြစ်ပါတယ်။
expressions -> _ expression _ {% 
                data => [data[1]]
              %}
            |  _ expression _ "\n" expressions {%
                data => [data[1],...data[4]]
              %}

# Expression တစ်ခုသည် Unary Expression (သို့မဟုတ်) Binary Expression လည်းဖြစ်နိုင်တယ်။
# Unary Expression ဆိုတာ တစ်ခုတည်းရှိတဲ့ကောင်တွေကိုပြောတာပါ။
# ဉပမာ 1,name စသဖြင့်။
# Binary Expression ဆိုတာ Root နဲ့ Node နှစ်ခုပါတဲ့ကောင်တွေကိုပြောဖြစ်ပါတယ်။
# ဉပမာ 1 + 2 သည် Binary Expression ဖြစ်ပါတယ်။အဘယ့်ကြောင့်ဆိုသော် + Root ရဲ့ ညာဘက်မှာ 1 ၊ ဘယ်ဘက်မှာ 2 ရှိနေလို့ဖြစ်ပါတယ်။
expression -> unary_expression {% id %} | binary_expression {% id %}

# Unary Expression ဆိုတာ Number လည်းဖြစ်နိုင်တယ်။
unary_expression -> number {% id %}

# Binary Expression‌ ဆိုတာ Unary Expression Operator နဲ့ Expression ကြီးတစ်ခုလုံးလည်းဖြစ်နိုင်တယ်။
# Expression တစ်ခုလုံးဖြစ်နိုင်တယ်ဆိုတာက 1 + 2 + 3 မှာ 1 သည် Unary Expression လို့မှတ်ယူလို့ရတယ်။ 2 + 3 ကြတော့ Binary Expression ဖြစ်တယ်။ Binary Expression သည် Expression ပဲဖြစ်တဲ့အတွက် Expression လို့ပုန်ခေါ်လိုက်တာဖြစ်တယ်။ Unary Expression ကြ‌တော့တစ်ခုတည်းမို့လို့ဖြစ်ပါတယ်။

binary_expression -> unary_expression _ operator _ expression {%

# ခု Expression ကရလာတဲ့ Data တွေကို Type နဲ့ Value သတ်မှတ်ပြီး Return ပြန်ပေးလိုက်ပါတယ်။
# Data တွေရဲ့ Index No စရေတဲ့အခါ -> ရဲ့ ‌ဘာဘက်ကနေစရေရပါတယ်။
data => {
    return {
        type: "binary_expression",
        rop: data[0],
        operator: data[2],
        lop: data[4]
    }
}

%}

# Operator သည် အပေါင်း (သို့မဟုတ်) အနှုတ်ဖြစ်နိုင်တယ်လို့သတ်မှတ်လိုက်ပါတယ်။ဆိုလိုတာက နှစ်ခုလုံးလက်ခံတယ်လို့ပြောချင်တာပါ။
operator -> "+" {% id %} 
          | "-" {% id %}

# Number သည် Decimal လည်းဖြစ်နိုင်သလို Digit လည်းဖြစ်နိုင်တယ်။
number -> decimal {% id %}
        | digit {% id %}

# Decimal သည် Digit နှစ်ခုကို Dot (.) နှင့်ဆက်ထားတာဖြစ်တယ်။
decimal -> digit "." digit {%

# String ဖြစ်နေတဲ့အတွက် Number ကိုပြောင်းပေးလိုက်တာပါ။
data => Number(data[0] + "." + data[2])

%}

# Digit သည် 0 ကနေ 9 ထိတစ်လုံး (သို့မဟုတ်) တစ်လုံးထက်ပိုမယ်လို့သတ်မှတ်လိုက်တာပါ။
digit -> [0-9]:+ {%

# Parse Tree ကနေထွက်လာမယ့် ကောင်(Token)တွေက Array Element တွေဖြစ်နေတဲ့အတွက်တစ်စုတစ်စည်းတည်း Join ပြီး Number ပြောင်းပေးလိုက်ပါတယ်။
# ဉပမာ - 123 ကို Parse လုပ်ရင်  [[['1','2','3']]] ထွင်လာမယ်။ Join လိုက်တဲ့အခါ ['123'] ဖြစ်သွားမှာဖြစ်တယ်။
data => Number(data[0].join(''))

%}

# _ (Optional White Space) သည်  Space (သို့မဟုတ်) Tab ပါလည်းရတယ်။မပါလည်းရတယ်။
_ -> [\s\t]:*

# __ (Space) အနည်းဆုံးတစ်ခုနှင့်တစ်ခုထက်ပိုရှိဖို့လိုအပ်တယ်။
__ -> [\s]:+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

const nearley = require("nearley");
const grammar = require("./grammar.js");

/*ဖိုင်တွေ Read ဖို့ Write ဖို့လိုအပ်တဲ့အတွက် FS Module ကို Import လိုက်ပါတယ်။*/
const fs = require('fs');

// Parser Instance Object တစ်ခုတည်ဆောက်လိုက်ပါတယ်။
const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));

// CLI ကနေဝင်လာမဲ့ Program File Name ကိုယူလိုက်ပါတယ်။
const fileName = process.argv[2];

// Source Code တွေကို FS Module သုံးပြီးဖတ်လိုက်ပါတယ်။
const sourceCodes = fs.readFile(fileName, (err, data) => {
    if (err) throw err; // ဖိုင်ဖတ်လို့မရတဲ့အခါ Error ပြန်ပေးမှာပါ။

    /*File ကိုဖတ်လို့ရတဲ့ Data တွေကို String အဖြစ်ပြောင်းပြီး Parse ဆိုတဲ့ Function ကိုပို့ပေးလိုက်ပါတယ်။*/
    parse(data.toString())
})

/*Parse Function က Data တွေကိုလက်ခံပါတယ်။*/
const parse = (data) => {
    try {
        /*Parser ကနေ Parse လုပ်ပါတယ်။*/
        parser.feed(data);
        /*Parse လုပ်လို့အမှားမတွေ့ရင် AST အဖြစ်သိုလှောင်လိုက်တယ်။
   */ const AST = parser.results[0];

        /*Parse လုပ်တာအောင်မြင်တဲ့အခါ "FileName.ast.json" ဖိုင်ထုတ်ပေးလိုက်တယ်။မထုတ်ခင် AST ကို JSON String အဖြစ်ပြောင်းလိုက်တယ်။*/
        fs.writeFile(`${fileName}.ast.json`,
            JSON.stringify(AST, null, 4),
            (err) => {
                /*Error ရှိအခါ Error တက်ပါမယ်။*/
                if (err) return console.log(err);

                /*File Create လို့အောင်မြင်ရင်အောင်မြင်ကြောင်း Message ပြန်ပေးပါမယ်။*/
                console.log("AST Created.");
            });

    }catch(e) {
        /*Syntax Error တွေ့ရင် Error ပြပေးမှာပါ။*/
        console.log(e.message);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

const fs = require("fs");
// User ကထည့်ပေးမယ့်ဖိုင်ကိုယူပါမယ်။
const file = process.argv[2];
// ဖိုင်ရဲ့နာမည်လေးကိုခွဲထုတ်လိုက်တယ်။
const fileNameOnly = file.split(".")[0];

// AST ဖိုင်ကိုဖတ်ပါတယ်။
fs.readFile(file, (err, data) => {
    if (err) throw err; // handle the error

    // AST ဖိုင်ထဲက JSON ကို Array Object ပြန်ပြောင်းလိုက်ပါတယ်။ပြီးနောက်JS ကိုပြောင်းမယ့် Function ကို Data တွေပေးလိုက်တယ်။
    const JSCodes = transpileToJS(JSON.parse(data.toString()));

    // JS Code တွေကို JS ဖိုင်အဖြစ်ပြန်ထုတ်ပေးလိုက်ပါတယ်။
    fs.writeFile(`${fileNameOnly}.js`, JSCodes, err => {
        if (err) return console.log(err);

        console.log(`${fileNameOnly}.js Transpiled Successfully.`);
    });
})


const transpileToJS = data => {
    // JS Code ပြန်ထုတ်ပေးဖို့အတွက် ပထမဆုံး Arary အဖြစ်သတ်မှတ်ထားပါတယ်။
    let lines = [];
    // Data တွေကို Loop ပတ်ပါမယ်။
    for (statement of data) {
        // Expression တွေထွက်လာမှာဖြသ်တဲါအတွက် Expression Generator ကိုလွှဲပေးလိုက်တယ်။ပြီးမှ Return ပြန်တဲ့ ကောင်ကို Expression အဖြစ်သိမ်းလိုက်တယ်။
        let expression = generateExpression(statement);

        // Expression တွေကို JS ပြောင်းပြီး Lines Array ထဲထည့်လိုက်တယ်။
        lines.push(`console.log(${expression})`);
    }
    // Lines Array ထဲက Source Code အဖြစ်ထည့်လိုက်တဲ့ Array Element တွေကို တစ်ကြောင်းချင်းစီဖြစ်အောင်လုပ်ပေးပြီး Return ပြန်လိုက်တယ်။
    return lines.join("\n");
}


// Expression တွေကိုလက်ခံပါမယ်။
function generateExpression(expression) {
    // Expression က Object ဖြစ်မဖြစ်စစ်ပါတယ်။
    if (typeof expression === "object") {
        // Object ဖြစ်နေတဲ့အခါ Binary Expression လားလို့စစ်ပါတယ်။
        if (expression.type === "binary_expression") {
            // rop (Right Operand) က Expression ပြန်ဖြစ်နိုင်တဲ့အတွက် generateExpression ကိုပြန်ခေါ်ပေးလိုက်ပါတယ်။
            let right = generateExpression(expression.rop);
            // lop (Left Operand) က Expression ပြန်ဖြစ်နိုင်တဲ့အတွက် generateExpression ကိုပြန်ခေါ်ပေးလိုက်ပါတယ်။
            let left = generateExpression(expression.lop);

            // Operator က Operator ပဲမို့လို့ Operator တန်ဖို့းကိုပဲယူလိုက်ပါတယ်။
            let operator = expression.operator;

            // ပြီးနောက် Expression အဖြစ် Return ပြန်ပေးလိုက်ပါတယ်။
            return `${left} ${operator} ${right}`;
        }
    } else {
        // Object မဟုတ်ရင် ပေးထားတဲ့ကောင်ကိုပဲပြန် Return ပေးပါတယ်။
        return expression;
    }
}

1

npm run parse # parse the grammer to generate parser

1
2

1 + 2
2 + 3 + 8

1

node parser.js example.calc 

1

node translator.js example.calc.js.json

1

node example.js