基于cool语言实现一个可执行若干指令的stack machine，要求实现的栈机可以满足以下命令：
| Command | Meaning |
|---|---|
| int | 将该整数压入栈 |
| s | 将字符s压入栈 |
| e | 根据栈顶元素执行相关命令，具体见下 |
| d | 打印当前栈中元素（from top to bottom） |
| x | 该stack machine正常退出 |
对于"e"指令的执行，目前分为以下三种情况：
实验环境配置
apt-get install flex bison build-essential csh libxaw7-dev lib32stdc++6
export PATH=/home/user/workspace/bin:$PATH。实验理论准备
代码设计与实现
采用面向对象方式进行代码设计，涉及到的类的结构图如下：
代码总的设计思路是，终端读入字符到StackMachine，然后StackMachine根据字符产生相应种类的StackCommand，StackMachine再执行这些相关的指令并维护自身所持有的栈。下面我们按照书写顺序来分析各个Class的代码。流程图见下：
StackCommand：这里注释给出了该类的features含义。该类是让StackMachine执行的命令的载体，方便后续进行命令的扩展。
class StackCommand {
(*
cName: The name or string of command.
cType: It is designed to classify different command, but now we just need use "case".
getName(): To get cName.
getType(): To get cType.
init(String): Use a string to name command.
*)
cName : String;
cType : Int;
getName() : String {
cName
};
getType() : Int {
cType
};
init(commandName : String) : StackCommand {
{
cName <- commandName;
self;
}
};
};
class StackExecuteCommand inherits StackCommand {
init(comandName : String) : StackCommand{
{
self@StackCommand.init(comandName);
cType <- 0;
self;
}
};
};
class StackDisplayCommand inherits StackCommand {
init(comandName : String) : StackCommand{
{
self@StackCommand.init(comandName);
cType <- 1;
self;
}
};
};
class StackStopCommand inherits StackCommand {
init(comandName : String) : StackCommand{
{
self@StackCommand.init(comandName);
cType <- 2;
self;
}
};
};
class StackPushCommand inherits StackCommand {
elem : Element; (*The element will be pushed into the stack.*)
getElem() : Element {elem};
initPC(comandName : String , e : Element) : StackCommand{
{
self@StackCommand.init(comandName);
cType <- 3;
elem <- e;
self;
}
};
};
class Element {
(*
eName: The name of element.
eType: The type of element. It is designed to classify different element but now we just need use "case".
getName(): To get eName.
getType(): To get eType.
init(): Use a string to init the eName.
*)
eName : String;
eType : Int;
getName() : String {
eName
};
getType() : Int {
eType
};
init(elementName : String) : Element{
{
eName <- elementName;
self;
}
};
};
class Operation inherits Element {
opNumber : Int;
getOpNum() : Int {
opNumber
};
initOp(elementName : String , operationNumber : Int) : Operation{
{
self@Element.init(elementName);
eType <- 0;
opNumber <- operationNumber;
self;
}
};
};
(*
* The types of data means:
* 0 : int;
*)
class Data inherits Element {
dType : Int;
getType() : Int {
dType
};
initData(elementName : String , dataType : Int) : Data{
{
self@Element.init(elementName);
eType <- 1;
dType <- dataType;
self;
}
};
};
class Link {
isNil() : Bool {true};
head() : Element {{abort();new Element.init("NULL");}};
tail() : Link {{abort();self;}};
setRest(r : Link) : Link {{abort(); new LinkCons.init(head(),tail());}};
cons(e : Element) : Link {
(new LinkCons).init(e,self)
};
};
class LinkCons inherits Link{
elem : Element;
rest : Link;
isNil() : Bool {false};
head() : Element {elem};
tail() : Link {rest};
setRest(r : Link) : Link{
rest <- r
};
init(e : Element , s : Link) : Link{
{
elem <- e;
rest <- s;
self;
}
};
};
class Stack inherits IO{
top : Element;
link : Link;
length : Int;
isNil() : Bool{link.isNil()};
getLength() : Int{length};
top() : Element {top};
pop() : Bool {
let temp : Link , void : Link in {
if isNil() then false
else {
temp <- link.tail();
link.setRest(void);
link <- temp;
if length = 1 then 1 else top <- link.head() fi;
length <- length - 1;
true;
} fi;
}
};
push(e : Element): Bool {
{
link <- link.cons(e);
top <- e;
length <- length + 1;
true;
}
};
init() : Stack {
{
link <- (new Link);
length <- 0;
top <- (new Element);
self;
}
};
display() : Stack {
{
let i : Int <- 0 , l : Link <- link in {
while i < length loop {
out_string(l.head().getName());
out_string("\n");
i <- i + 1;
l <- l.tail();
} pool;
};
self;
}
};
};
class StackMachine inherits IO {
stack : Stack;
init() : StackMachine {
{
stack <- (new Stack).init();
self;
}
};
commandCreate(cmdString : String) : StackCommand{
if cmdString = "e" then {
new StackExecuteCommand.init(cmdString);
} else if cmdString = "d" then {
new StackDisplayCommand.init(cmdString);
} else if cmdString = "x" then {
new StackStopCommand.init(cmdString);
} else {
new StackPushCommand.initPC(cmdString,elementCreate(cmdString));
} fi fi fi
};
elementCreate(cmdString : String) : Element {
if cmdString = "+" then (new Operation).initOp(cmdString,2) else
if cmdString = "s" then (new Operation).initOp(cmdString,2) else
(new Data).initData(cmdString,0) fi fi
};
execute(scmd : StackCommand) : Bool {
let state_code : Bool in
{
case scmd of
temp : StackExecuteCommand => {
if stack.isNil() then 1 else
let elem : Element , i : Int in {
elem <- stack.top();
stack.pop();
case elem of
op : Operation => execute_op(op);
data : Data => execute_data(data);
esac;
} fi;
state_code <- true;
};
temp : StackDisplayCommand => {
stack.display();
state_code <- true;
};
temp : StackStopCommand => {
state_code <- false;
};
temp : StackPushCommand => {
stack.push(temp.getElem());
state_code <- true;
};
esac;
state_code;
}
};
execute_op(op : Operation) : StackMachine{
{
if op.getOpNum() = 2 then {
let ad : Int , bd : Int , at : Int , bt : Int , c : Int , d : Int in {
if op.getName() = "+" then {
ad <- (new A2I).a2i(stack.top().getName());
at <- stack.top().getType();
stack.pop();
bd <- (new A2I).a2i(stack.top().getName());
bt <- stack.top().getType();
stack.pop();
c <- ad+bd;
if at < bt then d <- at else d <- bt fi;
stack.push(new Data.initData((new A2I).i2a(c),d));
} else if op.getName() = "s" then {
let a : Element , b : Element in {
a <- stack.top();
stack.pop();
b <- stack.top();
stack.pop();
stack.push(a);
stack.push(b);
};
} else {
out_string("No operation: ");
out_string(op.getName());
out_string("\n");
}fi fi;
};
} else if op.getOpNum() = 1 then {
op.getOpNum();
} else {
op.getOpNum();
} fi fi ;
self;
}
};
execute_data(data : Data) : StackMachine{
self
};
run() : StackMachine {
{
let cmd : StackCommand , str : String in {
let state_code : Bool <- true in {
while state_code loop {
out_string(">");
str <- in_string();
cmd <- commandCreate(str);
state_code <- execute(cmd);
} pool;
};
};
self;
}
};
};
class Main inherits IO {
machine : StackMachine;
main() : Object {
{
machine <- (new StackMachine).init();
machine.run();
}
};
};
对于本次实验，两个重点：
对于cool语言的学习，目前仅仅学到了基础语法和class的使用，对于后面讲的那些类型判断和检测还有其他比较深入的东西还未尝接触。通过对cool的学习和使用，我感觉cool语言已经是比较完善的面向对象语言了，并且也不算复杂，熟悉之后很容易掌握，但是也有一部分缺点，就比如对一些局部变量的使用，必须使用let语句进行限定，不够便捷等等。总结来说，简单易懂但不够方便。
对Stack Machine的实现上，这本身其实是一个很简单的任务，只需创建一个存储字符串的栈结构，然后进行对栈进行相应操作即可，这里我们之所以采用这么复杂的方法，是为了方便指令的扩展以及其他操作的扩展，同时也使得代码更容易理解，更容易维护等等。