2024年5月9日发(作者：)

SNL语言_吉大计算机编译原理课程设计

/* analyze.h */

#ifndef _ANALYZE_H_

#define _ANALYZE_H_

#define ScopeMaxLevel 20

#include "TreeNode.h"

enum IdKind { typeKind , varKind , procKind };

enum TypeKind { intType , charType , arrayType ,

TypeIR * idType;

IdKind kind;

union More

{

struct

{

AccessKind access;

int level;

int offset;

}VarAttr;

struct

recordType , boolType};

enum AccessKind { dir , indir };

struct TypeIR;

struct SymbolChain;

struct ParamChain

{

SymbolChain * entry;

ParamChain * next;

};

struct FieldChain

{

char idName[10];

TypeIR * unitType;

int offset;

FieldChain * next;

};

struct TypeIR

{

int size;

TypeKind kind;

union

{

struct

{

TypeIR * indexType;

TypeIR * elementType;

}ArrayAttr;

FieldChain * body;

}More;

};

struct AttributeIR

{

{

int level;

ParamChain * param;

int code;

int size;

}ProcKind;

};

};

struct SymbolChain

{

int line;

char idName[10];

AttributeIR attrIR;

SymbolChain * next;

};

class analyze

{

private:

TreeNode * root;

int level;

SymbolChain * Scope[ScopeMaxLevel];

SymbolChain * Backup[ScopeMaxLevel];

private:

ofstream output;

analyze(ofstream o, TreeNode * r);

~analyze();

void PrintSymbolChain();

bool FindField();

bool SearchChain(char *,int,SymbolChain * &);

bool FindEntry(char *,bool,SymbolChain * &);

bool FindEntry2(char *,SymbolChain * &,IdKind);

bool Enter(char *,SymbolChain * &);

void DestroyChain();

void CreateChain();

1

SNL语言_吉大计算机编译原理课程设计

void analysis(TreeNode *);

public:

void RecordType(TreeNode * t,SymbolChain *

entry);

void ArrayType(TreeNode * t , SymbolChain *

entry);

void nameType(TreeNode * t , SymbolChain *

TreeNode * LoopStm();

TreeNode * ConditionalStm();

TreeNode * ArrayRest();

TreeNode * FieldRest();

TreeNode * AssignmentRest();

TreeNode * AllCall();

TreeNode * Stm();

entry);

SymbolChain * NewTy();

void TypeProcess(TreeNode * t , SymbolChain *);

void Body(TreeNode * t);

void ProcDecPart(TreeNode * t);

void VarDecPart(TreeNode * t);

void TypeDecPart(TreeNode * t);

static void doAnalyze(TreeNode * , ofstream );

};

#endif

/* parse.h */

#ifndef _PARSE_H_

#define _PARSE_H_

#include"TokenList.h"

#include"TreeNode.h"

class parse{

private:

ofstream * output;

TokenList * head;

TokenList * cur;

TreeNode * root;

void fieldvarMore(TreeNode * t);

TreeNode * fieldvar();

void variMore(TreeNode * t);

TreeNode * variable();

TreeNode * factor();

TreeNode * term();

TreeNode * Simple_exp();

TreeNode * Exp();

TreeNode * ActParamMore();

TreeNode * ActParamList();

TreeNode * CallStmRest();

TreeNode * ReturnStm();

TreeNode * OutputStm();

TreeNode * InputStm();

TreeNode * StmMore();

TreeNode * StmList();

TreeNode * ProgramBody();

TreeNode * procBody();

TreeNode * ProcDecPart();

void FidMore(TreeNode * t);

void FormList(TreeNode * t);

TreeNode * Param();

TreeNode * ParamMore();

TreeNode * ParamDecList();

void ParamList(TreeNode * t);

TreeNode * ProcDeclaration();

TreeNode * ProcDec();

void varIdMore(TreeNode * t);

void VarIdList(TreeNode * t);

TreeNode * VarDecMore();

TreeNode * VarDecList();

TreeNode * VarDeclaration();

TreeNode * VarDec();

void IdMore(TreeNode * t);

void IdList(TreeNode * t);

TreeNode * FieldDecMore();

TreeNode * FieldDecList();

void RecType(TreeNode * t);

void ArrayType(TreeNode * t);

void StructureType(TreeNode * t);

void BaseType(TreeNode * t);

void TypeDef(TreeNode * t);

void TypeId(TreeNode * t);

TreeNode * TypeDecMore();

TreeNode * TypeDecList();

TreeNode * TypeDeclaration();

TreeNode * TypeDec();

TreeNode * DeclarePart();

TreeNode * DeclarePart2();

TreeNode * ProgramHead();

TreeNode * Program();

ofstream * getOutputStream();

2