对于antlr4的基础使用，请参考我的前一篇文章《用antlr4来实现<按编译原理的思路设计的一个计算器>中的计算器》。

其实我对于antlr4的理解也仅限于那篇文章的范围，但那些内容对于我们实现一个SNL语言已是足够了。

SNL语言的简介可以百度百科（http://baike.baidu.com/subview/2298006/5909410.htm）中看到。

简单说来，这是一个非常简单的结构化编程语言，它包含了一个编程语言应该有的最基本的东西，同时基本上不包含其它的所谓先进的元素。

首先贴一下文法（我对原始的文法做了一些调整，如：原始的文法中if语句的else部分不是可选的，原始文法中record类型内部只能有基础类型或array类型，等等。但我所做的这些调整都是比较边缘的，以下文法基本上保持了SNL语言的原貌）：

grammar Snlc;

@header{package net.yeah.zhouyou.mickey.snl.antlr4;}

program: programHead declarePart programBody? ;

programHead: PROGRAM programName=ID ;
declarePart: typeDecpart? varDecpart? procDecpart? ;

typeDecpart: TYPE typeDecList ;
typeDecList: typeId=ID ‘:=‘ typeDef ‘;‘ typeDecList? ;

typeDef: basicType
       | structureType
       | ID
       ;
basicType: INTEGER | CHAR ;
structureType: arrayType
             | recordType
             ;
arrayType: ARRAY ‘[‘ low=INTC ‘..‘ top=INTC ‘]‘ OF basicType ;
recordType: RECORD fieldDecList END ;
fieldDecList: typeDef idList ‘;‘ fieldDecList? ;
idList: ID (‘,‘ idList)? ;

varDecpart: VAR varDecList ;
varDecList: typeDef idList ‘;‘ varDecList? ;

procDecpart: procDeclare procDecpart? ;
procDeclare: PROCEDURE procName=ID ‘(‘ paramList? ‘)‘ ‘;‘
             declarePart programBody ;
paramList: param (‘;‘ paramList)? ;
param: VAR? typeDef idList ;

programBody: BEGIN stmList END ;
stmList: stm (‘;‘ stmList)? ;
stm: conditionalStm
   | loopStm
   | inputStm
   | outputStm
   | assignment
   | callStm
   | RETURN
   ;
assignment: variable ‘:=‘ exp ;
callStm: ID ‘(‘ actParamList? ‘)‘ ;
conditionalStm: IF condExp THEN stmList (ELSE stmList)? FI ;
loopStm: WHILE condExp DO stmList ENDWH ;
inputStm: READ ‘(‘ invar=ID ‘)‘ ;
outputStm: WRITE ‘(‘ exp ‘)‘ ;
actParamList: exp (‘,‘ actParamList)? ;
condExp: exp (cmpOp=(EQ | LT) exp)? ;
exp: exp op=(MUL | DIV) exp
   | exp op=(ADD | SUB) exp
   | factor
   ;
factor: ‘(‘ exp ‘)‘
      | intVal=INTC
      | variable
      ;
variable: ID variMore? ;
variMore: ‘[‘ exp ‘]‘
        | DOT ID variMore?
        ;

//
PROGRAM: ‘program‘ ;
TYPE: ‘type‘;
INTEGER: ‘integer‘ ;
CHAR: ‘char‘ ;
ARRAY: ‘array‘ ;
OF: ‘of‘ ;
RECORD: ‘record‘ ;
BEGIN: ‘begin‘ ;
END: ‘end‘ ;
PROCEDURE: ‘procedure‘ ;
VAR: ‘var‘ ;
IF: ‘if‘ ;
THEN: ‘then‘ ;
ELSE: ‘else‘ ;
WHILE: ‘while‘ ;
DO: ‘do‘;
ENDWH: ‘endwh‘ ;
READ: ‘read‘ ;
WRITE: ‘write‘ ;
RETURN: ‘return‘ ;
FI: ‘fi‘ ;
ID: [a-zA-Z][a-zA-Z0-9]* ;
INTC: [0-9]+ ;
ADD: ‘+‘ ;
SUB: ‘-‘ ;
MUL: ‘*‘ ;
DIV: ‘/‘ ;
EQ: ‘=‘ ;
LT: ‘<‘ ;
DOT: ‘.‘ ;
DDOT: ‘..‘ ;
AMGT: ‘:=‘ ;
SEM: ‘;‘ ;
COMMA: ‘,‘ ;
LBT: ‘(‘ ;
RBT: ‘)‘ ;
LSBT: ‘[‘ ;
RSBT: ‘]‘ ;
WS: [ \t\n\r]+ -> skip;

