java开发C语言模拟器：sizeof函数的实现

最新推荐文章于 2021-02-13 09:51:17 发布

tyler_download

最新推荐文章于 2021-02-13 09:51:17 发布

阅读量1.2k

点赞数 1

分类专栏：编译原理 java 文章标签： C语言解释器编译原理 java sizeof函数

本文链接：https://blog.csdn.net/tyler_download/article/details/60962149

版权

编译原理同时被 2 个专栏收录

82 篇文章 63 订阅

订阅专栏

java

55 篇文章 6 订阅

订阅专栏

更详细的讲解和代码调试演示过程，请参看视频
用java开发C语言编译器

在C语言中，有一个非常基础，也是极其重要的函数，就是sizeof, 这个函数的作用是计算变量所占内存的大小。只有知道了对应变量的大小，那么我们才能动态分配对应大小的内存。

如果sizeof 计算的对象，仅仅是简单的基础类型变量，例如 int， char 等，那么他们的大小很容易计算，由于我们当前代码假设运行在32位机器上，因此如果传入sizeof的变量是int , 或是指针类型，那么该变量的内存大小就是4字节，如果变量的类型是short, 那么它的内存大小就是2字节，如果是char, 那么内存大小就是1字节。

因此实现sizeof的时候，我们通过传入的变量名，找到它对应的Symbol对象，通过Symbol对象找到它的数据类型，根据上面的分类就可以得知该对象的内存大小了。

问题在于，sizeof传入的可能是符合数据类型，也就是说，传入的变量可以是结构体，例如下面的结构体：

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

结构体的内存大小，实际上是组成该结构体的的内部成员大小之和，因此计算结构体TAG的内存大小，就得计算p, c, 和arr[3]这三个成员的大小后求和。

一种更难的情况是结构体间套，也就是一个结构体里面还包含结构体成员，这么看来，sizeof要正确实现，必须是一种层级递归的方式。

我们采用深度优先的搜索来实现sizeof, 深度优先搜索主要是用于图的遍历，这里我们把该算法平移到sizeof的计算上来，深度优先搜索的基本原理如下，假定一个有向图：
这里写图片描述

在遍历上面的有向图时，如果被访问的节点含有子节点，那么先访问其子节点，然后在访问该节点或该节点的兄弟。那么上面的有向图，深度优先遍历的次序可以如下：1->2->3->4->3->2->5->6->5->1

同理，在实现sizeof函数时，如果传进来的变量是结构体，那么我们先通过sizeof计算结构体每个成员的大小，然后再把每个成员的大小加总，得到当前结构体的大小。

由此sizeof函数实现的基本逻辑是：
1，如果传入的变量是基本数据类型，那么直接返回该变量的字节大小。
2，如果传入的变量是结构体，那么再次调用sizeof计算每个成员的大小，然后加总得到当前结构体的大小。
3，如果当前变量是数组类型，那么把前两步计算的大小乘以数组的元素个数，得到的就是当前变量的大小。

由于sizeof是库函数，因此它的实现在ClibCall.java 中，实现代码如下：

public class ClibCall {
    private Set<String> apiSet;

