java开发C语言解释器：结构体内存与成员变量的一致性

更详细的讲解和代码调试演示过程，请参看视频

用java开发C语言编译器

如果你对机器学习感兴趣，请参看一下链接：

机器学习：神经网络导论

由于设计上的原因，我们的解释器在解读结构体指针时，存有两套信息存储系统，例如对于结构体定义和结构体指针变量的相关代码如下：

struct TAG {
int  p;
char c;
int arr[3];

}tag;

struct TAG *pTag;
int sz = sizeof(tag);
pTag = malloc(sz);

我们根据结构体TAG 定义了一个结构体指针pTag, 并且通过malloc为该指针分配了动态内存,在解释器内部，由于设计上的原因，一个结构体指针变量应对着两套内存系统，一个是解释器会为结构体指针遍历中的每一个成员变量创建一个Symbol对象，这些对象存储在符号表中，二是解释器根据malloc调用，为该指针分配了动态内存，具体情况如下图所示：



这样带来一个问题是，我们必须保证两套内存数据的值必须是一致的，例如成员变量p的值改变了后，那么指针指向的动态内存，头四个字节的内容也需要相应改变。上一节，我们实现的就是这个功能。

本节，我们要实现的是，如果代码修改了动态内存头四个字节的数据，那么结构体的成员变量p的值也需要跟着改变。上一节做法的思路是，解释器监视结构体成员变量，每当结构体成员的值发生改变，那么解释器就把所有成员变量的值复制到内存中。这次，我们反其道而行之，在解释器读取结构体成本变量的数值之前，先把内存中的信息拷贝到每个结构体成员中。

完成本节代码后，解释器将能正确的解释执行如下代码：

void main() {
struct TAG {
char c;
char b[3];
int p;
}tag;

struct TAG* pTag;
int sz ;
sz = sizeof(tag);
pTag = malloc(sz);

pTag[0] = 3;
pTag[1] = 4;
pTag[2] = 5;
pTag[3] = 6;
printf("value of c is %d, b[0] is %d, b[1] is %d, b[2] is %d ", pTag->c, pTag->b[0], pTag->b[1], pTag->b[2]);
}

当结构体成员变量被赋值或读取的语句是 pTag->c, 此类语句对应的语法表达式为：Unary -> Unary StructOP Name

负责解释执行该类语句的解释器代码处于UnaryNodeExecutor.java中，相关代码逻辑如下：

