public override string ToScriptString()
{
#if FULL_VERSION
//与write方法不同，这里输出无缩进单行表示
string line = "";
if (null != m_Call)
{
line = m_Call.ToScriptString();
}
StringBuilder stream = new StringBuilder();
stream.Append(line);
if (HaveStatement())
{
stream.Append("{");
int ct = GetStatementNum();
for (int i = 0; i < ct; ++i)
{
ISyntaxComponent data = GetStatement(i);
stream.Append(data.ToScriptString());
stream.Append(";");
}
stream.Append("}");
}
return(stream.ToString());
#else
return(ToString());
#endif
}
private void simplifyCallData(CallData data)
{
int ct = data.GetParamNum();
for (int i = 0; i < ct; ++i)
{
ISyntaxComponent param = data.GetParam(i);
StatementData statement = param as StatementData;
if (null != statement)
{
data.SetParam(i, simplifyStatement(statement));
}
else
{
FunctionData func = param as FunctionData;
if (null != func)
{
data.SetParam(i, simplifyStatement(func));
}
else
{
CallData call = param as CallData;
if (null != call)
{
data.SetParam(i, simplifyStatement(call));
}
}
}
}
}
public void Init(ISyntaxComponent config)
{
CallData callData = config as CallData;
if (null != callData)
{
Load(callData);
}
else
{
FunctionData funcData = config as FunctionData;
if (null != funcData)
{
Load(funcData);
}
else
{
StatementData statementData = config as StatementData;
if (null != statementData)
{
//是否支持语句类型的触发器语法？
Load(statementData);
}
else
{
//error
}
}
}
}
internal void buildFirstTernaryOperator()
{
int type;
string name = pop(out type);
StatementData arg = popStatement();
ISyntaxComponent argComp = simplifyStatement(arg);
StatementData _statement = newStatement();
FunctionData first = _statement.First;
first.Call.Name.SetLine(getLastLineNumber());
_statement.CopyFirstComments(argComp);
argComp.FirstComments.Clear();
mStatementSemanticStack.Push(_statement);
StatementData statement = getCurStatement();
FunctionData func = getLastFunction();
if (!func.IsValid())
{
func.Call.SetParamClass((int)CallData.ParamClassEnum.PARAM_CLASS_TERNARY_OPERATOR);
func.SetExtentClass((int)FunctionData.ExtentClassEnum.EXTENT_CLASS_STATEMENT);
func.Call.Name.SetId(name);
func.Call.Name.SetType(type);
if (argComp.IsValid())
{
func.Call.AddParams(argComp);
}
}
}
public void SetParam(int index, ISyntaxComponent data)
{
if (index < 0 || index >= m_Params.Count)
{
return;
}
m_Params[index] = data;
}
public void AddParams(ISyntaxComponent param)
{
m_Params.Add(param);
if ((int)ParamClassEnum.PARAM_CLASS_NOTHING == m_ParamClass)
{
m_ParamClass = (int)ParamClassEnum.PARAM_CLASS_PARENTHESIS;
}
}
public void SetStatement(int index, ISyntaxComponent data)
{
if (index < 0 || index >= m_Statements.Count)
{
return;
}
m_Statements[index] = data;
}
public void AddStatement(ISyntaxComponent statement)
{
m_Statements.Add(statement);
if ((int)ExtentClassEnum.EXTENT_CLASS_STATEMENT != m_ExtentClass)
{
m_ExtentClass = (int)ExtentClassEnum.EXTENT_CLASS_STATEMENT;
}
}
private AbstractSyntaxComponent simplifyStatement(CallData data)
{
if (!data.HaveParam())
{
//没有参数的调用退化为基本值数据
if (data.IsHighOrder)
{
//这种情况应该不会出现
return(data);
}
else
{
data.Name.CopyComments(data);
return(data.Name);
}
}
else if (data.GetId() == "-" && data.GetParamNum() == 1)
{
ISyntaxComponent val = data.GetParam(0);
ValueData temp = val as ValueData;
if (null != temp && temp.IsNumber())
{
ValueData ret = new ValueData("-" + temp.GetId(), ValueData.NUM_TOKEN);
ret.CopyComments(temp);
ret.CopyComments(data);
return(ret);
}
else
{
simplifyCallData(data);
return(data);
}
}
else if (data.GetId() == "+" && data.GetParamNum() == 1)
{
ISyntaxComponent val = data.GetParam(0);
ValueData temp = val as ValueData;
if (null != temp && temp.IsNumber())
{
ValueData ret = new ValueData(temp.GetId(), ValueData.NUM_TOKEN);
ret.CopyComments(temp);
ret.CopyComments(data);
return(ret);
}
else
{
simplifyCallData(data);
return(data);
}
}
else
{
//有参数不会退化，对各参数进行化简
simplifyCallData(data);
return(data);
}
}
internal void endStatement()
{
StatementData statement = popStatement();
if (mStatementSemanticStack.Count == 0)
{
simplifyStatementData(statement);
if (!statement.IsValid())
{
//_epsilon_表达式无语句语义
return;
}
//顶层元素结束
ScriptableDataInfo scriptData = new ScriptableDataInfo();
scriptData.CopyFrom(statement);
scriptData.SetLoaded(true);
mScriptDatas.Add(scriptData);
}
else
{
ISyntaxComponent statementSyntax = simplifyStatement(statement);
FunctionData func = getLastFunction();
switch (func.GetExtentClass())
{
case (int)FunctionData.ExtentClassEnum.EXTENT_CLASS_NOTHING:
{
/*这段先暂时注掉，忘记原来为啥要允许空语句作函数参数了(现在对于明确的空串参数不会判断为无效语句了)
* if(func.Call.getParamClass()==(int)CallData.ParamClassEnum.PARAM_CLASS_OPERATOR && !statement.IsValid())
* return;//操作符就不支持空语句作参数了
* //函数参数，允许空语句，用于表达默认状态(副作用是a()与a[]将总是会有一个空语句参数)。
*/
if (statement.IsValid())
{
func.Call.AddParams(statementSyntax);
}
}
break;
case (int)FunctionData.ExtentClassEnum.EXTENT_CLASS_STATEMENT:
{
if (!statement.IsValid())
{
//_epsilon_表达式无语句语义
return;
}
//函数扩展语句部分
func.AddStatement(statementSyntax);
}
break;
}
}
}
private AbstractSyntaxComponent simplifyStatement(FunctionData data)
{
//注意，为了省内存ValueData上不附带注释了，相关接口无实际效果！！！
if (!data.HaveParamOrStatement())
{
//没有参数的调用退化为基本值数据
if (data.IsHighOrder)
{
//这种情况应该不会出现
return(data);
}
else
{
return(data.Name);
}
}
else if (data.GetId() == "-" && data.GetParamNum() == 1)
{
ISyntaxComponent val = data.GetParam(0);
ValueData temp = val as ValueData;
if (null != temp && temp.IsNumber())
{
ValueData ret = new ValueData("-" + temp.GetId(), ValueData.NUM_TOKEN);
return(ret);
}
else
{
return(data);
}
}
else if (data.GetId() == "+" && data.GetParamNum() == 1)
{
ISyntaxComponent val = data.GetParam(0);
ValueData temp = val as ValueData;
if (null != temp && temp.IsNumber())
{
ValueData ret = new ValueData(temp.GetId(), ValueData.NUM_TOKEN);
return(ret);
}
else
{
return(data);
}
}
else
{
return(data);
}
}
public static void writeFunctionData(StringBuilder stream, FunctionData data, int indent, bool isLastOfStatement)
{
#if FULL_VERSION
string line = "";
if (null != data.Call)
{
line = data.Call.ToScriptString();
}
if (data.HaveStatement())
{
if (line.Length > 0)
{
writeLine(stream, line, indent);
}
writeLine(stream, "{", indent);
++indent;
int ct = data.GetStatementNum();
for (int i = 0; i < ct; ++i)
{
ISyntaxComponent tempData = data.GetStatement(i);
writeSyntaxComponent(stream, tempData, indent, true);
}
--indent;
if (isLastOfStatement)
{
writeLine(stream, "};", indent);
}
else
{
writeLine(stream, "}", indent);
}
}
else
{
if (isLastOfStatement)
{
writeLine(stream, line + ";", indent);
}
else
{
writeLine(stream, line, indent);
}
}
#endif
}
public static void writeSyntaxComponent(StringBuilder stream, ISyntaxComponent data, int indent, bool isLastOfStatement)
{
#if FULL_VERSION
ValueData val = data as ValueData;
if (null != val)
{
if (isLastOfStatement)
{
writeLine(stream, val.ToScriptString() + ";", indent);
}
else
{
writeLine(stream, val.ToScriptString(), indent);
}
}
else
{
CallData call = data as CallData;
if (null != call)
{
if (isLastOfStatement)
{
writeLine(stream, call.ToScriptString() + ";", indent);
}
else
{
writeLine(stream, call.ToScriptString(), indent);
}
}
else
{
FunctionData function = data as FunctionData;
if (null != function)
{
writeFunctionData(stream, function, indent, isLastOfStatement);
}
else
{
StatementData statement = data as StatementData;
writeStatementData(stream, statement, indent);
}
}
}
#endif
}
private void buildOperator()
{
int type;
string name = pop(out type);
StatementData arg = popStatement();
ISyntaxComponent argComp = simplifyStatement(arg);
StatementData _statement = newStatementWithOneFunction();
FunctionData first = _statement.First;
first.Name.SetLine(getLastLineNumber());
_statement.CopyFirstComments(argComp);
argComp.FirstComments.Clear();
mStatementSemanticStack.Push(_statement);
StatementData statement = getCurStatement();
FunctionData func = getLastFunction();
if (!func.IsValid())
{
if (name.Length > 0 && name[0] == '`')
{
func.SetParamClass((int)(FunctionData.ParamClassEnum.PARAM_CLASS_WRAP_INFIX_CALL_MASK | FunctionData.ParamClassEnum.PARAM_CLASS_OPERATOR));
func.Name.SetId(name.Substring(1));
func.Name.SetType(type);
}
else
{
func.SetParamClass((int)FunctionData.ParamClassEnum.PARAM_CLASS_OPERATOR);
func.Name.SetId(name);
func.Name.SetType(type);
}
if (argComp.IsValid())
{
func.AddParam(argComp);
}
}
}
public ISkillTriger CreateTriger(ISyntaxComponent trigerConfig)
{
ISkillTriger triger = null;
string type = trigerConfig.GetId();
ISkillTrigerFactory factory = GetFactory(type);
if (null != factory)
{
triger = factory.Create(trigerConfig);
}
//else if (DashFire.GlobalVariables.Instance.IsClient)
//{
// DashFire.LogSystem.Error("CreateTriger failed, unkown type:{0}", type);
//}
if (null != triger)
{
//DashFire.LogSystem.Debug("CreateTriger, type:{0} triger:{1}", type, triger.GetType().Name);
}
return triger;
}
private void buildFirstTernaryOperator()
{
int type;
string name = pop(out type);
StatementData arg = popStatement();
ISyntaxComponent argComp = simplifyStatement(arg);
StatementData _statement = newStatementWithOneFunction();
FunctionData first = _statement.First;
//三元运算符表示成op1(cond)(true_val)op2(false_val)
first.LowerOrderFunction = new FunctionData();
first.LowerOrderFunction.Name = new ValueData();
first.LowerOrderFunction.Name.SetLine(getLastLineNumber());
_statement.CopyFirstComments(argComp);
argComp.FirstComments.Clear();
mStatementSemanticStack.Push(_statement);
StatementData statement = getCurStatement();
FunctionData func = getLastFunction();
if (!func.IsValid())
{
func.LowerOrderFunction.SetParamClass((int)FunctionData.ParamClassEnum.PARAM_CLASS_PARENTHESIS);
func.LowerOrderFunction.Name.SetId(name);
func.LowerOrderFunction.Name.SetType(type);
if (argComp.IsValid())
{
func.LowerOrderFunction.AddParam(argComp);
}
func.SetParamClass((int)FunctionData.ParamClassEnum.PARAM_CLASS_TERNARY_OPERATOR);
}
}
private void simplifyFunctionData(FunctionData data)
{
if (null != data.Call)
{
simplifyCallData(data.Call);
}
if (data.HaveStatement())
{
int ct = data.GetStatementNum();
for (int i = 0; i < ct; ++i)
{
ISyntaxComponent temp = data.GetStatement(i);
StatementData statement = temp as StatementData;
if (null != statement)
{
data.SetStatement(i, simplifyStatement(statement));
}
else
{
FunctionData func = temp as FunctionData;
if (null != func)
{
data.SetStatement(i, simplifyStatement(func));
}
else
{
CallData call = temp as CallData;
if (null != call)
{
data.SetStatement(i, simplifyStatement(call));
}
}
}
}
}
}
internal void endStatement()
{
StatementData statement = popStatement();
if (statement.GetId() == "@@delimiter" && statement.Functions.Count == 1 && (statement.First.Call.GetParamNum() == 1 || statement.First.Call.GetParamNum() == 3) && !statement.First.Call.IsHighOrder)
{
CallData call = statement.First.Call;
string type = call.GetParamId(0);
if (call.GetParamNum() == 3)
{
string begin = call.GetParamId(1);
string end = call.GetParamId(2);
if (type == "string")
{
setStringDelimiter(begin, end);
}
else if (type == "script")
{
setScriptDelimiter(begin, end);
}
else
{
//invalid
}
}
else
{
if (type == "string")
{
setStringDelimiter(string.Empty, string.Empty);
}
else if (type == "script")
{
setScriptDelimiter(string.Empty, string.Empty);
}
else
{
//invalid
}
}
return;
}
bool commentOnNewLine;
IList <string> cmts = GetComments(out commentOnNewLine);
if (cmts.Count > 0)
{
if (statement.LastComments.Count <= 0)
{
statement.LastCommentOnNewLine = commentOnNewLine;
}
statement.LastComments.AddRange(cmts);
}
if (mStatementSemanticStack.Count == 0)
{
//化简只需要处理一级，参数与语句部分应该在添加到语句时已经处理了
AbstractSyntaxComponent statementSyntax = simplifyStatement(statement);
if (!statementSyntax.IsValid())
{
//_epsilon_表达式无语句语义
if (mScriptDatas.Count > 0 && statementSyntax.FirstComments.Count > 0)
{
ISyntaxComponent last = mScriptDatas[mScriptDatas.Count - 1];
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statementSyntax.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statementSyntax.FirstComments);
}
return;
}
else
{
if (mScriptDatas.Count > 0 && !statementSyntax.FirstCommentOnNewLine && statementSyntax.FirstComments.Count > 0)
{
string cmt = statementSyntax.FirstComments[0];
statementSyntax.FirstComments.RemoveAt(0);
statementSyntax.FirstCommentOnNewLine = true;
ISyntaxComponent last = mScriptDatas[mScriptDatas.Count - 1];
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = false;
}
last.LastComments.Add(cmt);
}
}
//顶层元素结束
mScriptDatas.Add(statementSyntax);
}
else
{
//化简只需要处理一级，参数与语句部分应该在添加到语句时已经处理了
AbstractSyntaxComponent statementSyntax = simplifyStatement(statement);
FunctionData func = getLastFunction();
switch (func.GetExtentClass())
{
case (int)FunctionData.ExtentClassEnum.EXTENT_CLASS_NOTHING: {
/*这段先暂时注掉，忘记原来为啥要允许空语句作函数参数了(现在对于明确的空串参数不会判断为无效语句了)
* if(func.Call.getParamClass()==(int)CallData.ParamClassEnum.PARAM_CLASS_OPERATOR && !statement.IsValid())
* return;//操作符就不支持空语句作参数了
* //函数参数，允许空语句，用于表达默认状态(副作用是a()与a[]将总是会有一个空语句参数)。
*/
if (statementSyntax.IsValid())
{
func.Call.AddParams(statementSyntax);
}
else if (statementSyntax.FirstComments.Count > 0)
{
func.Call.Comments.AddRange(statementSyntax.FirstComments);
}
}
break;
case (int)FunctionData.ExtentClassEnum.EXTENT_CLASS_STATEMENT: {
if (!statementSyntax.IsValid())
{
//_epsilon_表达式无语句语义
if (func.Statements.Count > 0 && statementSyntax.FirstComments.Count > 0)
{
AbstractSyntaxComponent last = func.Statements[func.Statements.Count - 1] as AbstractSyntaxComponent;
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statementSyntax.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statementSyntax.FirstComments);
}
return;
}
else
{
if (!statementSyntax.FirstCommentOnNewLine && statementSyntax.FirstComments.Count > 0)
{
string cmt = statementSyntax.FirstComments[0];
statementSyntax.FirstComments.RemoveAt(0);
statementSyntax.FirstCommentOnNewLine = true;
if (func.Statements.Count > 0)
{
AbstractSyntaxComponent last = func.Statements[func.Statements.Count - 1] as AbstractSyntaxComponent;
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = false;
}
last.LastComments.Add(cmt);
}
else
{
func.Call.Comments.Add(cmt);
}
}
}
//函数扩展语句部分
func.AddStatement(statementSyntax);
}
break;
}
}
}
public static void writeSyntaxComponent(StringBuilder stream, ISyntaxComponent data, int indent)
{
#if FULL_VERSION
AbstractSyntaxComponent syntaxComp = data as AbstractSyntaxComponent;
bool isFirst = true;
foreach (string cmt in syntaxComp.FirstComments) {
if (isFirst && !syntaxComp.FirstCommentOnNewLine) {
writeContent(stream, cmt, indent > 0 ? 1 : 0);
} else {
writeLine(stream, cmt, indent);
}
isFirst = false;
}
ValueData val = data as ValueData;
if (null != val) {
writeContent(stream, val.ToScriptString(false) + ";", indent);
} else {
CallData call = data as CallData;
if (null != call) {
writeContent(stream, call.ToScriptString(false) + ";", indent);
writeContent(stream, call.CalcComment(), 0);
} else {
FunctionData function = data as FunctionData;
if (null != function) {
writeFunctionData(stream, function, indent, true);
} else {
StatementData statement = data as StatementData;
writeStatementData(stream, statement, indent);
}
}
}
if (syntaxComp.LastComments.Count > 0) {
if (syntaxComp.LastCommentOnNewLine) {
writeLine(stream, string.Empty, 0);
}
isFirst = true;
foreach (string cmt in syntaxComp.LastComments) {
if (isFirst && !syntaxComp.LastCommentOnNewLine) {
writeLine(stream, cmt, indent > 0 ? 1 : 0);
} else {
writeLine(stream, cmt, indent);
}
isFirst = false;
}
} else {
writeLine(stream, string.Empty, 0);
}
#endif
}
private void endStatement()
{
StatementData statement = popStatement();
if ((null != mSetStringDelimiter || null != mSetScriptDelimiter) && statement.GetId() == "@@delimiter" && statement.Functions.Count == 1 && (statement.First.GetParamNum() == 1 || statement.First.GetParamNum() == 3) && !statement.First.IsHighOrder)
{
FunctionData call = statement.First;
string type = call.GetParamId(0);
if (call.GetParamNum() == 3)
{
string begin = call.GetParamId(1);
string end = call.GetParamId(2);
if (type == "string")
{
setStringDelimiter(begin, end);
}
else if (type == "script")
{
setScriptDelimiter(begin, end);
}
else
{
//invalid
}
}
else
{
if (type == "string")
{
setStringDelimiter(string.Empty, string.Empty);
}
else if (type == "script")
{
setScriptDelimiter(string.Empty, string.Empty);
}
else
{
//invalid
}
}
return;
}
bool commentOnNewLine;
IList <string> cmts = GetComments(out commentOnNewLine);
if (cmts.Count > 0)
{
if (statement.LastComments.Count <= 0)
{
statement.LastCommentOnNewLine = commentOnNewLine;
}
statement.LastComments.AddRange(cmts);
}
if (mStatementSemanticStack.Count == 0)
{
//化简只需要处理一级，参数与语句部分应该在添加到语句时已经处理了
AbstractSyntaxComponent statementSyntax = simplifyStatement(statement);
ValueData vdSyntax = statementSyntax as ValueData;
if (!statementSyntax.IsValid())
{
//_epsilon_表达式无语句语义
if (mScriptDatas.Count > 0)
{
ISyntaxComponent last = mScriptDatas[mScriptDatas.Count - 1];
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statementSyntax.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statementSyntax.FirstComments);
last.LastComments.AddRange(statementSyntax.LastComments);
}
return;
}
else if (null != vdSyntax)
{
//如果语句是普通值，注释挪到上一语句
if (mScriptDatas.Count > 0)
{
ISyntaxComponent last = mScriptDatas[mScriptDatas.Count - 1];
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statement.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statement.FirstComments);
last.LastComments.AddRange(statement.LastComments);
}
}
else
{
//上一行语句的注释挪到上一行语句
if (mScriptDatas.Count > 0 && !statementSyntax.FirstCommentOnNewLine && statementSyntax.FirstComments.Count > 0)
{
string cmt = statementSyntax.FirstComments[0];
statementSyntax.FirstComments.RemoveAt(0);
statementSyntax.FirstCommentOnNewLine = true;
ISyntaxComponent last = mScriptDatas[mScriptDatas.Count - 1];
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = false;
}
last.LastComments.Add(cmt);
}
}
//顶层元素结束
mScriptDatas.Add(statementSyntax);
}
else
{
//化简只需要处理一级，参数与语句部分应该在添加到语句时已经处理了
AbstractSyntaxComponent statementSyntax = simplifyStatement(statement);
ValueData vdSyntax = statementSyntax as ValueData;
FunctionData func = getLastFunction();
if (func.HaveParam())
{
//如果是参数里的注释，保持原样。普通值上的注释会丢弃，嵌入的注释如果挪到行尾会比较莫名其妙。
if (!statementSyntax.IsValid())
{
return;
}
}
else if (!statement.IsValid())
{
//_epsilon_表达式无语句语义
if (func.Params.Count > 0 && statementSyntax.FirstComments.Count > 0)
{
AbstractSyntaxComponent last = func.Params[func.Params.Count - 1] as AbstractSyntaxComponent;
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statementSyntax.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statementSyntax.FirstComments);
last.LastComments.AddRange(statementSyntax.LastComments);
}
return;
}
else if (null != vdSyntax)
{
//如果语句是普通值，注释挪到上一语句
if (func.Params.Count > 0)
{
AbstractSyntaxComponent last = func.Params[func.Params.Count - 1] as AbstractSyntaxComponent;
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = statement.FirstCommentOnNewLine;
}
last.LastComments.AddRange(statement.FirstComments);
last.LastComments.AddRange(statement.LastComments);
}
else
{
func.Comments.AddRange(statement.FirstComments);
func.Comments.AddRange(statement.LastComments);
}
}
else
{
//上一行语句的注释挪到上一行语句或外层函数头或外层函数
if (!statementSyntax.FirstCommentOnNewLine && statementSyntax.FirstComments.Count > 0)
{
string cmt = statementSyntax.FirstComments[0];
statementSyntax.FirstComments.RemoveAt(0);
statementSyntax.FirstCommentOnNewLine = true;
if (func.Params.Count > 0)
{
AbstractSyntaxComponent last = func.Params[func.Params.Count - 1] as AbstractSyntaxComponent;
if (last.LastComments.Count <= 0)
{
last.LastCommentOnNewLine = false;
}
last.LastComments.Add(cmt);
}
else if (func.IsHighOrder)
{
func.LowerOrderFunction.Comments.Add(cmt);
}
else
{
func.Comments.Add(cmt);
}
}
}
func.AddParam(statementSyntax);
}
}
//---------------------------------------------------------------------------------------------
internal static void writeBinary(MemoryStream stream, List<string> identifiers, ISyntaxComponent data)
{
ValueData val = data as ValueData;
if (null != val) {
writeBinary(stream, identifiers, val);
} else {
CallData call = data as CallData;
if (null != call) {
writeBinary(stream, identifiers, call);
} else {
FunctionData function = data as FunctionData;
if (null != function) {
writeBinary(stream, identifiers, function);
} else {
StatementData statement = data as StatementData;
writeBinary(stream, identifiers, statement);
}
}
}
}
public void CopyComments(ISyntaxComponent other)
{
CopyFirstComments(other);
CopyLastComments(other);
}
public void SetStatement(int index, ISyntaxComponent data)
{
if (index < 0 || index >= m_Statements.Count)
return;
m_Statements[index] = data;
}
public static string getCallString(CallData data)
{
#if FULL_VERSION
string lineNo = "";//formatString("/* %d */",data.GetLine());
string line = "";
if (data.IsHighOrder)
{
line = getCallString(data.Call);
}
else if (data.HaveId())
{
line = quoteString(data.GetId(), data.GetIdType());
}
if (data.HaveParam())
{
int paramClass = data.GetParamClass();
if ((int)CallData.ParamClassEnum.PARAM_CLASS_OPERATOR == paramClass)
{
switch (data.GetParamNum())
{
case 1:
return(string.Format("{0} {1}", line, data.GetParam(0).ToScriptString()));
case 2:
return(string.Format("{0} {1} {2}", data.GetParam(0).ToScriptString(), line, data.GetParam(1).ToScriptString()));
default:
return(line);
}
}
else
{
string lbracket = "";
string rbracket = "";
switch (paramClass)
{
case (int)CallData.ParamClassEnum.PARAM_CLASS_PARENTHESIS:
lbracket = "(";
rbracket = ")";
break;
case (int)CallData.ParamClassEnum.PARAM_CLASS_BRACKET:
lbracket = "[";
rbracket = "]";
break;
case (int)CallData.ParamClassEnum.PARAM_CLASS_PERIOD:
lbracket = ".";
rbracket = "";
break;
case (int)CallData.ParamClassEnum.PARAM_CLASS_PERIOD_PARENTHESIS:
lbracket = ".(";
rbracket = ")";
break;
case (int)CallData.ParamClassEnum.PARAM_CLASS_PERIOD_BRACKET:
lbracket = ".[";
rbracket = "]";
break;
case (int)CallData.ParamClassEnum.PARAM_CLASS_PERIOD_BRACE:
lbracket = ".{";
rbracket = "}";
break;
}
StringBuilder stream = new StringBuilder();
stream.Append(lbracket);
int ct = data.GetParamNum();
for (int i = 0; i < ct; ++i)
{
if (i > 0)
{
stream.Append(",");
}
ISyntaxComponent param = data.GetParam(i);
if ((int)CallData.ParamClassEnum.PARAM_CLASS_PERIOD == paramClass)
{
stream.Append(unquoteString(param.ToScriptString()));
}
else
{
stream.Append(param.ToScriptString());
}
}
stream.Append(rbracket);
return(string.Format("{0}{1}{2}", lineNo, line, stream.ToString()));
}
}
else
{
return(string.Format("{0}{1}", lineNo, line));
}
#else
return("");
#endif
}
public void AddStatement(ISyntaxComponent statement)
{
m_Statements.Add(statement);
if ((int)ExtentClassEnum.EXTENT_CLASS_STATEMENT != m_ExtentClass)
{
m_ExtentClass = (int)ExtentClassEnum.EXTENT_CLASS_STATEMENT;
}
}
public void SetParam(int index, ISyntaxComponent data)
{
if (index < 0 || index >= m_Params.Count)
return;
m_Params[index] = data;
}
public void AddParams(ISyntaxComponent param)
{
m_Params.Add(param);
if ((int)ParamClassEnum.PARAM_CLASS_NOTHING == m_ParamClass)
{
m_ParamClass = (int)ParamClassEnum.PARAM_CLASS_PARENTHESIS;
}
}
public static void writeSyntaxComponent(StringBuilder stream, ISyntaxComponent data, int indent, bool isLastOfStatement)
{
#if FULL_VERSION
ValueData val = data as ValueData;
if (null != val)
{
if (isLastOfStatement)
writeLine(stream, val.ToScriptString() + ";", indent);
else
writeLine(stream, val.ToScriptString(), indent);
}
else
{
CallData call = data as CallData;
if (null != call)
{
if (isLastOfStatement)
writeLine(stream, call.ToScriptString() + ";", indent);
else
writeLine(stream, call.ToScriptString(), indent);
}
else
{
FunctionData function = data as FunctionData;
if (null != function)
{
writeFunctionData(stream, function, indent, isLastOfStatement);
}
else
{
StatementData statement = data as StatementData;
writeStatementData(stream, statement, indent);
}
}
}
#endif
}
public void CopyLastComments(ISyntaxComponent other)
{
if (other.LastComments.Count > 0) {
LastComments.AddRange(other.LastComments);
LastCommentOnNewLine = other.LastCommentOnNewLine;
}
}
