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

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

首先贴一下文法(我对原始的文法做了一些调整，如：原始的文法中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

例二，以下程序中创建了一个整数数组，这个数组的下标是从6到8，共三个值(或三个引用)，然后分写或读数组的每个元素。

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

例三，以下程序定义了一个过程f，当调用这个过程中，会打印当前的参数，并把参数+1传入下一次的递归调用中。如果没有实现“尾递归优化”，则这个程序的调用可预期的情况是“堆栈溢出”。

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

例五，以下程序中的factorial过程用于计算n的阶乘，因为我实现的是引用传参，所以我们可以用参数从过程中返回结果。如果我们不设计成引用传参，则需要使用全局变量来传递数据了。

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这个语言比较理解了，下面我选择这个解释器最重要的部分介绍一下开发思路。

一、堆栈

………………

二、上下文(符号表)

………………

三、引用

………………

四、类型

………………