public void AddGuessError(ABnfElement element, ABnfGuessError error)
{
{
if (!m_guess_error_map.TryGetValue(element.GetFile(), out Dictionary <ABnfElement, ABnfGuessError> map))
{
map = new Dictionary <ABnfElement, ABnfGuessError>();
m_guess_error_map.Add(element.GetFile(), map);
}
if (map.ContainsKey(element))
{
map.Remove(element);
}
map.Add(element, error);
}
{
if (m_guess_type_map.TryGetValue(element.GetFile(), out Dictionary <ABnfElement, List <ABnfGuess> > map))
{
if (map.ContainsKey(element))
{
map.Remove(element);
}
}
}
}
public ABnfGuessError GuessPreType(out ABnfGuess guess)
{
guess = null;
// 获取父节点
var property_value_suffix = m_element.GetParent() as ALittleScriptPropertyValueSuffixElement;
var property_value = property_value_suffix.GetParent() as ALittleScriptPropertyValueElement;
var property_value_first_type = property_value.GetPropertyValueFirstType();
var suffix_list = property_value.GetPropertyValueSuffixList();
// 获取所在位置
int index = suffix_list.IndexOf(property_value_suffix);
if (index == -1)
{
return(null);
}
// 获取前一个类型
ABnfGuess pre_type = null;
ABnfGuess pre_pre_type = null;
ABnfGuessError error = null;
if (index == 0)
{
error = property_value_first_type.GuessType(out pre_type);
if (error != null)
{
return(error);
}
}
else if (index == 1)
{
error = suffix_list[index - 1].GuessType(out pre_type);
if (error != null)
{
return(error);
}
error = property_value_first_type.GuessType(out pre_pre_type);
if (error != null)
{
return(error);
}
}
else
{
error = suffix_list[index - 1].GuessType(out pre_type);
if (error != null)
{
return(error);
}
error = suffix_list[index - 2].GuessType(out pre_pre_type);
if (error != null)
{
return(error);
}
}
// 如果是Functor
if (pre_type is ALittleScriptGuessFunctor)
{
var pre_type_functor = pre_type as ALittleScriptGuessFunctor;
if (pre_pre_type is ALittleScriptGuessTemplate)
{
pre_pre_type = (pre_pre_type as ALittleScriptGuessTemplate).template_extends;
}
// 如果再往前一个是一个Class实例对象，那么就要去掉第一个参数
if (pre_pre_type is ALittleScriptGuessClass && pre_type_functor.param_list.Count > 0 &&
(pre_type_functor.element is ALittleScriptClassMethodDecElement ||
pre_type_functor.element is ALittleScriptClassGetterDecElement ||
pre_type_functor.element is ALittleScriptClassSetterDecElement))
{
var new_pre_type_functor = new ALittleScriptGuessFunctor(pre_type_functor.element);
pre_type = new_pre_type_functor;
new_pre_type_functor.await_modifier = pre_type_functor.await_modifier;
new_pre_type_functor.const_modifier = pre_type_functor.const_modifier;
new_pre_type_functor.proto = pre_type_functor.proto;
new_pre_type_functor.template_param_list.AddRange(pre_type_functor.template_param_list);
new_pre_type_functor.param_list.AddRange(pre_type_functor.param_list);
new_pre_type_functor.param_nullable_list.AddRange(pre_type_functor.param_nullable_list);
new_pre_type_functor.param_name_list.AddRange(pre_type_functor.param_name_list);
new_pre_type_functor.param_tail = pre_type_functor.param_tail;
new_pre_type_functor.return_list.AddRange(pre_type_functor.return_list);
new_pre_type_functor.return_tail = pre_type_functor.return_tail;
// 移除掉第一个参数
new_pre_type_functor.param_list.RemoveAt(0);
new_pre_type_functor.param_nullable_list.RemoveAt(0);
new_pre_type_functor.param_name_list.RemoveAt(0);
new_pre_type_functor.UpdateValue();
}
}
guess = pre_type;
return(null);
}
public override bool QueryCompletion(int offset, List <ALanguageCompletionInfo> list)
{
// 获取父节点
var property_value_dot_id = m_element;
var property_value_suffix = property_value_dot_id.GetParent() as ALittleScriptPropertyValueSuffixElement;
var property_value = property_value_suffix.GetParent() as ALittleScriptPropertyValueElement;
var property_value_first_type = property_value.GetPropertyValueFirstType();
var suffix_list = property_value.GetPropertyValueSuffixList();
// 获取所在位置
int index = suffix_list.IndexOf(property_value_suffix);
if (index == -1)
{
return(false);
}
// 获取前一个类型
ABnfGuess pre_type;
ABnfGuessError error = null;
if (index == 0)
{
error = property_value_first_type.GuessType(out pre_type);
}
else
{
error = suffix_list[index - 1].GuessType(out pre_type);
}
if (error != null)
{
return(false);
}
bool is_const = false;
if (pre_type != null)
{
is_const = pre_type.is_const;
}
if (pre_type is ALittleScriptGuessTemplate)
{
pre_type = (pre_type as ALittleScriptGuessTemplate).template_extends;
if (is_const && !pre_type.is_const)
{
pre_type = pre_type.Clone();
pre_type.is_const = true;
pre_type.UpdateValue();
}
}
if (pre_type == null)
{
return(false);
}
// 处理类的实例对象
if (pre_type is ALittleScriptGuessClass)
{
var class_dec = (pre_type as ALittleScriptGuessClass).class_dec;
// 计算当前元素对这个类的访问权限
int access_level = ALittleScriptUtility.CalcAccessLevelByTargetClassDecForElement(m_element, class_dec);
var class_var_dec_list = new List <ABnfElement>();
// 所有成员变量
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.VAR, "", class_var_dec_list, 100);
foreach (var dec in class_var_dec_list)
{
var class_var_dec = dec as ALittleScriptClassVarDecElement;
if (class_var_dec == null)
{
continue;
}
var class_var_name_dec = class_var_dec.GetClassVarNameDec();
if (class_var_name_dec == null)
{
continue;
}
list.Add(new ALanguageCompletionInfo(class_var_name_dec.GetElementText(), ALittleScriptIndex.inst.sVariableIcon));
}
// 所有setter,getter
var class_method_name_dec_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.SETTER, "", class_method_name_dec_list, 100);
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.GETTER, "", class_method_name_dec_list, 100);
class_method_name_dec_list = ALittleScriptUtility.FilterSameName(class_method_name_dec_list);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_method_name_dec.GetElementText(), ALittleScriptIndex.inst.sFieldMethodIcon));
}
// 所有成员函数
class_method_name_dec_list.Clear();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.FUN, "", class_method_name_dec_list, 10);
class_method_name_dec_list = ALittleScriptUtility.FilterSameName(class_method_name_dec_list);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_method_name_dec.GetElementText(), ALittleScriptIndex.inst.sMemberMethodIcon));
}
}
// 处理结构体的实例对象
else if (pre_type is ALittleScriptGuessStruct)
{
var struct_dec = ((ALittleScriptGuessStruct)pre_type).struct_dec;
var struct_var_dec_list = new List <ALittleScriptStructVarDecElement>();
// 所有成员变量
ALittleScriptUtility.FindStructVarDecList(struct_dec, "", struct_var_dec_list, 100);
foreach (var struct_var_dec in struct_var_dec_list)
{
var name_dec = struct_var_dec.GetStructVarNameDec();
if (name_dec == null)
{
continue;
}
list.Add(new ALanguageCompletionInfo(name_dec.GetElementText(), ALittleScriptIndex.inst.sPropertyIcon));
}
}
// 比如 ALittleName.XXX
else if (pre_type is ALittleScriptGuessNamespaceName)
{
var namespace_name_dec = ((ALittleScriptGuessNamespaceName)pre_type).namespace_name_dec;
string namespace_name = namespace_name_dec.GetElementText();
// 所有枚举名
var enum_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.ENUM_NAME, m_element.GetFile(), namespace_name, "", true);
foreach (var enum_name_dec in enum_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(enum_name_dec.GetElementText(), ALittleScriptIndex.inst.sEnumIcon));
}
// 所有全局函数
var method_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.GLOBAL_METHOD, m_element.GetFile(), namespace_name, "", true);
foreach (var method_name_dec in method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(method_name_dec.GetElementText(), ALittleScriptIndex.inst.sGlobalMethodIcon));
}
// 所有类名
var class_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.CLASS_NAME, m_element.GetFile(), namespace_name, "", true);
foreach (var class_name_dec in class_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_name_dec.GetElementText(), ALittleScriptIndex.inst.sClassIcon));
}
// 所有结构体名
var struct_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.STRUCT_NAME, m_element.GetFile(), namespace_name, "", true);
foreach (var struct_name_dec in struct_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(struct_name_dec.GetElementText(), ALittleScriptIndex.inst.sStructIcon));
}
// 所有单例
var instance_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.INSTANCE_NAME, m_element.GetFile(), namespace_name, "", false);
foreach (var instance_name_dec in instance_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(instance_name_dec.GetElementText(), ALittleScriptIndex.inst.sInstanceIcon));
}
}
// 比如 AClassName.XXX
else if (pre_type is ALittleScriptGuessClassName)
{
var class_name_dec = ((ALittleScriptGuessClassName)pre_type).class_name_dec;
var class_dec = class_name_dec.GetParent() as ALittleScriptClassDecElement;
// 计算当前元素对这个类的访问权限
int access_level = ALittleScriptUtility.CalcAccessLevelByTargetClassDecForElement(m_element, class_dec);
// 所有静态函数
var class_method_name_dec_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.STATIC, "", class_method_name_dec_list, 100);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_method_name_dec.GetElementText(), ALittleScriptIndex.inst.sStaticMethodIcon));
}
// 所有成员函数
class_method_name_dec_list.Clear();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.FUN, "", class_method_name_dec_list, 100);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_method_name_dec.GetElementText(), ALittleScriptIndex.inst.sMemberMethodIcon));
}
// 所有setter,getter
class_method_name_dec_list.Clear();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.SETTER, "", class_method_name_dec_list, 100);
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.GETTER, "", class_method_name_dec_list, 100);
class_method_name_dec_list = ALittleScriptUtility.FilterSameName(class_method_name_dec_list);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
list.Add(new ALanguageCompletionInfo(class_method_name_dec.GetElementText(), ALittleScriptIndex.inst.sFieldMethodIcon));
}
;
}
// 比如 AEnum.XXX
else if (pre_type is ALittleScriptGuessEnumName)
{
// 所有枚举字段
var enum_name_dec = ((ALittleScriptGuessEnumName)pre_type).enum_name_dec;
var enum_dec = enum_name_dec.GetParent() as ALittleScriptEnumDecElement;
var var_dec_list = new List <ALittleScriptEnumVarDecElement>();
ALittleScriptUtility.FindEnumVarDecList(enum_dec, "", var_dec_list);
foreach (var var_dec in var_dec_list)
{
var var_name_dec = var_dec.GetEnumVarNameDec();
if (var_name_dec == null)
{
continue;
}
list.Add(new ALanguageCompletionInfo(var_name_dec.GetElementText(), ALittleScriptIndex.inst.sEnumIcon));
}
}
return(true);
}
public override ABnfGuessError GuessTypes(out List <ABnfGuess> guess_list)
{
guess_list = null;
ABnfGuessError error = null;
bool is_const = m_element.GetAllTypeConst() != null;
if (m_element.GetCustomType() != null)
{
error = m_element.GetCustomType().GuessTypes(out guess_list);
}
else if (m_element.GetGenericType() != null)
{
error = m_element.GetGenericType().GuessTypes(out guess_list);
}
else if (m_element.GetPrimitiveType() != null)
{
error = m_element.GetPrimitiveType().GuessTypes(out guess_list);
}
if (error != null)
{
return(error);
}
if (guess_list != null)
{
if (!is_const)
{
return(null);
}
for (int i = 0; i < guess_list.Count; ++i)
{
var guess = guess_list[i];
if (guess.is_const)
{
continue;
}
if (guess is ALittleScriptGuessPrimitive)
{
ALittleScriptIndex.inst.sPrimitiveGuessListMap.TryGetValue("const " + guess.GetValue(), out guess_list);
if (guess_list == null)
{
return(new ABnfGuessError(m_element, "找不到const " + guess.GetValue()));
}
break;
}
else
{
guess = guess.Clone();
guess.is_const = true;
guess.UpdateValue();
}
guess_list[i] = guess;
}
return(null);
}
return(new ABnfGuessError(m_element, "AllType出现未知的子节点"));
}
public override ABnfGuessError CheckError()
{
var value_stat = m_element.GetValueStat();
if (value_stat == null)
{
return(null);
}
// 获取父节点
var property_value_suffix = m_element.GetParent() as ALittleScriptPropertyValueSuffixElement;
var property_value = property_value_suffix.GetParent() as ALittleScriptPropertyValueElement;
var property_value_first_type = property_value.GetPropertyValueFirstType();
var suffixList = property_value.GetPropertyValueSuffixList();
// 获取所在位置
int index = suffixList.IndexOf(property_value_suffix);
if (index == -1)
{
return(null);
}
// 获取前一个类型
ABnfGuess pre_type;
ABnfGuessError error = null;
if (index == 0)
{
error = property_value_first_type.GuessType(out pre_type);
}
else
{
error = suffixList[index - 1].GuessType(out pre_type);
}
if (error != null)
{
return(error);
}
error = ALittleScriptUtility.CalcReturnCount(value_stat, out int return_count, out _);
if (error != null)
{
return(error);
}
if (return_count != 1)
{
return(new ABnfGuessError(value_stat, "表达式必须只能是一个返回值"));
}
error = value_stat.GuessType(out ABnfGuess key_guess_type);
if (error != null)
{
return(error);
}
// 获取类型
if (pre_type is ALittleScriptGuessList)
{
if (!(key_guess_type is ALittleScriptGuessInt) && !(key_guess_type is ALittleScriptGuessLong))
{
return(new ABnfGuessError(value_stat, "索引值的类型必须是int或者是long，不能是:" + key_guess_type.GetValue()));
}
}
else if (pre_type is ALittleScriptGuessMap)
{
var pre_type_map = pre_type as ALittleScriptGuessMap;
error = ALittleScriptOp.GuessTypeEqual(((ALittleScriptGuessMap)pre_type).key_type, value_stat, key_guess_type, true, false);
if (error != null)
{
return(new ABnfGuessError(error.GetElement(), "索引值的类型不能是:" + key_guess_type.GetValue() + " :" + error.GetError()));
}
}
{
error = m_element.GuessTypes(out List <ABnfGuess> guess_list);
if (error != null)
{
return(error);
}
if (guess_list.Count == 0)
{
return(new ABnfGuessError(m_element, "该元素不能直接使用[]取值，请先cast"));
}
else if (guess_list.Count != 1)
{
return(new ABnfGuessError(m_element, "重复定义"));
}
return(null);
}
}
public override ABnfGuessError GuessTypes(out List <ABnfGuess> guess_list)
{
guess_list = new List <ABnfGuess>();
// 获取父节点
var property_value_suffix = m_element.GetParent() as ALittleScriptPropertyValueSuffixElement;
var property_value = property_value_suffix.GetParent() as ALittleScriptPropertyValueElement;
var property_value_first_type = property_value.GetPropertyValueFirstType();
var suffix_list = property_value.GetPropertyValueSuffixList();
// 获取所在位置
int index = suffix_list.IndexOf(property_value_suffix);
if (index == -1)
{
return(null);
}
// 获取前一个类型
ABnfGuess pre_type;
ABnfGuessError error = null;
if (index == 0)
{
error = property_value_first_type.GuessType(out pre_type);
}
else
{
error = suffix_list[index - 1].GuessType(out pre_type);
}
if (error != null)
{
return(error);
}
// 获取类型
if (pre_type is ALittleScriptGuessList)
{
var sub_type = ((ALittleScriptGuessList)pre_type).sub_type;
if (pre_type.is_const && !sub_type.is_const)
{
sub_type = sub_type.Clone();
sub_type.is_const = true;
sub_type.UpdateValue();
}
guess_list.Add(sub_type);
}
else if (pre_type is ALittleScriptGuessMap)
{
var value_type = ((ALittleScriptGuessMap)pre_type).value_type;
if (pre_type.is_const && !value_type.is_const)
{
value_type = value_type.Clone();
value_type.is_const = true;
value_type.UpdateValue();
}
guess_list.Add(value_type);
}
return(null);
}
private ABnfGuessError CheckProtoError()
{
var parent = m_element.GetParent() as ALittleScriptNamespaceElementDecElement;
var proto_type = ALittleScriptUtility.GetProtocolType(parent.GetModifierList());
if (proto_type == null)
{
return(null);
}
var co_text = ALittleScriptUtility.GetCoroutineType(parent.GetModifierList());
var param_dec = m_element.GetMethodParamDec();
var return_dec = m_element.GetMethodReturnDec();
string text = proto_type;
if (m_element.GetTemplateDec() != null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，不能使用模板"));
}
if (param_dec == null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须有参数"));
}
var return_list = new List <ALittleScriptAllTypeElement>();
if (return_dec != null)
{
var return_one_list = return_dec.GetMethodReturnOneDecList();
foreach (var return_one in return_one_list)
{
if (return_one.GetMethodReturnTailDec() != null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，不能使用返回值占位符"));
}
var all_type = return_one.GetAllType();
if (all_type == null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，返回值没有定义类型"));
}
return_list.Add(all_type);
}
}
var param_one_dec_list = param_dec.GetMethodParamOneDecList();
var param_guess_list = new List <ABnfGuess>();
foreach (var param_one_dec in param_one_dec_list)
{
if (param_one_dec.GetMethodParamTailDec() != null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，不能使用参数占位符"));
}
var all_type = param_one_dec.GetAllType();
if (all_type == null)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，参数没有定义类型"));
}
var guess_error = all_type.GuessType(out ABnfGuess all_type_guess);
if (guess_error != null)
{
return(guess_error);
}
param_guess_list.Add(all_type_guess);
}
var return_guess_list = new List <ABnfGuess>();
foreach (var all_type in return_list)
{
var guess_error = all_type.GuessType(out ABnfGuess all_type_guess);
if (guess_error != null)
{
return(guess_error);
}
return_guess_list.Add(all_type_guess);
}
if (co_text == "async" && return_guess_list.Count > 0)
{
return(new ABnfGuessError(return_dec, "带async修饰的函数，不能有返回值"));
}
// 检查参数个数
if (param_guess_list.Count != 2)
{
return(new ABnfGuessError(param_dec, "带" + text + "的全局函数，必须有两个参数"));
}
// 第二个参数
if (!(param_guess_list[1] is ALittleScriptGuessStruct))
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，第二个参数必须是struct"));
}
ABnfGuessError error = null;
if (text == "Http")
{
if (co_text != "await")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须使用await修饰"));
}
if (return_guess_list.Count != 1)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须有一个返回值"));
}
// 第一个参数
if (param_guess_list[0].GetValue() != "ALittle.IHttpReceiver")
{
return(new ABnfGuessError(param_one_dec_list[0], "带" + text + "的全局函数，第一个参数必须是ALittle.IHttpReceiver"));
}
// 返回值
if (!(return_guess_list[0] is ALittleScriptGuessStruct))
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，返回值必须是struct"));
}
error = CheckJsonStruct(param_one_dec_list[1], param_guess_list[1], new HashSet <string>());
if (error != null)
{
return(error);
}
error = CheckJsonStruct(return_list[0], return_guess_list[0], new HashSet <string>());
if (error != null)
{
return(error);
}
}
else if (text == "HttpDownload")
{
if (co_text != "await")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须使用await修饰"));
}
if (return_guess_list.Count != 2)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须有两个返回值，一个是string，一个是int"));
}
if (return_guess_list[0].GetValue() != "string")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，第一个参数必须是string"));
}
if (return_guess_list[1].GetValue() != "int")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，第二个参数必须是int"));
}
// 第一个参数
if (param_guess_list[0].GetValue() != "ALittle.IHttpReceiver")
{
return(new ABnfGuessError(param_one_dec_list[0], "带" + text + "的全局函数，第一个参数必须是ALittle.IHttpReceiver"));
}
error = CheckJsonStruct(param_one_dec_list[1], param_guess_list[1], new HashSet <string>());
if (error != null)
{
return(error);
}
}
else if (text == "HttpUpload")
{
if (co_text != "await")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，必须使用await修饰"));
}
// 第一个参数
if (param_guess_list[0].GetValue() != "ALittle.IHttpFileReceiver")
{
return(new ABnfGuessError(param_one_dec_list[0], "带" + text + "的全局函数，第一个参数必须是ALittle.IHttpFileReceiver"));
}
error = CheckJsonStruct(param_one_dec_list[1], param_guess_list[1], new HashSet <string>());
if (error != null)
{
return(error);
}
// 返回值
if (return_guess_list.Count != 0)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，不能有返回值"));
}
}
else if (text == "Msg")
{
if (return_guess_list.Count > 1)
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，最多只能有一个返回值"));
}
// 第一个参数
if (param_guess_list[0].GetValue() != "ALittle.IMsgCommon")
{
return(new ABnfGuessError(param_one_dec_list[0], "带" + text + "的全局函数，第一个参数必须是ALittle.IMsgCommon"));
}
error = CheckMsgStruct(param_one_dec_list[1], param_guess_list[1], new HashSet <string>());
if (error != null)
{
return(error);
}
// 返回值
if (return_guess_list.Count > 0)
{
if (co_text != "await")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，并且有返回值，必须使用await修饰"));
}
if (!(return_guess_list[0] is ALittleScriptGuessStruct))
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，返回值必须是struct"));
}
error = CheckMsgStruct(return_list[0], return_guess_list[0], new HashSet <string>());
if (error != null)
{
return(error);
}
}
else
{
// 如果没有返回值，那么不能使用await，只能使用async，或者不使用
if (co_text == "await")
{
return(new ABnfGuessError(m_element, "带" + text + "的全局函数，当没有返回值时，不能使用await，可以使用async"));
}
}
}
return(null);
}
public override ABnfGuessError GuessTypes(ABnfElement element, out List <ABnfGuess> guess_list)
{
guess_list = null;
var error = ALittleScriptIndex.inst.GetGuessError(element);
if (error != null)
{
return(error);
}
guess_list = ALittleScriptIndex.inst.GetGuessTypeList(element);
if (guess_list != null && guess_list.Count > 0)
{
bool is_changed = false;
foreach (var guess in guess_list)
{
if (guess.IsChanged())
{
is_changed = true;
break;
}
}
if (!is_changed)
{
return(null);
}
}
var reference = element.GetReference();
if (reference == null)
{
error = new ABnfGuessError(element, "ALittleReference对象创建失败 element:" + element);
ALittleScriptIndex.inst.AddGuessError(element, error);
return(error);
}
error = reference.GuessTypes(out guess_list);
if (error != null)
{
ALittleScriptIndex.inst.AddGuessError(element, error);
return(error);
}
if (guess_list == null)
{
guess_list = new List <ABnfGuess>();
}
// 如果是两个，并且一个是register，一个不是。那么就要把register那个删掉
if (!reference.MultiGuessTypes() &&
guess_list.Count == 2 &&
guess_list[0].GetValue() == guess_list[1].GetValue() &&
guess_list[0] is ALittleScriptGuess &&
guess_list[1] is ALittleScriptGuess)
{
if ((guess_list[0] as ALittleScriptGuess).is_register && !(guess_list[1] as ALittleScriptGuess).is_register)
{
guess_list.RemoveAt(0);
}
else if (!(guess_list[0] as ALittleScriptGuess).is_register && (guess_list[1] as ALittleScriptGuess).is_register)
{
guess_list.RemoveAt(1);
}
}
foreach (var guess in guess_list)
{
if (guess == null)
{
error = new ABnfGuessError(element, "guess列表出现null:" + element);
ALittleScriptIndex.inst.AddGuessError(element, error);
return(error);
}
}
ALittleScriptIndex.inst.AddGuessTypeList(element, guess_list);
return(null);
}
private ABnfGuessError CalcResolve(out List <ABnfElement> result_list, out ABnfGuess pre_type)
{
pre_type = null;
result_list = new List <ABnfElement>();
if (m_key.Length == 0)
{
return(null);
}
// 获取父节点
var property_value_dot_id = m_element.GetParent() as ALittleScriptPropertyValueDotIdElement;
var property_value_suffix = property_value_dot_id.GetParent() as ALittleScriptPropertyValueSuffixElement;
var property_value = property_value_suffix.GetParent() as ALittleScriptPropertyValueElement;
var property_value_first_type = property_value.GetPropertyValueFirstType();
var suffix_list = property_value.GetPropertyValueSuffixList();
// 获取所在位置
int index = suffix_list.IndexOf(property_value_suffix);
if (index == -1)
{
return(null);
}
ABnfGuessError error = null;
if (index == 0)
{
error = property_value_first_type.GuessType(out pre_type);
}
else
{
error = suffix_list[index - 1].GuessType(out pre_type);
}
if (error != null)
{
return(error);
}
// 判断当前后缀是否是最后一个后缀
ALittleScriptPropertyValueSuffixElement next_suffix = null;
if (index + 1 < suffix_list.Count)
{
next_suffix = suffix_list[index + 1];
}
bool is_const = false;
if (pre_type != null)
{
is_const = pre_type.is_const;
}
if (pre_type is ALittleScriptGuessTemplate)
{
pre_type = (pre_type as ALittleScriptGuessTemplate).template_extends;
if (pre_type != null && is_const && !pre_type.is_const)
{
pre_type = pre_type.Clone();
pre_type.is_const = true;
pre_type.UpdateValue();
}
}
if (pre_type == null)
{
return(null);
}
// 处理类的实例对象
if (pre_type is ALittleScriptGuessClass)
{
m_class_guess = pre_type as ALittleScriptGuessClass;
var class_dec = m_class_guess.class_dec;
// 计算当前元素对这个类的访问权限
int access_level = ALittleScriptUtility.CalcAccessLevelByTargetClassDecForElement(m_element, class_dec);
// 所有成员变量
var class_var_dec_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec,
access_level, ALittleScriptUtility.ClassAttrType.VAR, m_key, class_var_dec_list, 100);
foreach (var class_var_dec in class_var_dec_list)
{
result_list.Add(class_var_dec);
}
var class_method_name_dec_list = new List <ABnfElement>();
// 在当前情况下，只有当前property_value在等号的左边，并且是最后一个属性才是setter，否则都是getter
if (next_suffix == null && property_value.GetParent() is ALittleScriptOpAssignExprElement)
{
m_setter_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.SETTER, m_key, m_setter_list, 100);
class_method_name_dec_list.AddRange(m_setter_list);
}
else
{
m_getter_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.GETTER, m_key, m_getter_list, 100);
class_method_name_dec_list.AddRange(m_getter_list);
}
// 所有成员函数
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.FUN, m_key, class_method_name_dec_list, 100);
// 添加函数名元素
class_method_name_dec_list = ALittleScriptUtility.FilterSameName(class_method_name_dec_list);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
result_list.Add(class_method_name_dec);
}
// 处理结构体的实例对象
}
else if (pre_type is ALittleScriptGuessStruct)
{
var struct_dec = ((ALittleScriptGuessStruct)pre_type).struct_dec;
var struct_var_dec_list = new List <ALittleScriptStructVarDecElement>();
// 所有成员变量
ALittleScriptUtility.FindStructVarDecList(struct_dec, m_key, struct_var_dec_list, 100);
foreach (var struct_var_dec in struct_var_dec_list)
{
result_list.Add(struct_var_dec);
}
// 比如 ALittleName.XXX
}
else if (pre_type is ALittleScriptGuessNamespaceName)
{
var namespace_name_dec = ((ALittleScriptGuessNamespaceName)pre_type).namespace_name_dec;
string namespace_name = namespace_name_dec.GetElementText();
// 所有枚举名
var enum_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.ENUM_NAME, m_element.GetFile(), namespace_name, m_key, true);
foreach (var enum_name_dec in enum_name_dec_list)
{
result_list.Add(enum_name_dec);
}
// 所有全局函数
var method_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.GLOBAL_METHOD, m_element.GetFile(), namespace_name, m_key, true);
foreach (var method_name_dec in method_name_dec_list)
{
result_list.Add(method_name_dec);
}
// 所有类名
var class_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.CLASS_NAME, m_element.GetFile(), namespace_name, m_key, true);
foreach (var class_name_dec in class_name_dec_list)
{
result_list.Add(class_name_dec);
}
// 所有结构体名
var struct_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.STRUCT_NAME, m_element.GetFile(), namespace_name, m_key, true);
foreach (var struct_name_dec in struct_name_dec_list)
{
result_list.Add(struct_name_dec);
}
// 所有单例
var instance_name_dec_list = ALittleScriptIndex.inst.FindALittleNameDecList(
ALittleScriptUtility.ABnfElementType.INSTANCE_NAME, m_element.GetFile(), namespace_name, m_key, false);
foreach (var instance_name_dec in instance_name_dec_list)
{
result_list.Add(instance_name_dec);
}
// 比如 AClassName.XXX
}
else if (pre_type is ALittleScriptGuessClassName)
{
var class_name_dec = ((ALittleScriptGuessClassName)pre_type).class_name_dec;
var class_dec = class_name_dec.GetParent() as ALittleScriptClassDecElement;
// 计算当前元素对这个类的访问权限
int access_level = ALittleScriptUtility.CalcAccessLevelByTargetClassDecForElement(m_element, class_dec);
// 所有静态函数
var class_method_name_dec_list = new List <ABnfElement>();
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.STATIC, m_key, class_method_name_dec_list, 100);
// 如果后面那个是MethodCall，并且有两个参数的是setter，是一个参数的是getter，否则两个都不是
if (next_suffix != null)
{
var method_call_stat = next_suffix.GetPropertyValueMethodCall();
if (method_call_stat != null)
{
int paramCount = method_call_stat.GetValueStatList().Count;
if (paramCount == 1)
{
// 所有getter
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.GETTER, m_key, class_method_name_dec_list, 100);
}
else if (paramCount == 2)
{
// 所有setter
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.SETTER, m_key, class_method_name_dec_list, 100);
}
}
}
// 所有成员函数
ALittleScriptUtility.FindClassAttrList(class_dec, access_level, ALittleScriptUtility.ClassAttrType.FUN, m_key, class_method_name_dec_list, 100);
class_method_name_dec_list = ALittleScriptUtility.FilterSameName(class_method_name_dec_list);
foreach (var class_method_name_dec in class_method_name_dec_list)
{
result_list.Add(class_method_name_dec);
}
// 比如 AEnumName.XXX
}
else if (pre_type is ALittleScriptGuessEnumName)
{
// 所有枚举字段
var enum_name_dec = ((ALittleScriptGuessEnumName)pre_type).enum_name_dec;
var enum_dec = enum_name_dec.GetParent() as ALittleScriptEnumDecElement;
var var_dec_list = new List <ALittleScriptEnumVarDecElement>();
ALittleScriptUtility.FindEnumVarDecList(enum_dec, m_key, var_dec_list);
foreach (var var_name_dec in var_dec_list)
{
result_list.Add(var_name_dec);
}
}
return(null);
}
