symbol.cpp

扩展后的mini-pl0语法编译器

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <iostream.h>
#include "symbol.h"

symbol::symbol()
{
	m_next = NULL;
	m_name = NULL;
	for(int i=0;i<30;i++)
	{
		m_typeInfo[i] = NULL;
	}
	m_checkvar= false;
}

symbol::~symbol()
{
	if(m_name != NULL)
		delete []m_name;
	if(m_type == DRecord)
	{
		for(int i=0;i<30;i++)
		{
			if(m_typeInfo[i])
				delete m_typeInfo[i];//与record有关
			m_typeInfo[i] = NULL;
		}
	}
	else
	{
		for(int i=0;i<30;i++)
		{
			m_typeInfo[i] = NULL;
		}
	}
}

symbol* symbol::create(const char* name,symbol** psymbol)
//过程名初始化
{
	assert(name != NULL);
	int length = strlen(name);
	m_name = new char[length + 1];
	strcpy(m_name, name);

	int i,index;
	//查找到第一个不为空的下标
	for(index=29;index>=0;index--)
	{
		if(psymbol[index])
			break;
	}

	int len=0,addlen;
	for(i = index;i>=0;i--)	//参数信息
	{
		m_typeInfo[i] = psymbol[i];
		//确定当前变量的长度
		if(psymbol[i]->m_checkparam)	//var型
			addlen=1;	
		else
			addlen=psymbol[i]->m_length;
		len=len-addlen;
		m_typeInfo[i]->m_value=len;		//写入偏移量
	}	
	m_type = CProce;					//当前节点的类型
	m_length = 0;						//该数据的长度为0（不是变量，也不是新类型）
	return this;						//返回当前节点
}

symbol* symbol::create(const char* name,IdType type)
//普通类型,int和bool型
{
	assert(name != NULL);
	int length = strlen(name);
	m_name = new char[length + 1];
	strcpy(m_name, name);
	m_type = type;
	m_length = 1;
	return this;
}

symbol* symbol::create(const char* name, const int start, const int end,IdType type, symbol* psymbol)
//array的新类型名，name为新类型名，start为起点，end为结尾下标，
//type为此数组中数据的类型， psymbol存储当type是新类型的有关信息，如果是普通类型，则为空
{
	assert(name != NULL);
	int length = strlen(name);
	m_name = new char[length + 1];
	strcpy(m_name, name);
	arraystart = start;
	arrayend = end;
	m_type = DArray;		//标注数组新类型的名字节点
	arrayType = type;		//标注是什么类型的数组(初始数组为int或bool)
	m_typeInfo[0] = psymbol;
	if(psymbol)				//不是普通数组
		m_length = (end - start +1) * psymbol->m_length;//当前name类型的长度
	else
		m_length = end - start +1;
	return this;
}

symbol* symbol::create(const char* name,int length)
//record的新类型名
{
	assert(name != NULL);
	int l = strlen(name);
	m_name = new char[l + 1];
	strcpy(m_name, name);
	m_type = DRecord;
	m_length = length;
	return this;
}

symbol* symbol::create(const char* name, IdType type, symbol* psymbol)
//插入的类型为新类型的变量
{
	//变量名的插入
	if((type == VArray && psymbol->m_type == DArray) 
		|| (type == VRecord && psymbol->m_type == DRecord) )
	{
		assert(name != NULL);
		int length = strlen(name);
		m_name = new char[length + 1];
		strcpy(m_name, name);
		m_type = type;		
		m_typeInfo[0] = psymbol;
		m_length = psymbol->m_length;
		return this;
	}
	else
	{
		cout<<"不是新类型。"<<endl;
		return NULL;
	}
}

//插入过程的参数
symbol* symbol::create(const char* name, IdType type, int length, symbol* psymbol, bool checkparam)
{
	assert(name != NULL);
	int len = strlen(name);
	m_name = new char[len + 1];
	strcpy(m_name, name);
	m_type = type;
	m_length = length;
	m_typeInfo[0] = psymbol;
	m_checkparam = checkparam;	//表明是否是实参
	m_checkvar = true;			//表明示参数
	return this;
}

//返回值
int symbol::GetValue()
{
	return m_value;
}

//设置值
void symbol::SetSimpleValue(int value)
{
	m_value = value;
}

/*********************************************************/
//symboltable类的构造函数
symboltable::symboltable(int lever, symboltable* parent, symboltable* sibling)
{
	for(int i = 0; i < BUCKET_SIZE; i++)
	{
		m_bucket[i] = NULL;
	}
	m_lever = lever;
	m_procesymbol = NULL;
	m_childtable = NULL;
	m_parenttable = parent;
	m_siblingtable = sibling; 
	for(i = 0; i < 30; i++)
	{
		symbolList[i] = NULL;
	}
	m_listindex = 0;
}

