仿c语言自制编程语言笔记3

2018-01-14

CflatToken

这个类是对Token类的一个包装.这样能整合Token和SpecialToken.首先我们看一下官方的Token的定义,这里有两个关键的调用

//这个方法返回这个token的下一个非特殊token,而且是相连的,如果当前token是一个Specialtoken,则返回下一个Specialtoken.
  public Token next();
//这个方法返回上上一段连续Specialtoken的最后一个,如果要找到第一个,一直调用直到这个方法返回null,
  public Token specialToken();

因此,我们可以用这两个方法来分别获得sptoken和普通token.所以在CflatToken类中,实现的方法:

//包括去除头字符的版本,考虑其作用
protected List<CflatToken> buildTokenList(Token first, boolean rejectFirstSpecials) {
       List<CflatToken> result = new ArrayList<CflatToken>();
       boolean rejectSpecials = rejectFirstSpecials;
       for (Token t = first; t != null; t = t.next) {
           if (t.specialToken != null && !rejectSpecials) {
               Token s = specialTokenHead(t.specialToken);
               for (; s != null; s = s.next) {
                   result.add(new CflatToken(s));
               }
           }
           result.add(new CflatToken(t));
           rejectSpecials = false;
       }
       return result;
   }
//得到一段sptoken的第一个
   protected Token specialTokenHead(Token firstSpecial) {
       Token s = firstSpecial;
       while (s.specialToken != null) {
           s = s.specialToken;
       }
       return s;
   }

其中token序列相当于链表,每找到一个普通TOKEN,向上遍历找之前的spTOKEN序列的头.然后看情况是否添加.

节点编写

首先,我们定义所有的实体类有如下几种:

Constant 常量
DefinedVariable 定义的变量
UndefinedVariable 声明的变量
DefinedFunction 定义的函数
UndefinedFunction 声明的函数
StructNode struct定义
UnionNode union定义

TypedefNode 定义的类型
看一下我们顶层的Declarations类,这个类在根节点中出现用来汇集import声明和函数体的类.基本上就是一个各种类型的集合.

public class Declarations {
	 Set<DefinedVariable> defvars = new HashSet<DefinedVariable>();
	    Set<UndefinedVariable> vardecls = new HashSet<UndefinedVariable>();
	    Set<DefinedFunction> defuns = new HashSet<DefinedFunction>();
	    Set<UndefinedFunction> funcdecls = new HashSet<UndefinedFunction>();
	    Set<Constant> constants = new HashSet<Constant>();
	    Set<StructNode> defstructs = new HashSet<StructNode>();
	    Set<UnionNode> defunions = new HashSet<UnionNode>();
	    Set<TypedefNode> typedefs = new HashSet<TypedefNode>();
	   //...一些add接口
}

接下来抽象出我们的节点的基类node:

abstract public class Node implements Dumpable {
	public Node(){
	}
	//返回某节点对应的语法在代码中的位置,也能返回出错的语句的位置.
	abstract public Location location();
	public void dump(){
		dump(System.out);
	}
	public void dump(PrintStream out){
		dump(new Dumper(out));
	}
	//以文本形式打印语法树
	public void dump(Dumper d){
		d.printClass(this,location());
		_dump(d);
	}
	//用来测试
	abstract protected void PrintTree(Dumper d);
}

Node中没有实质内容.PrintTree方法是用来递归打印整个节点向下包含的内容结构.就是一颗抽象语法树子树.

所有的节点类型中包含了type()和origType(),type()返回这个节点包含的整体类型,而后者返回他的基础类型,比如char[]数组返回的类型就是数组,基础类型就是char.
type包里定义了一些类型类,比如说我们的指针类PointerType,char,int这些都属于这个类,因此应该包含一个保存基础类型的成员.
在设计type系列的类时候,要考虑如下几个方面:

类型的类要考虑能否转换.比如int可以转换成一个指针类型
考虑是不是同一种类型.
考虑两个类型是不是兼容,比如int可以兼容void.
复合类型需要基础类型.
从实体中可以抽象出他的类型,比如从一个Definedfunction中抽出他的参数列表类型,返回值类型.

解析器的启动模块

在Parser这个类里,首先编写构造函数:

public parser(Reader s,String filename,LibraryLoader loader,ErrorHandler errorHandler,boolean debug) {
	  this(s);//调用默认的构造函数
	  this.loader=loader;//加载器加载import的文件
	  this.errorHandler=errorHandler;//错误处理的对象
	  this.sourceName=filename;//解析的当前文件名
	  this.knownTypedefs=new HashSet<String >();
	  if(debug) {
	    enable_tracing();//启动跟踪功能
	  }else {
	    disable_tracing();
	  }
	}

构造函数中用Javacc默认的第三个构造函数,debug用来开启javacc的调试模式.
我们需要一个能解析源文件的方法和一个解析头文件的方法:

//用来解析当前内文件是源文件的调用,返回一个AST对象
    public AST parse() throws SyntaxException {
        try {
            return compilation_unit();
        }
        catch (TokenMgrError err) {
            throw new SyntaxException(err.getMessage());
        }
        catch (ParseException ex) {
            throw new SyntaxException(ex.getMessage());
        }
        catch (LookaheadSuccess err) {
            throw new SyntaxException("syntax error");
        }
    }
//用来解析当前文件为声明文件的调用,返回一个Declarations对象
    public Declarations parseDecls() throws SyntaxException {
        try {
            return declaration_file();
        }
        catch (TokenMgrError ex) {
            throw new SyntaxException(ex.getMessage());
        }
        catch (ParseException ex) {
            throw new SyntaxException(ex.getMessage());
        }
   }