public class UnaryNodeExecutor extends BaseExecutor implements IExecutorReceiver{
private Symbol structObjSymbol = null;
private Symbol monitorSymbol = null;

@Override
public Object Execute(ICodeNode root) {
executeChildren(root);
int production = (Integer)root.getAttribute(ICodeKey.PRODUCTION);
String text ;
Symbol symbol;
Object value;
ICodeNode child;

switch (production) {
....
case CGrammarInitializer.Unary_StructOP_Name_TO_Unary:
child = root.getChildren().get(0);
String fieldName = (String)root.getAttribute(ICodeKey.TEXT);
symbol = (Symbol)child.getAttribute(ICodeKey.SYMBOL);

if (isSymbolStructPointer(symbol)) {
copyBetweenStructAndMem(symbol, false);
}

Symbol args = symbol.getArgList();
while (args != null) {
if (args.getName().equals(fieldName)) {
break;
}

args = args.getNextSymbol();
}

if (args == null) {
System.err.println("access a filed not in struct object!");
System.exit(1);
}

root.setAttribute(ICodeKey.SYMBOL, args);
root.setAttribute(ICodeKey.VALUE, args.getValue());

if (isSymbolStructPointer(symbol) == true) {
checkValidPointer(symbol);
structObjSymbol = symbol;
monitorSymbol = args;

ExecutorBrocasterImpl.getInstance().registerReceiverForAfterExe(this);
} else {
structObjSymbol = null;
}

break;
....
}
....
}

在上面代码中，我添加了如下语句：

if (isSymbolStructPointer(symbol)) {
copyBetweenStructAndMem(symbol, false);
}

这几行代码的作用是，判断当前Symbol所对应的变量是否是结构体指针，如果是的话，在访问该结构体变量的成员之前，先把数据从动态内存，也就是上图中Mem所代表的那部分，拷贝到各个结构体成员变量中。我们再看看copyBetweenStructAndMem 接口的实现：

private void copyBetweenStructAndMem(Symbol symbol, boolean isFromStructToMem) {
Integer addr = (Integer)symbol.getValue();
MemoryHeap memHeap = MemoryHeap.getInstance();
Map.Entry<Integer, byte[]> entry = memHeap.getMem(addr);
byte[] mems = entry.getValue();
Stack<Symbol> stack = reverseStructSymbolList(symbol);
int offset = 0;

while (stack.empty() != true) {
Symbol sym = stack.pop();

try {
if (isFromStructToMem == true) {
offset += writeStructVariablesToMem(sym, mems, offset);
} else {
offset += writeMemToStructVariables(sym, mems, offset);
}

} catch (Exception e) {
System.err.println("error when copyin struct variables to memory");
e.printStackTrace();
}
}
}

它输入两个参数，第一个是结构体指针变量对应的Symbol对象，第二个参数是一个boolean 类型变量，如果他的值是true, 那么该函数调用writeStructVariablesToMem 将结构体成员变量的值拷贝到内存，如果是false, 那么调用writeMemToStructVariables 把内存数据拷贝到结构体成员变量中。

writeStructVariablesToMem 的逻辑我们上节讲过了，本节我们看看writeMemToStructVariables的实现：

private int writeMemToStructVariables(Symbol symbol, byte[] mem, int offset) throws Exception {
if (symbol.getArgList() != null) {
//struct variable, copy mem to struct recursively
return writeMemToStructVariables(symbol, mem, offset);
}

int sz = symbol.getByteSize();
int val = 0;
if (symbol.getDeclarator(Declarator.ARRAY) == null) {
val = fromByteArrayToInteger(mem, offset, sz);
symbol.setValue(val);
} else {
return copyMemToArrayVariable(symbol, mem, offset);
}

return sz;
}

private int fromByteArrayToInteger(byte[] mem, int offset, int sz) {
int val = 0;
switch (sz) {
case 1:
val = mem[offset];
break;
case 2:
val = (mem[offset + 1] << 8 | mem[offset]);
break;
case 4:
val = (mem[offset+3] << 24 | mem[offset+2] << 16 | mem[offset + 1] << 8 |
mem[offset]);
break;
}

return val;
}

private int copyMemToArrayVariable(Symbol symbol, byte[] mem, int offset) {
int sz = symbol.getByteSize();
Declarator declarator = symbol.getDeclarator(Declarator.ARRAY);
if (declarator == null) {
return 0;
}

int size = 0;
int elemCount = declarator.getElementNum();
for (int i = 0; i < elemCount; i++) {
int val = fromByteArrayToInteger(mem, offset + size, sz);
size += sz;
try {
declarator.addElement(i, val);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

return size;
}

writeMemToStructVariables 实现的基本逻辑是，根据结构体成员变量在内存中的相对位置，以及该变量对应的字节大小，从内存中读取相关数据，把读取的信息写入到该变量所对应的Symbol对象中。例如根据给定的代码实例，结构体的成员变量c,位于结构体偏移0处，它是char类型，因此该变量对应的字节大小为1，于是，我们从动态内存其实地址为0开始，读取一个字节的数据内容，把读取的内容设置到变量c在符号表中的Symbol对象。

fromByteArrayToInteger的作用是把多个字节的数据合成一个基本数据类型，例如int类型的变量是4个字节，那么该函数先从内存数组里读出4个字节的数据，然后把这4个字节合并成一个int整形数。

copyMemToArrayVariable的作用跟我们上节讲过的函数copyArrayVariableToMem， 逻辑是一样的。

完成上面代码后，当我们通过指针修改了结构体指针指向的内存后，修改的结果就能直接反应到结构体的成员变量上，我们给定的示例代码，解释器解释执行后结果如下：

value of c is 3, b[0] is 4, b[1] is 5, b[2] is 6

由此可见，我们解释器对源代码的解释执行结果是正确的。请参看视频以便获得更详细的讲解和更详实的代码调试演示过程。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：