//析构函数
symboltable::~symboltable()
{
	for (int i = 0; i < BUCKET_SIZE; i++)
	{
		symbol* p= m_bucket[i];
		while(p != NULL)
		{
			symbol* next = p->m_next;
			delete p;
			p = next;
		}
	}
	delete m_procesymbol;
	m_procesymbol = NULL;
}

//散列函数
int symboltable::hash(const char* name) const
{
	assert(name != NULL);
	int index = 0;
	while (*name != '\0')
	{
		index = index << 1 ^ *name++;
	}
	index %= BUCKET_SIZE;
	if (index < 0)
	{
		index = -index;
	}
	return index;
}

symbol* symboltable::install(const char* name, symbol** psymbol,IdType type)
//插入过程名或插入record的新类型名
{
	if(type == CProce) //插入过程名
	{
		symbol* p;
		p = new symbol();
		m_procesymbol = p->create(name,psymbol);
		return p;
	}
	else	//插入record的新类型名
	{
		assert(name != NULL);
		int index = hash(name);
		symbol* p;
		for (p = m_bucket[index]; p != NULL; p = p->m_next) {
			if (strcmp(p->m_name, name) == 0) {
				return NULL;	//名字已经存在，则不能再插入
			}
		}
		p = new symbol();
		p->create(name,0);
		p->m_next = m_bucket[index];
		m_bucket[index] = p;
		int length = 0;
		for(int i = 0; i<30 ; i++)
		{
			p->m_typeInfo[i]=psymbol[i];
			if(psymbol[i])
			{
				p->m_typeInfo[i]->m_value=length;
				length += psymbol[i]->m_length;
			}		
		}
		p->m_length = length;
		return p;
	}
}

symbol* symboltable::install(const char* name,IdType type)
//插入int和bool型变量
{
	assert(name != NULL);
	int index = hash(name);
	symbol* p;
	for (p = m_bucket[index]; p != NULL; p = p->m_next) {
		if (strcmp(p->m_name, name) == 0) {
			return NULL;
		}
	}
	p = new symbol();
	p->create(name,type);
	p->m_next = m_bucket[index];
	m_bucket[index] = p;
	return p;
}

symbol* symboltable::install(const char* name,const int start, const int end ,IdType type, symbol* psymbol)
//插入array的新类型名
{
	assert(name != NULL);
	int index = hash(name);
	symbol* p;
	for (p = m_bucket[index]; p != NULL; p = p->m_next) {
		if (strcmp(p->m_name, name) == 0 && p->m_type != CProce) {
			return NULL;
		}
	}
	p = new symbol();
	//psymbol为数组类型(新类型)的节点指针,不是新类型，则为NULL
	p->create(name,start,end,type,psymbol);
	p->m_next = m_bucket[index];
	m_bucket[index] = p;
	return p;
}
//插入新类型的变量
//变量名name,新类型名为nametype
symbol* symboltable::install(const char* name, IdType type, symbol* q)
{
	assert(name != NULL);
	int index = hash(name);
	symbol* p;
	for (p = m_bucket[index]; p != NULL; p = p->m_next) {
		if (strcmp(p->m_name, name) == 0 ) {
			return NULL;
		}
	}
	p = new symbol();
	p->create(name,type,q);
	p->m_next = m_bucket[index];
	m_bucket[index] = p;
	return p;
}

symbol* symboltable::install(const char* name,IdType type, int length, symbol* psymbol, bool checkparam)
//插入
{
	assert(name != NULL);
	int index = hash(name);
	symbol* p;
	for (p = m_bucket[index]; p != NULL; p = p->m_next) {
		if (strcmp(p->m_name, name) == 0 && p->m_type != CProce) {
			return NULL;
		}
	}
	p = new symbol();
	if(type==DArray)
		type=VArray;
	if(type==DRecord)
		type=VRecord;
	p->create(name,type,length,psymbol,checkparam);
	p->m_next = m_bucket[index];
	m_bucket[index] = p;
	return p;
}

symboltable* symboltable::search(char* name)
//查找变量
{
	assert(name != NULL);
	int index = hash(name);
	symbol* p;
	for (p = m_bucket[index]; p != NULL; p = p->m_next) 
	{
		if (strcmp(p->m_name, name) == 0) 
		{
			m_tempsymbol = p;
			return this;
		}
	}
	symboltable* outLook = NULL; 
	if(m_parenttable)
	{
		outLook= m_parenttable->search(name);
		if(outLook)
		{
			m_tempsymbol = m_parenttable->m_tempsymbol;
		}
		else
			m_tempsymbol = NULL;
	}
	return outLook;

}