读懂这个文法就完全清楚了这门语言的语法结构了，大家可以直接用它来开始开发了，对于语义的部分，大家猜都能猜得出个大概。

但是文法对于学习一个语言来说是比较抽象的，虽然大家都能看懂，但过于理论化，所以我写几个例子贴在下面。

例一，以下程序演示了参数传递，调用proc时传入三个参数1,2,3，在proc内部打印这三个参数的值到控制台——如果我们实现的没有问题，则它应该可以正确打印出这三个数字：

program test
    procedure proc(integer a, b; integer c);
    begin
        write(a);
        write(b);
        write(c)
    end
begin
    proc(1, 2, 3)
end

program test
    var array[6..8] of integer a;
begin
    a[6] := 1;
    a[7] := 2;
    a[8] := 3;
   
    write(a[6]);
    write(a[7]);
    write(a[8])
end

program recursion
    procedure f(integer d);
    begin
        write(d);
        f(d + 1)
    end
begin
    f(1)
end

例四，以下程序用来表示引用传参。我们把t做为参数传到ref过程中，过程中对参数n做了一些动作，结束这个过程后打印t——如果我们的实现中，把实参t传给形参n是值传递的，则最终会打印出5（因为过程内部无论做了什么都改变不了实参）；如果我们的实现中，把实参t传给形参n是引用传递的，则n和t在语义上就是同一个对象，则作用于n的都会在t上有所体现。

在我的实现中，它会打印出3，因为我把参数传递实现为引用传递，但把 := 实现为值传递。

program test
    var integer t;
    procedure ref(integer n);
        var integer i;
    begin
        i := n;
        n := 3;
        i := 1
    end
begin
    t := 5;
    ref(t);
    write(t)
end

program test
    var integer res;
    procedure factorial(integer n, r);
    begin
        r := 1;
        factorial_recursion(n, r)
    end
    procedure factorial_recursion(integer n, r);
    begin
        if 1 < n then
            r := r * n;
            factorial_recursion(n - 1, r)
        fi
    end
begin
    factorial(10, res);
    write(res)
end

program test
    type
        int := integer;
        array1to20 := array[1..20] of char;
        recordtype1 := record
            int a, b;
            array1to20 c;
        end;
        recordtype2 := record
            recordtype1 v;
            char c;
        end;
    var recordtype2 v;
        array1to20 v2;
begin
    v.v.a := 1;
    write(v.v.a);
   
    v2[1] := 65;
    write(v2[1]);
   
    v.v.c[1] := 68;
    write(v.v.c[1]);

    v.c := 66;
    write(v.c)
end

program bubble
    var integer i, j, num;
        array [1..20] of integer a;

    procedure q(integer num);
        var integer i, j, k;
            integer t;
    begin
        i := 1;
        while i < num do
            j := num - i + 1;
            k := 1;
            while k < j do
                if a[k + 1] < a[k] then
                    t := a[k];
                    a[k] := a[k + 1];
                    a[k + 1] := t
                else
                    t := 0
                fi;
                k := k + 1
            endwh;
            i:= i + 1
        endwh
    end
begin
    read(num);
    i := 1;
    while i < (num + 1) do
        read(j);
        a[i] := j;
        i := i + 1
    endwh;
    q(num);
    i := 1;
    while i < (num + 1) do
        write(a[i]);
        i := i + 1
    endwh
end.

经过以上的介绍，大家应该对SNL这个语言比较理解了，下面我选择这个解释器最重要的部分介绍一下开发思路。

一、堆栈

………………

二、上下文（符号表）

………………

三、引用

………………

四、类型

………………