系列入口：
本文介绍变量表的实现。
目录
一、变量表的组织结构
堆栈结构，进入一层新建一个层级，退出一层则丢弃整个层。也就是个栈结构，每层又是个数组。
查找时自顶向下逐级查找，直到最后的全局变量（包括执行脚本时传入的预设变量）。
每层是个数组，这会不会有性能问题？作为脚本，里面写几十上百个变量可能性不大，遍历足够了。
二、代码
2.1 变量块
//变量表
struct T_VARIABLE_BLOCK : public vector<pair<string, Variable > >
{
bool AddVariable(string const& var_name, Variable const& var)
{
for (const_iterator it = begin(); it != end(); ++it)
{
if (it->first == var_name)
{
return false;
}
}
push_back(pair<string, Variable >(var_name, var));
return true;
}
Variable* FindVariable(string const& var_name)const
{
return FindVariable(var_name.c_str());
}
Variable* FindVariable(char const* var_name)const
{
for (const_reverse_iterator it = rbegin(); it != rend(); ++it)
{
if (it->first != var_name)
{
continue;
}
return (Variable*)&it->second;
}
return NULL;
}
};
继承自vector，只有添加和查找两个功能。
添加时先检查是否存在，查找时顺序查找。
2.2 变量表（栈）
class T_VARIABLE_S
{
private:
typedef vector<T_VARIABLE_BLOCK > T_DATA;
T_VARIABLE_BLOCK* m_pEnvs;//指向环境变量
T_VARIABLE_BLOCK* m_pGlobals;//指向全局变量
long m_Globals_count;//全局变量个数
T_VARIABLE_BLOCK* m_pParams;//指向参数
T_DATA m_local_variables;//局部变量
public:
T_VARIABLE_S() :m_pEnvs(NULL), m_pGlobals(NULL), m_Globals_count(-1), m_pParams(NULL) {}
long getGlobalCount()const { return m_pGlobals->size(); }
void T_VARIABLE_S_init(T_VARIABLE_BLOCK* pEnv, T_VARIABLE_BLOCK* pG, long Globals_count, T_VARIABLE_BLOCK* pP)
{
m_pEnvs = pEnv;
m_pGlobals = pG;
m_Globals_count = Globals_count;
m_pParams = pP;
m_local_variables.clear();
}
void T_VARIABLE_S_init(T_VARIABLE_BLOCK const* pEnv, T_VARIABLE_BLOCK const* pG, long Globals_count, T_VARIABLE_BLOCK const* pP)
{
m_pEnvs = (T_VARIABLE_BLOCK*)pEnv;
m_pGlobals = (T_VARIABLE_BLOCK*)pG;
m_Globals_count = Globals_count;
m_pParams = (T_VARIABLE_BLOCK*)pP;
m_local_variables.clear();
}
void FromParentVars(T_VARIABLE_S& vars, long Globals_count, T_VARIABLE_BLOCK const* pP)
{
T_VARIABLE_S_init(vars.m_pEnvs, vars.m_pGlobals, Globals_count, pP);
}
void FromParentVars(T_VARIABLE_S const& vars, long Globals_count, T_VARIABLE_BLOCK const* pP)
{
T_VARIABLE_S_init(vars.m_pEnvs, vars.m_pGlobals, Globals_count, pP);
}
void PushLevel()
{
m_local_variables.resize(m_local_variables.size() + 1);
//cout << "PushLevel " << m_datas.size() << endl;
}
void PopLevel()
{
if (m_local_variables.size() > 0)m_local_variables.resize(m_local_variables.size() - 1);
//cout << "PopLevel " << m_datas.size() << endl;
}
bool AddVariable(string const& var_name, Variable const& var)
{
if (NULL != FindVariable(var_name))return false;
if (0 == m_local_variables.size())
{//全局变量
m_pGlobals->push_back(pair<string, Variable >(var_name, var));
}
else
{//局部变量
m_local_variables.rbegin()->push_back(pair<string, Variable >(var_name, var));
}
return true;
}
Variable* FindVariable(string const& var_name)const
{
return FindVariable(var_name.c_str());
}
Variable* FindVariable(char const* var_name)const
{
long count;
//从顶层向底层查找
for (T_DATA::const_reverse_iterator it = m_local_variables.rbegin(); it != m_local_variables.rend(); ++it)
{
for (T_VARIABLE_BLOCK::const_iterator it_block = it->begin(); it_block != it->end(); ++it_block)
{
if (it_block->first != var_name)
{
continue;
}
return (Variable*)&it_block->second;
}
}
//再找参数
count = m_pParams->size();
for (--count; count >= 0; --count)
{
if ((*m_pParams)[count].first != var_name)
{
continue;
}
return (Variable*) & (*m_pParams)[count].second;
}
//再找全局变量
count = (m_Globals_count < 0 ? m_pGlobals->size() : m_Globals_count);
if (m_Globals_count >= 0 && m_Globals_count > (long)m_pGlobals->size())
{
cout << "错误的有效全局变量个数 " << m_Globals_count << " 最大 " << m_pGlobals->size() << endl;
return NULL;
}
for (--count; count >= 0; --count)
{
if ((*m_pGlobals)[count].first != var_name)
{
continue;
}
return (Variable*) & (*m_pGlobals)[count].second;
}
//最后找环境变量
for (T_VARIABLE_BLOCK::const_reverse_iterator it = m_pEnvs->rbegin(); it != m_pEnvs->rend(); ++it)
{
if (it->first != var_name)
{
continue;
}
return (Variable*)&it->second;
}
return NULL;
}
string ToString(long level = 0)const
{
stringstream ret;
ret << this << endl;
long n = 0;
ret << "环境变量：" << endl;
for (T_VARIABLE_BLOCK::const_iterator it = m_pEnvs->begin(); it != m_pEnvs->end(); ++it)
{
ret << n << " : " << it->first << " : " << it->second.ToString() << endl;
++n;
}
ret << "全局变量：有效数" << this->m_Globals_count << endl;
for (T_VARIABLE_BLOCK::const_iterator it = m_pGlobals->begin(); it != m_pGlobals->end(); ++it)
{
ret << n << " : " << it->first << " : " << it->second.ToString() << endl;
++n;
}
ret << "参数：" << endl;
for (T_VARIABLE_BLOCK::const_iterator it = m_pParams->begin(); it != m_pParams->end(); ++it)
{
ret << n << " : " << it->first << " : " << it->second.ToString() << endl;
++n;
}
ret << "局部变量：" << endl;
for (T_DATA::const_iterator it = m_local_variables.begin(); it != m_local_variables.end(); ++it)
{
for (T_VARIABLE_BLOCK::const_iterator it_block = it->begin(); it_block != it->end(); ++it_block)
{
//if(it_block->second->isconst)continue;
ret << n << " : " << it_block->first << " : " << it_block->second.ToString() << endl;
}
++n;
}
return ret.str();
}
};
这个类的数据包含四部分：
- 预设变量（环境变量），是编译和执行时传入的
- 全局变量，脚本里定义的，配合m_Globals_count即可确定脚本此处可以使用的全局变量（只有此处之前定义的全局变量可以使用）
- 参数，对于通过插件提供的自定义函数，每个参数都有名字，都是一个可用的变量
- 局部变量，是个栈，每进入一层嵌套语句块增加一级
由于全局变量所在位置局部变量栈必然是空的，所以AddVariable直接用局部变量表是否为空来判断是否是全局变量。
预设变量和全局变量是统一的，所以是个指针。当然全局变量还需要m_Globals_count来指出可用的全局变量个数。（似乎m_Globals_count是多余的，因为如果引用后面定义的全局变量根本编译不下去）
2.3 变量层级
每进入一个新的层级就执行一次PushLevel，新添变量总是添加在最后一级。
按照新的C标准，for循环是个新的层级，for循环的初始化语句定义的变量仅仅能在for循环里面使用。每个大括号也都表示一个新的层级。
2.4 变量查找
参数查找顺序为局部变量-参数-全局变量-预设变量，这个顺序是符合类C语言通常的规则的。
由于变量添加的时候已经做了同样规则的查找，因此确保不会存在同名变量覆盖。
允许同名变量覆盖不是个好主意，所以我觉得没必要支持。
（这里是结束，但不是整个系列的结束）
1396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
