//Добавляет интерфейс и всех его предков в список реализуемых данным классом.
public static void AddInterface(common_type_node cnode, type_node _interface, location loc)
{
if (original_types_equals(_interface, cnode))
{
throw new TreeConverter.UndefinedNameReference(_interface.name, loc);
}
if (!_interface.IsInterface)
{
throw new TreeConverter.SimpleSemanticError(loc, "{0}_IS_NOT_INTERFACE", _interface.name);
}
if (_interface.ForwardDeclarationOnly)
{
throw new TreeConverter.SimpleSemanticError(loc, "FORWARD_DECLARATION_{0}_AS_IMPLEMENTING_INTERFACE", _interface.name);
}
if (!cnode.ImplementingInterfaces.Contains(_interface))
{
cnode.ImplementingInterfaces.Add(_interface);
foreach (type_node tn in _interface.ImplementingInterfaces)
{
if (!cnode.ImplementingInterfaces.Contains(tn))
{
cnode.ImplementingInterfaces.Add(tn);
}
}
}
}
private static type_compare get_table_type_compare(type_node left, type_node right)
{
type_intersection_node[] tins = get_type_intersections(left, right);
if (tins.Length == 0)
{
return(type_compare.non_comparable_type);
}
if (tins.Length == 1)
{
return(tins[0].type_compare);
}
if (tins.Length == 2)
{
type_compare tc1 = tins[0].type_compare;
type_compare tc2 = tins[1].type_compare;
if ((tc1 == type_compare.non_comparable_type) && (tc2 == type_compare.non_comparable_type))
{
return(type_compare.non_comparable_type);
}
if ((tc1 == type_compare.greater_type) && (tc2 == type_compare.less_type))
{
return(type_compare.greater_type);
}
if ((tc1 == type_compare.less_type) && (tc2 == type_compare.greater_type))
{
return(type_compare.less_type);
}
throw new PascalABCCompiler.TreeConverter.CompilerInternalError("Conflicting type comparsion");
}
return(type_compare.non_comparable_type);
}
private void ForeachCheckAndConvert(foreach_stmt _foreach_stmt, out expression_node foreachCollection,
out var_definition_node foreachVariable)
{
var lambdaSearcher = new LambdaSearcher(_foreach_stmt.in_what);
if (lambdaSearcher.CheckIfContainsLambdas())
{
AddError(new LambdasNotAllowedInForeachInWhatSatetement(get_location(lambdaSearcher.FoundLambda)));
}
foreachCollection = convert_strong(_foreach_stmt.in_what);
expression_node tmp = convert_if_typed_expression_to_function_call(foreachCollection);
if (tmp.type != null)
{
foreachCollection = tmp;
}
bool sys_coll_ienum; // true означает, что мы нашли тип object у интерфейса System.Collections.IEnumerable
type_node elem_type = null;
if (!FindIEnumerableElementType(foreachCollection.type, ref elem_type, out sys_coll_ienum))
{
AddError(foreachCollection.location, "CAN_NOT_EXECUTE_FOREACH_BY_EXPR_OF_TYPE_{0}", foreachCollection.type.name);
}
CheckToEmbeddedStatementCannotBeADeclaration(_foreach_stmt.stmt);
foreachVariable = FindForeachVariable(_foreach_stmt, elem_type, sys_coll_ienum);
}
public delegate_internal_interface(type_node return_value_type, function_node invoke_method,
function_node constructor)
{
_return_value_type = return_value_type;
_invoke_method = invoke_method;
_constructor = constructor;
}
/// <summary>
/// Автовыведение типов в yield'ax.
/// </summary>
private void ProcessAssigntToAutoType(addressed_expression to, ref expression_node from)
{
var sequence = to.type as compiled_generic_instance_type_node;
// SSM 26.06.16 - правка в связи с автовыведением типов в yieldах
if (to.type is auto_type)
{
try_convert_typed_expression_to_function_call(ref from);
if (to is class_field_reference)
{
var cfr = to as class_field_reference;
cfr.field.type = from.type;
cfr.type = from.type; // Это неверно работает когда yieldится процедура #1439
// SSM 1.11.18 попытка правки возвращения процедуры в yield
//if (from.type.semantic_node_type == semantic_node_type.delegated_method)
cfr.field.inital_value = context.GetInitalValueForVariable(cfr.field, cfr.field.inital_value);
}
else if (to is local_block_variable_reference)
{
var lvr = to as local_block_variable_reference;
lvr.var.type = from.type;
lvr.type = from.type;
lvr.var.inital_value = context.GetInitalValueForVariable(lvr.var, lvr.var.inital_value);
}
else
{
AddError(to.location, "Не могу вывести тип при наличии yield: " + to.type.full_name);
}
//to.type = from.type; // и без всякого real_type!
}
else if (sequence?.instance_params[0] is ienumerable_auto_type)
{
type_node elem_type = null;
try_convert_typed_expression_to_function_call(ref from);
bool bb; // здесь bb не нужно. Оно нужно в foreach
var b = FindIEnumerableElementType(from.type, ref elem_type, out bb);
if (!b)
{
AddError(from.location, "CAN_NOT_EXECUTE_FOREACH_BY_EXPR_OF_TYPE_{0}", from.type.full_name);
}
var IEnumType = new template_type_reference(new named_type_reference("System.Collections.Generic.IEnumerable"),
new template_param_list(new semantic_type_node(elem_type)));
if (to is class_field_reference)
{
var cfr = to as class_field_reference;
cfr.field.type = convert_strong(IEnumType);
cfr.type = cfr.field.type;
}
else if (to is local_block_variable_reference)
{
var lvr = to as local_block_variable_reference;
lvr.var.type = convert_strong(IEnumType); // замена типа у описания переменной
lvr.type = lvr.var.type; // замена типа у переменной
}
}
}
public static bool is_with_nil_allowed(type_node tn)
{
//(ssyy) переписал нормально, через switch
switch (tn.type_special_kind)
{
case SemanticTree.type_special_kind.array_wrapper:
case SemanticTree.type_special_kind.binary_file:
case SemanticTree.type_special_kind.diap_type:
case SemanticTree.type_special_kind.enum_kind:
case SemanticTree.type_special_kind.set_type:
case SemanticTree.type_special_kind.short_string:
case SemanticTree.type_special_kind.text_file:
case SemanticTree.type_special_kind.typed_file:
return(false);
default:
if (tn == SystemLibrary.SystemLibInitializer.AbstractBinaryFileNode)
{
return(false);
}
if (tn.is_generic_parameter)
{
return(tn.is_class || tn.base_type != SystemLibrary.SystemLibrary.object_type && tn.base_type.is_class);
}
else if (tn is ref_type_node)
{
return(true);
}
else
{
return(!tn.is_value || tn is null_type_node);
}
}
}
public wrapped_common_type_node(PCUReader pr, type_node base_type, string name, SemanticTree.type_access_level type_access_level,
common_namespace_node comprehensive_namespace, SymbolTable.ClassScope cs, location loc, int offset) :
base(base_type, name, type_access_level, comprehensive_namespace, cs, loc)
{
this.pr = pr;
this.offset = offset;
}
public exception_filter(type_node filter_type, local_block_variable_reference exception_var,
statement_node exception_handler, location loc) : base(loc)
{
_filter_type = filter_type;
_exception_var = exception_var;
_exception_handler = exception_handler;
}
public void UpdateReturnType()
{
if (!_ret_type_generated)
{
type_node tn = _functions[0].return_value_type;
int i = 1;
while (i < _functions.Count)
{
if (_functions[i].return_value_type == tn)
{
++i;
}
else
{
break;
}
}
if (i == _functions.Count)
{
return_value_type = tn;
}
else
{
_ret_type_generated = true;
return_value_type = new indefinite_type_node();
}
}
}
public SymbolInfo(type_node value)
{
//reference = new SymbolInfo(value);
_sym_info = value;
_access_level = access_level.al_public;
_symbol_kind = symbol_kind.sk_none;
}
/// <summary>
/// Проверяет, подходит ли фаункция для вызова с указанными параметрами
/// </summary>
/// <param name="candidate"></param>
/// <param name="givenParameterTypes">Типы параметров, указанные пользователем</param>
/// <returns></returns>
private bool IsSuitableFunction(
function_node candidate,
type_node[] givenParameterTypes,
expression_node patternInstance,
location deconstructionLocation,
out type_node[] parameterTypes)
{
parameterTypes = new type_node[givenParameterTypes.Length];
var selfParameter = candidate.is_extension_method ? candidate.parameters.First(IsSelfParameter) : null;
Debug.Assert(!candidate.is_extension_method || selfParameter != null, "Couldn't find self parameter in extension method");
var candidateParameterTypes =
candidate.is_extension_method ?
candidate.parameters.Where(x => !IsSelfParameter(x)).ToArray() :
candidate.parameters.ToArray();
if (candidateParameterTypes.Length != givenParameterTypes.Length)
{
return(false);
}
// Разрешаем только deconstruct текущего класса, родительские в расчет не берем
if (candidate is common_method_node commonMethod && !AreTheSameType(patternInstance.type, commonMethod.cont_type))
{
return(false);
}
var genericDeduceNeeded = candidate.is_extension_method && candidate.is_generic_function;
type_node[] deducedGenerics = new type_node[candidate.generic_parameters_count];
if (genericDeduceNeeded)
{
// Выводим дженерики по self
var nils = new List <int>();
var deduceSucceded = generic_convertions.DeduceInstanceTypes(selfParameter.type, patternInstance.type, deducedGenerics, nils);
if (!deduceSucceded || deducedGenerics.Contains(null))
{
return(false);
}
}
for (int i = 0; i < givenParameterTypes.Length; i++)
{
var givenParameter = givenParameterTypes[i];
var candidateParameter = candidateParameterTypes[i].type;
if (genericDeduceNeeded && (candidateParameter.is_generic_parameter || candidateParameter.is_generic_type_instance))
{
candidateParameter = InstantiateParameter(candidateParameter, deducedGenerics);
}
if (givenParameter != null && !AreTheSameType(candidateParameter, givenParameter))
{
return(false);
}
parameterTypes[i] = candidateParameter;
}
return(true);
}
public static type_definition ConvertSemanticTypeToSyntaxType(type_node semType)
{
// SSM 29/12/18 пробую скомбинировать
//if (semType is compiled_type_node && !(semType as compiled_type_node).is_generic_type_definition && !(semType as compiled_type_node).is_generic_type_instance)
//return new semantic_type_node(semType); // SSM 29/12/18 поменял на современное. Не получилось!
//else
return(OpenMP.ConvertToSyntaxType(semType)); // Это же надо! Пользоваться для этого хреновиной из OpenMP!!!
}
private static List <ident> GetTemplateParametersTypeDependsOn(type_node type)
{
if (type.generic_function_container != null)
{
return(new List <ident>
{
new ident(type.name)
});
}
var typeRef = type as ref_type_node;
if (typeRef != null)
{
return(GetTemplateParametersTypeDependsOn(typeRef.pointed_type));
}
var typeIi = type.get_internal_interface(internal_interface_kind.unsized_array_interface) as array_internal_interface;
if (typeIi != null)
{
return(GetTemplateParametersTypeDependsOn(typeIi.element_type));
}
if (type.type_special_kind == type_special_kind.set_type)
{
return(GetTemplateParametersTypeDependsOn(type.element_type));
}
if (type.IsDelegate)
{
var dii = type.get_internal_interface(internal_interface_kind.delegate_interface) as delegate_internal_interface;
var res = new List <ident>();
if (dii != null)
{
var paramCount = dii.parameters.Count;
for (var i = 0; i < paramCount; i++)
{
res.AddRange(GetTemplateParametersTypeDependsOn(dii.parameters[i].type));
}
}
return(res);
}
if (type.is_generic_type_instance)
{
var pcount = type.instance_params.Count;
var res = new List <ident>();
for (var i = 0; i < pcount; i++)
{
res.AddRange(GetTemplateParametersTypeDependsOn(type.instance_params[i]));
}
return(res);
}
return(new List <ident>());
}
/// <summary>
/// Проверяет, подходит ли фаункция для вызова с указанными параметрами
/// </summary>
/// <param name="candidate"></param>
/// <param name="givenParameterTypes">Типы параметров, указанные пользователем</param>
/// <returns></returns>
private bool IsSuitableFunction(
function_node candidate,
type_node[] givenParameterTypes,
expression_node patternInstance,
location deconstructionLocation,
out type_node[] parameterTypes)
{
parameterTypes = new type_node[givenParameterTypes.Length];
var selfParameter = candidate.is_extension_method ? candidate.parameters.First(IsSelfParameter) : null;
Debug.Assert(!candidate.is_extension_method || selfParameter != null, "Couldn't find self parameter in extension method");
var candidateParameterTypes =
candidate.is_extension_method ?
candidate.parameters.Where(x => !IsSelfParameter(x)).ToArray() :
candidate.parameters.ToArray();
if (candidateParameterTypes.Length != givenParameterTypes.Length)
{
return(false);
}
var genericDeduceNeeded = candidate.is_extension_method && candidate.is_generic_function;
type_node[] deducedGenerics = new type_node[candidate.generic_parameters_count];
if (genericDeduceNeeded)
{
// Выводим дженерики по self
var nils = new List <int>();
var deduceSucceded = generic_convertions.DeduceInstanceTypes(selfParameter.type, patternInstance.type, deducedGenerics, nils);
if (!deduceSucceded || deducedGenerics.Contains(null))
{
// Проверка на то, что в Deconstruct все дженерики выводятся по self делается в другом месте
// TODO Patterns: сделать проверку из коммента выше
// TODO Patterns: запретить дженерик методы в классах. Можно использовать только дженерик-типы самого класса в качестве параметров
//AddError(deconstructionLocation, "COULDNT_DEDUCE_DECONSTRUCT_GENERIC_TYPE");
return(false);
}
}
for (int i = 0; i < givenParameterTypes.Length; i++)
{
var givenParameter = givenParameterTypes[i];
var candidateParameter = candidateParameterTypes[i].type;
if (genericDeduceNeeded && (candidateParameter.is_generic_parameter || candidateParameter.is_generic_type_instance))
{
candidateParameter = InstantiateParameter(candidateParameter, deducedGenerics);
}
if (givenParameter != null && !AreTheSameType(candidateParameter, givenParameter))
{
return(false);
}
parameterTypes[i] = candidateParameter;
}
return(true);
}
public bounded_array_interface(ordinal_type_interface oti, type_node element_type,
common_property_node index_property, type_node index_type, class_field int_array)
{
_oti = oti;
_element_type = element_type;
_index_property = index_property;
_index_type = index_type;
_int_array = int_array;
}
public class_field(string name, type_node type, common_type_node cont_class,
polymorphic_state polymorphic_state, field_access_level field_access_level,
location loc) :
base(name, type)
{
_cont_class = cont_class;
_polymorphic_state = polymorphic_state;
_field_access_level = field_access_level;
_loc = loc;
}
/// <summary>
/// Поиск символа в пространстве имен.
/// </summary>
/// <param name="name">Имя для поиска.</param>
/// <returns>Первый элемент списка найденных имен. null если ни чего не найдено.</returns>
public override SymbolInfoList find(string name)
{
bool is_ns = NetHelper.IsNetNamespace(_name + "." + name);
SymbolInfoList sil = null;
if (is_ns)
{
compiled_namespace_node cnn = compiled_namespace_node.get_compiled_namespace(_name + "." + name, _tcst);
sil = new SymbolInfoList(new SymbolInfo(cnn));
}
else
{
//Kolay changed next string. throwOnError=false ignoreCase=true, .
//Type t = Type.GetType(_name+"."+name,false,true);
if (common_namespace != null)
{
sil = common_namespace.scope.FindOnlyInScope(name);
if (sil != null)
{
return(sil);
}
}
Type t = NetHelper.FindType(_name + "." + name);
if (t != null)
{
sil = new SymbolInfoList(new SymbolInfo(compiled_type_node.get_type_node(t, _tcst)));
}
else
{
t = NetHelper.FindType(_name + "." + _name);
if (t != null && NetHelper.IsEntryType(t))
{
sil = NetHelper.FindName(t, name);
if (sil == null)
{
type_node tn = NetHelper.FindCompiledPascalType(_name + "." + name);
if (tn != null)
{
sil = new SymbolInfoList(new SymbolInfo(tn));
}
else
{
template_class tc = NetHelper.FindCompiledTemplateType(_name + "." + name);
if (tc != null)
{
sil = new SymbolInfoList(new SymbolInfo(tc));
}
}
}
}
}
}
return(sil);
}
public common_parameter(string name, type_node tp, parameter_type pt,
common_function_node cont_function, concrete_parameter_type conc_par_type, expression_node default_value,
location loc) :
base(name, tp)
{
_par_type = pt;
_cont_function = cont_function;
_concrete_parameter_type = conc_par_type;
_default_value = default_value;
_loc = loc;
}
public common_namespace_event(string name, type_node del_type, common_namespace_node cont_namespace, common_namespace_function_node add_function, common_namespace_function_node remove_function, common_namespace_function_node raise_function,
location loc)
{
this._name = name;
this.del_type = del_type;
this._add_function = add_function;
this._remove_function = remove_function;
this._raise_function = raise_function;
this._cont_namespace = cont_namespace;
this._loc = loc;
}
private type_node[] InferAndCheckPatternVariableTypes(List <var_def_statement> variableDefinitions, expression_node patternInstance, desugared_deconstruction deconstruction)
{
var parameterTypes = variableDefinitions.Select(x => x.vars_type == null ? null : convert_strong(x.vars_type)).ToArray();
List <function_node> candidates = new List <function_node>();
List <type_node[]> deducedParametersList = new List <type_node[]>();
var allDeconstructs = patternInstance.type.find_in_type(compiler_string_consts.deconstruct_method_name, context.CurrentScope);
foreach (var canditateSymbol in allDeconstructs)
{
var deducedParameters = new type_node[parameterTypes.Length];
var possibleCandidate = canditateSymbol.sym_info as function_node;
if (!IsSuitableFunction(possibleCandidate, parameterTypes, patternInstance, get_location(deconstruction), out deducedParameters))
{
continue;
}
deducedParametersList.Add(deducedParameters);
candidates.Add(possibleCandidate);
}
if (candidates.Count == 0)
{
AddError(get_location(deconstruction), "NO_SUITABLE_DECONSTRUCT_FOUND");
return(null);
}
else
if (candidates.Count > 1)
{
RemoveDefaultDeconstruct(candidates);
if (candidates.Count > 1 && !CheckIfParameterListElementsAreTheSame(deducedParametersList))
{
AddError(get_location(deconstruction), "DECONSTRUCTOR_METHOD_AMBIGUITY");
return(null);
}
}
// Единственный подхдящий кандидат найден, либо их несколько, с одинаковыми выходными параметрами
var chosenFunction = candidates.First();
if (chosenFunction.is_extension_method)
{
if (chosenFunction.is_generic_function)
{
chosenFunction = generic_convertions.get_function_instance(chosenFunction, deducedParametersList.First().ToList());
}
return(chosenFunction.parameters.Where(x => !IsSelfParameter(x)).Select(x => x.type).ToArray());
}
else
{
return(chosenFunction.parameters.Select(x => x.type).ToArray());//deducedParametersList[0];
}
}
public common_property_node(string name, common_type_node comprehensive_type, type_node property_type,
function_node get_function, function_node set_function, location loc,
SemanticTree.field_access_level field_access_level, SemanticTree.polymorphic_state polymorphic_state)
{
_name = name;
_comprehensive_type = comprehensive_type;
_property_type = property_type;
_get_function = get_function;
_set_function = set_function;
_loc = loc;
_field_access_level = field_access_level;
_polymorphic_state = polymorphic_state;
}
public common_event(string name, type_node del_type, common_type_node cont_type, common_method_node add_method, common_method_node remove_method, common_method_node raise_method,
field_access_level fal, polymorphic_state ps, location loc)
{
this._name = name;
this.del_type = del_type;
this._add_method = add_method;
this._remove_method = remove_method;
this._raise_method = raise_method;
this._field_access_level = fal;
this._polymorphic_state = ps;
this._cont_type = cont_type;
this._loc = loc;
}
private void make_unary_operator(string operator_name, compiled_type_node to,
SemanticTree.basic_function_type bft, type_node ret_value_type)
{
parameterArrayList pars = new parameterArrayList();
basic_function_node bfn = new basic_function_node(bft, pars, ret_value_type);
bfn.is_overload = true;
basic_parameter par = new basic_parameter(compiler_string_consts.unary_param_name, to,
SemanticTree.parameter_type.value, bfn);
pars.Add(par);
to.add_additional_name(operator_name, new SymbolInfo(bfn));
}
private void CheckType(type_node type, expression_node initial_value, location loc)
{
/*if (type.IsPointer && type.element_type.is_value_type && type.element_type is common_type_node)
* {
* AddHint("DO_NOT_USE_POINTERS_TO_RECORDS", loc);
* }*/
if (type.type_special_kind == SemanticTree.type_special_kind.short_string && !(current_type != null && current_type.is_value))
{
AddHint("DO_NOT_USE_SHORT_STRINGS", loc);
}
else if (type.type_special_kind == SemanticTree.type_special_kind.array_kind || type.type_special_kind == SemanticTree.type_special_kind.array_wrapper)
{
CheckType(type.element_type, initial_value, loc);
}
}
private var_definition_node FindForeachVariable(foreach_stmt _foreach_stmt, type_node elem_type, bool sys_coll_ienum)
{
var_definition_node foreachVariable = null;
if (_foreach_stmt.type_name == null) // значит, переменная определена в другом месте
{
location loc1 = get_location(_foreach_stmt.identifier);
definition_node dn = context.check_name_node_type(_foreach_stmt.identifier.name, loc1,
general_node_type.variable_node);
foreachVariable = (var_definition_node)dn;
if (!check_name_in_current_scope(_foreach_stmt.identifier.name))
{
AddError(loc1, "FOREACH_LOOP_CONTROL_MUST_BE_SIMPLE_LOCAL_VARIABLE");
}
}
else
{
foreachVariable = context.add_var_definition(_foreach_stmt.identifier.name,
get_location(_foreach_stmt.identifier));
type_node tn;
if (_foreach_stmt.type_name is no_type_foreach) // значит, это for var x in a
{
tn = elem_type;
}
else // значит, это for var x: T in a
{
tn = convert_strong(_foreach_stmt.type_name);
check_for_type_allowed(tn, get_location(_foreach_stmt.type_name));
check_using_static_class(tn, get_location(_foreach_stmt.type_name));
}
if (tn.is_value_type && !tn.is_standard_type)
{
context.close_var_definition_list(tn, new default_operator_node(tn, foreachVariable.location));
}
else
{
context.close_var_definition_list(tn, null);
}
}
if (/*!(foreachVariable.type is compiled_generic_instance_type_node) &&*/ !sys_coll_ienum) // SSM 16.09.18 - закомментировал это ограничение для фиксации бага #1184
{
convertion_data_and_alghoritms.check_convert_type_with_inheritance(elem_type, foreachVariable.type,
get_location(_foreach_stmt.identifier));
}
return(foreachVariable);
}
private void make_object_operator(common_type_node ctn, SemanticTree.basic_function_type bas_ft,
string name, type_node ret_type, SemanticTree.parameter_type first_parameter_type)
{
parameterArrayList pars = new parameterArrayList();
basic_function_node bfn = new basic_function_node(bas_ft, pars, ret_type);
bfn.is_overload = true;
basic_parameter to = new basic_parameter(compiler_string_consts.left_param_name, ctn,
first_parameter_type, bfn);
basic_parameter from = new basic_parameter(compiler_string_consts.right_param_name, ctn,
SemanticTree.parameter_type.value, bfn);
pars.Add(to);
pars.Add(from);
ctn.Scope.AddSymbol(name, new SymbolInfo(bfn));
}
private static type_intersection_node[] get_type_intersections(type_node left, type_node right)
{
type_intersection_node tin1 = left.get_type_intersection(right);
type_intersection_node tin2 = right.get_type_intersection(left);
if (tin1 == null)
{
if (tin2 == null)
{
return(new type_intersection_node[0]);
}
else
{
type_intersection_node[] tinarr = new type_intersection_node[1];
type_intersection_node new_tin = new type_intersection_node();
new_tin.another_to_this = tin2.another_to_this;
new_tin.this_to_another = tin2.this_to_another;
if (tin2.type_compare == type_compare.greater_type)
{
new_tin.type_compare = type_compare.less_type;
}
else
{
new_tin.type_compare = type_compare.greater_type;
}
tinarr[0] = new_tin;
return(tinarr);
}
}
else
{
if (tin2 == null)
{
type_intersection_node[] tinarr2 = new type_intersection_node[1];
tinarr2[0] = tin1;
return(tinarr2);
}
else
{
type_intersection_node[] tinarr3 = new type_intersection_node[2];
tinarr3[0] = tin1;
tinarr3[1] = tin2;
return(tinarr3);
}
}
}
public static type_compare compare_types(type_node left, type_node right)
{
type_compare ret = get_table_type_compare(left, right);
if (ret != type_compare.non_comparable_type)
{
return(ret);
}
if (is_derived(left, right))
{
return(type_compare.greater_type);
}
if (is_derived(right, left))
{
return(type_compare.less_type);
}
return(type_compare.non_comparable_type);
}
private string get_pointer_name(ref_type_node ctn)
{
type_node tn = ctn.pointed_type;
int i = 1;
while (tn is ref_type_node)
{
i++;
tn = (tn as ref_type_node).pointed_type;
}
string s = get_name(tn);
for (int j = 0; j < i; j++)
{
s += "*";
}
return(s);
}
private string get_dyn_array_name(common_type_node ctn)
{
type_node tn = ctn.element_type;
int i = 1;
while (tn.type_special_kind == SemanticTree.type_special_kind.array_kind)
{
i++;
tn = tn.element_type;
}
string s = get_name(tn);
for (int j = 0; j < i; j++)
{
s += "[]";
}
return(s);
}
private void make_unary_operator(string operator_name,compiled_type_node to,
SemanticTree.basic_function_type bft,type_node ret_value_type)
{
parameterArrayList pars=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
bfn.is_overload=true;
basic_parameter par=new basic_parameter(compiler_string_consts.unary_param_name,to,
SemanticTree.parameter_type.value,bfn);
pars.Add(par);
to.add_additional_name(operator_name,new SymbolInfo(bfn));
}
private basic_function_node make_common_binary_operation(string operator_name,compiled_type_node def_type,compiled_type_node left,
compiled_type_node right,SemanticTree.basic_function_type bft,type_node ret_value_type)
{
parameterArrayList pars=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
bfn.is_overload=true;
basic_parameter par_left=new basic_parameter(compiler_string_consts.left_param_name,left,
SemanticTree.parameter_type.value,bfn);
basic_parameter par_right=new basic_parameter(compiler_string_consts.right_param_name,right,
SemanticTree.parameter_type.value,bfn);
pars.Add(par_left);
pars.Add(par_right);
def_type.add_additional_name(operator_name,new SymbolInfo(bfn));
return bfn;
}
private basic_function_node make_binary_operator(string operator_name,compiled_type_node to,
SemanticTree.basic_function_type bft,type_node ret_value_type)
{
/*parameterArrayList pars=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
basic_parameter par_left=new basic_parameter(compiler_string_consts.left_param_name,to,
SemanticTree.parameter_type.value,bfn);
basic_parameter par_right=new basic_parameter(compiler_string_consts.right_param_name,to,
SemanticTree.parameter_type.value,bfn);
pars.Add(par_left);
pars.Add(par_right);
to.add_additional_name(operator_name,new SymbolInfo(bfn));*/
return make_common_binary_operation(operator_name,to,to,to,bft,ret_value_type);
}
private basic_function_node create_oti_method(SemanticTree.basic_function_type bft,type_node type)
{
parameterArrayList pal=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bft,pal,type);
common_parameter cp=new common_parameter(compiler_string_consts.unary_param_name,type,
SemanticTree.parameter_type.var,null);
pal.Add(cp);
bfn.is_overload=true;
return bfn;
}
private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,
string name,type_node ret_type,SemanticTree.parameter_type first_parameter_type)
{
parameterArrayList pars=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bas_ft,pars,ret_type);
bfn.is_overload=true;
basic_parameter to=new basic_parameter(compiler_string_consts.left_param_name,ctn,
first_parameter_type,bfn);
basic_parameter from=new basic_parameter(compiler_string_consts.right_param_name,ctn,
SemanticTree.parameter_type.value,bfn);
pars.Add(to);
pars.Add(from);
ctn.Scope.AddSymbol(name,new SymbolInfo(bfn));
}
private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,string name,
type_node ret_type)
{
make_object_operator(ctn,bas_ft,name,ret_type,SemanticTree.parameter_type.value);
}