    private ClibCall() {
        apiSet = new HashSet<String>();
        apiSet.add("printf");
        apiSet.add("malloc");
        apiSet.add("sizeof");
    }
    ....
     public Object invokeAPI(String funcName) {
        switch (funcName) {

        case "printf":
            return handlePrintfCall();

        case "malloc":
            return handleMallocCall();

        case "sizeof":
            return handleSizeOfCall();
        default:
            return null;
        }
    }
private Integer calculateVarSize(Symbol symbol) {
        int size = 0;
        if (symbol.getArgList() == null) {
            size = symbol.getByteSize();
        } else {
            Symbol head = symbol.getArgList();
            while (head != null) {
                size += calculateVarSize(head);
                head = head.getNextSymbol();
            }
        }

        Declarator declarator = symbol.getDeclarator(Declarator.ARRAY); 
        if ( declarator != null) {
            size = size * declarator.getElementNum();
        }

        return size;
    }

calculateVarSize就是解释器对sizeof函数的解释执行，传入参数是sizeof变量对应的Symbol对象，如果getArgsList 返回为空，那表明当前变量不是结构体类型，于是直接通过调用Symbol的getByteSize 函数获取基础数据类型的字节大小。

如果getArgsList返回不是空，那么当前变量类型是结构体，于是把结构体中的每个成员取得，然后递归的调用calculateVarSize去计算每个成员的内存大小。

最后判断下，当前变量是否是数组，如果是数组的话，那么就要把单个变量的大小乘以数组中元素个数，才能得到总的内存大小。

以上代码就是实现sizeof的主逻辑。解释器还有一些地方，代码需要变动，函数调用需要获得传入参数，以前我们的做法是，先获得传入参数的值，然后把这些值存到FunctionArgumentList这个类中，以便解释器执行库函数时容易取得传入参数的值。

sizeof函数需要的不再是变量的值，而是变量对应的Symbol对象，因此我们在解析传入参数时，需要得到参数对应的Symbol对象，由于解析传入参数是在类
ArgsExecutor中实现的，因此需要在该类中，增加获取输入参数Symbol对象的代码：

package backend;

import java.util.ArrayList;

import frontend.CGrammarInitializer;

public class ArgsExecutor extends BaseExecutor {

    @Override
    public Object Execute(ICodeNode root) {
        int production = (Integer)root.getAttribute(ICodeKey.PRODUCTION);
        ArrayList<Object> argList = new ArrayList<Object>();
        ArrayList<Object> symList = new ArrayList<Object>();
        ICodeNode child ;
        switch (production) {
        case CGrammarInitializer.NoCommaExpr_TO_Args:
            child = (ICodeNode)executeChild(root, 0);
            Object objVal = child.getAttribute(ICodeKey.VALUE);
            argList.add(objVal);
            objVal = child.getAttribute(ICodeKey.SYMBOL);
            symList.add(objVal);
            break;

        case CGrammarInitializer.NoCommaExpr_Comma_Args_TO_Args:
            child = executeChild(root, 0);
            objVal = child.getAttribute(ICodeKey.VALUE);
            argList.add(objVal);
            objVal = child.getAttribute(ICodeKey.SYMBOL);
            symList.add(objVal);

            child = (ICodeNode)executeChild(root, 1);
            ArrayList<Object> list = (ArrayList<Object>)child.getAttribute(ICodeKey.VALUE);
            argList.addAll(list);
            list = (ArrayList<Object>)child.getAttribute(ICodeKey.SYMBOL);
            symList.add(list);
            break;
        }

        root.setAttribute(ICodeKey.VALUE, argList);
        root.setAttribute(ICodeKey.SYMBOL, symList);
        return root;
    }

}

最后，FunctionArgumentList这个类也要做一些改动，原来这个类只提供接口存储参数的值，这次要增加接口，存储参数的Symbol对象，改动如下：

package backend;

import java.util.ArrayList;
import java.util.Collections;

public class FunctionArgumentList {
    private static FunctionArgumentList argumentList = null;
    private ArrayList<Object> funcArgList = new ArrayList<Object>();
    private ArrayList<Object> argSymList = new ArrayList<Object>();

    public static FunctionArgumentList getFunctionArgumentList() {
        if (argumentList == null) {
            argumentList = new FunctionArgumentList();
        }

        return argumentList;
    }

    public void setFuncArgList(ArrayList<Object> list) {
        funcArgList = list;
    }

    public void setFuncArgSymbolList(ArrayList<Object> list) {
        this.argSymList = list;
    }

    public ArrayList<Object> getFuncArgList(boolean reverse) {

        if (reverse == true) {
            Collections.reverse(funcArgList);
        }

        return funcArgList;
    }

    public ArrayList<Object> getFuncArgSymsList(boolean reverse) {
        if (reverse == true) {
            Collections.reverse(argSymList);
        }

        return argSymList;
    }

    private FunctionArgumentList() {}
}

有了以上的代码实现后，我们的解释器就可以解释执行如下C语言代码了：

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

    struct TAG myTag[3];
    int size ;
    size = sizeof(myTag);
    printf("The size of struct TAG is : %d", size);
}