本文整理汇总了C#中expressions_list.ToArray方法的典型用法代码示例。如果您正苦于以下问题：C# expressions_list.ToArray方法的具体用法？C# expressions_list.ToArray怎么用？C# expressions_list.ToArray使用的例子？那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类expressions_list的用法示例。
在下文中一共展示了expressions_list.ToArray方法的7个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: make_read_call
//.........这里部分代码省略.........
if (en is compiled_function_call)
{
compiled_function_call cfc = en as compiled_function_call;
if ((cfc.function_node.return_value_type == SystemLibrary.SystemLibrary.char_type && cfc.function_node.cont_type == SystemLibrary.SystemLibrary.string_type
&& cfc.function_node == cfc.function_node.cont_type.default_property_node.get_function))
{
en = new simple_array_indexing((en as compiled_function_call).obj, (en as compiled_function_call).parameters[0], SystemLibrary.SystemLibrary.char_type, en.location);
is_char_getter = true;
}
}
}
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.TypedFileReadProcedure.SymbolInfo, loc);
expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, get_location(ex), file);
//expression_node expr = convertion_data_and_alghoritms.create_full_function_call(exl, SystemLibrary.SystemLibInitializer.TypedFileReadProcedure.SymbolInfo, loc, context.converted_type, context.top_function, true);
expr = convertion_data_and_alghoritms.explicit_convert_type(expr, file.type.element_type);
if (is_char_getter)
expr = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.StringDefaultPropertySetProcedure.sym_info as function_node, loc, (en as simple_array_indexing).simple_arr_expr, (en as simple_array_indexing).ind_expr, expr);
else
expr = find_operator(compiler_string_consts.assign_name, en, expr, loc);
last_call = expr;
}
else if (read_from_binary_file)
{
if (SystemLibrary.SystemLibInitializer.BinaryFileReadProcedure == null)
AddError(new NotSupportedError(loc));
if (!CanUseThisTypeForBinaryFiles(en.type))
{
AddError(en.location, "CAN_NOT_READ_REFERENCE_DATA_FROM_BINARY_FILE");
}
exl.AddElement(new typeof_operator(en.type, loc));
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.BinaryFileReadProcedure.SymbolInfo, loc);
expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, get_location(ex), exl.ToArray());
expr = convertion_data_and_alghoritms.explicit_convert_type(expr, en.type);
expr = find_operator(compiler_string_consts.assign_name, en, expr, loc);
last_call = expr;
}
else
{
exl.AddElement(en);
try
{
function_node fn = null;
if (en.type.type_special_kind == SemanticTree.type_special_kind.short_string)
{
exl.AddElement(new int_const_node((en.type as short_string_type_node).Length,null));
if (!read_from_file)
last_call = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.read_short_string_procedure.sym_info as function_node,get_location(ex),exl.ToArray());
else
last_call = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.read_short_string_from_file_procedure.sym_info as function_node,get_location(ex),exl.ToArray());
}
else if (en.type.type_special_kind == SemanticTree.type_special_kind.diap_type)
{
exl.remove(en);
en.type = en.type.base_type;
exl.AddElement(en);
fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.read_procedure.SymbolInfo, loc);
last_call = convertion_data_and_alghoritms.create_simple_function_call(fn, get_location(ex), exl.ToArray());
}
else
{
if (SystemLibrary.SystemLibInitializer.readln_procedure.Equal(si) && parameters.expressions.Count == 2 && en.type == SystemLibrary.SystemLibrary.string_type)
{
fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.readln_procedure.SymbolInfo, loc);
readln_string_file = true;示例2: visit
public override void visit(SyntaxTree.format_expr _format_expr)
{
if (_format_expr.expr == null || _format_expr.format1 == null)
AddError(get_location(_format_expr), "BAD_CONSTRUCTED_FORMAT_EXPRESSION");
//TODO: Добавить проверки.
if (!SemanticRules.AllowUseFormatExprAnywhere && !is_format_allowed)
AddError(get_location(_format_expr.expr), "FORMAT_EXPRESSION_CAN_USE_ONLY_IN_THESE_PROCEDURES");
expression_node expr = convert_strong(_format_expr.expr);
if (expr is typed_expression)
expr = convert_typed_expression_to_function_call(expr as typed_expression);
expression_node par1 = convert_strong(_format_expr.format1);
par1 = convertion_data_and_alghoritms.convert_type(par1, SystemLibrary.SystemLibrary.integer_type);
expression_node par2 = convert_weak(_format_expr.format2);
if (par2 != null)
{
if (expr.type != SystemLibrary.SystemLibrary.double_type && expr.type != SystemLibrary.SystemLibrary.float_type)
{
AddError(expr.location, "REAL_TYPE_IN_DOUBLE_COLON_EXPRESSION_EXPECTED");
}
par2 = convertion_data_and_alghoritms.convert_type(par2, SystemLibrary.SystemLibrary.integer_type);
}
expressions_list exl = new expressions_list();
exl.AddElement(expr);
exl.AddElement(par1);
if (par2 != null)
{
exl.AddElement(par2);
}
location loc = get_location(_format_expr);
if (!SystemUnitAssigned)
AddError( new NotSupportedError(loc));
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.format_function.SymbolInfo,
loc);
expression_node ret = convertion_data_and_alghoritms.create_simple_function_call(fn, loc, exl.ToArray());
return_value(ret);
}示例3: make_dec_call
private expression_node make_dec_call(SymbolInfo si, SyntaxTree.expression_list parameters, location loc)
{
if (parameters == null) throw new NoFunctionWithSameParametresNum(loc,false,si.sym_info as function_node);
if (parameters.expressions.Count == 1 || parameters.expressions.Count == 2)
{
expression_node param0 = convert_strong(parameters.expressions[0]);
if (!param0.is_addressed)
{
bool is_pascal_array_ref = false;
if (param0.semantic_node_type == semantic_node_type.common_method_call)
{
common_method_call cmc = (common_method_call)param0;
internal_interface ii = cmc.obj.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii != null)
{
if (cmc.function_node.name == compiler_string_consts.get_val_pascal_array_name)
{
bounded_array_interface bai = (bounded_array_interface)ii;
class_field cf = bai.int_array;
expression_node left = new class_field_reference(cf, cmc.obj, cmc.location);
expression_node right = cmc.parameters[0];
//right = convert_type(right, SystemLibrary.SystemLibrary.integer_type);
right = convertion_data_and_alghoritms.convert_type(right, (ii as bounded_array_interface).ordinal_type_interface.elems_type);
right = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibrary.int_sub, cmc.location, right,
new int_const_node(bai.ordinal_type_interface.ordinal_type_to_int(bai.ordinal_type_interface.lower_value), cmc.location));
param0 = new simple_array_indexing(left, right, cmc.type, cmc.location);
is_pascal_array_ref = true;
}
}
if (!is_pascal_array_ref)
{
throw new ThisExpressionCanNotBePassedAsVarParameter(param0);
}
}
else if (param0 is compiled_function_call)
{
compiled_function_call cfc = param0 as compiled_function_call;
if ((cfc.function_node.return_value_type == SystemLibrary.SystemLibrary.char_type && cfc.function_node.cont_type == SystemLibrary.SystemLibrary.string_type
&& cfc.function_node == cfc.function_node.cont_type.default_property_node.get_function))
{
expressions_list exl = new expressions_list();
exl.AddElement(cfc.obj);
exl.AddElement(cfc.parameters[0]);
basic_function_call bfc2 = new basic_function_call(SystemLibrary.SystemLibrary.int_sub as basic_function_node,loc);
bfc2.parameters.AddElement(param0);
expression_node _param1 = null;
if (parameters.expressions.Count == 2)
{
_param1 = convert_strong(parameters.expressions[1]);
}
if (_param1 != null)
bfc2.parameters.AddElement(convertion_data_and_alghoritms.convert_type(_param1,SystemLibrary.SystemLibrary.integer_type));
else
bfc2.parameters.AddElement(new int_const_node(1,null));
expressions_list el = new expressions_list();
el.AddElement(convertion_data_and_alghoritms.convert_type(bfc2,SystemLibrary.SystemLibrary.ushort_type));
function_node chr_func = convertion_data_and_alghoritms.select_function(el, SystemLibrary.SystemLibInitializer.ChrUnicodeFunction.SymbolInfo, loc);
exl.AddElement(convertion_data_and_alghoritms.create_simple_function_call(chr_func, loc, el.ToArray()));
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.StringDefaultPropertySetProcedure.SymbolInfo, loc);
expression_node ret = convertion_data_and_alghoritms.create_simple_function_call(fn, loc, exl.ToArray());
return ret;
}
else
{
throw new ThisExpressionCanNotBePassedAsVarParameter(param0);
}
}
else throw new ThisExpressionCanNotBePassedAsVarParameter(param0);
}
else
check_on_loop_variable(param0);
expression_node param1 = null;
int type_flag = 0;
bool is_uint=false;
bool is_enum=false;
if (parameters.expressions.Count == 2)
{
param1 = convert_strong(parameters.expressions[1]);
param1 = convertion_data_and_alghoritms.convert_type(param1,SystemLibrary.SystemLibrary.integer_type);
}
basic_function_call ass = null;
basic_function_call bfc = null;
if (param0.type == SystemLibrary.SystemLibrary.integer_type)
{
ass = new basic_function_call(SystemLibrary.SystemLibrary.int_assign as basic_function_node,loc);
bfc = new basic_function_call(SystemLibrary.SystemLibrary.int_sub as basic_function_node,loc);
}
else if (param0.type == SystemLibrary.SystemLibrary.char_type)
{
ass = new basic_function_call(SystemLibrary.SystemLibrary.char_assign as basic_function_node,loc);
bfc = new basic_function_call(SystemLibrary.SystemLibrary.int_sub as basic_function_node,loc);
}
else if (param0.type == SystemLibrary.SystemLibrary.byte_type)
{
ass = new basic_function_call(SystemLibrary.SystemLibrary.byte_assign as basic_function_node,loc);
bfc = new basic_function_call(SystemLibrary.SystemLibrary.int_sub as basic_function_node,loc);
}
else if (param0.type == SystemLibrary.SystemLibrary.sbyte_type)
//.........这里部分代码省略.........
示例4: get_init_call_for_set
internal expression_node get_init_call_for_set(var_definition_node vdn)
{
location loc = (vdn.type as common_type_node).loc;
if (!SystemUnitAssigned)
AddError(new NotSupportedError(loc));
//Когда заработает наследование конструкторов надо вставить это
/*
expression_node var_ref = create_variable_reference(vdn, loc);
expressions_list exl = new expressions_list();
exl.AddElement(new typeof_operator(element_type, loc));
base_function_call bfc = create_constructor_call(vdn.type, exl, loc);
expression_node expr = find_operator(compiler_string_consts.assign_name, var_ref, bfc, loc);
*/
type_node tn = vdn.type;
vdn.type = SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as type_node;
expression_node var_ref = create_variable_reference(vdn, loc);
expressions_list exl = new expressions_list();
exl.AddElement(var_ref);
bool short_str = false;
//exl.AddElement(new typeof_operator(element_type, loc));
if (tn.element_type == SystemLibrary.SystemLibrary.byte_type)
{
exl.AddElement(new byte_const_node(byte.MinValue,null));
exl.AddElement(new byte_const_node(byte.MaxValue,null));
}
else if (tn.element_type == SystemLibrary.SystemLibrary.sbyte_type)
{
exl.AddElement(new sbyte_const_node(sbyte.MinValue,null));
exl.AddElement(new sbyte_const_node(sbyte.MaxValue,null));
}
else if (tn.element_type == SystemLibrary.SystemLibrary.short_type)
{
exl.AddElement(new short_const_node(short.MinValue,null));
exl.AddElement(new short_const_node(short.MaxValue,null));
}
else if (tn.element_type == SystemLibrary.SystemLibrary.ushort_type)
{
exl.AddElement(new ushort_const_node(ushort.MinValue,null));
exl.AddElement(new ushort_const_node(ushort.MaxValue,null));
}
else if (tn.element_type.type_special_kind == SemanticTree.type_special_kind.diap_type || tn.element_type.type_special_kind == SemanticTree.type_special_kind.enum_kind)
{
ordinal_type_interface ii = tn.element_type.get_internal_interface(internal_interface_kind.ordinal_interface) as ordinal_type_interface;
exl.AddElement(ii.lower_value);
exl.AddElement(ii.upper_value);
}
else if (tn.element_type.type_special_kind == SemanticTree.type_special_kind.short_string)
{
short_str = true;
exl.AddElement(new int_const_node((tn.element_type as short_string_type_node).Length,null));
}
function_node fn = null;
if (short_str)
fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.TypedSetInitWithShortString.SymbolInfo, loc);
else
if (exl.Count > 1)
fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.TypedSetInitProcedureWithBounds.SymbolInfo, loc);
else
fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.TypedSetInitProcedure.SymbolInfo, loc);
expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, null, exl.ToArray());
vdn.type = tn;
return expr;
}示例5: get_init_call_for_binary_file
internal expression_node get_init_call_for_binary_file(var_definition_node vdn)
{
location loc = null;
if (vdn.type is common_type_node)
loc = (vdn.type as common_type_node).loc;
if (!SystemUnitAssigned)
AddError(new NotSupportedError(loc));
type_node tn = vdn.type;
vdn.type = SystemLibrary.SystemLibInitializer.BinaryFileType.sym_info as type_node;
expression_node var_ref = create_variable_reference(vdn, loc);
expressions_list exl = new expressions_list();
exl.AddElement(var_ref);
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.BinaryFileInitProcedure.SymbolInfo, loc);
expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, null, exl.ToArray());
vdn.type = tn;
return expr;
}示例6: get_init_call_for_typed_file
internal expression_node get_init_call_for_typed_file(var_definition_node vdn, type_node element_type)
{
location loc = (vdn.type as common_type_node).loc;
if (!SystemUnitAssigned)
AddError(new NotSupportedError(loc));
//Когда заработает наследование конструкторов надо вставить это
/*
expression_node var_ref = create_variable_reference(vdn, loc);
expressions_list exl = new expressions_list();
exl.AddElement(new typeof_operator(element_type, loc));
base_function_call bfc = create_constructor_call(vdn.type, exl, loc);
expression_node expr = find_operator(compiler_string_consts.assign_name, var_ref, bfc, loc);
*/
type_node tn = vdn.type;
vdn.type = SystemLibrary.SystemLibInitializer.TypedFileType.sym_info as type_node;
expression_node var_ref = create_variable_reference(vdn, loc);
expressions_list exl = new expressions_list();
exl.AddElement(var_ref);
exl.AddElement(new typeof_operator(element_type, loc));
List<int> lens = get_short_string_lens(element_type);
int sz = get_short_string_size(element_type);
if (sz > 0)
{
exl.AddElement(new int_const_node(get_short_string_size(element_type),null));
for (int i=0; i<lens.Count; i++)
exl.AddElement(new int_const_node(lens[i],null));
}
this.context.save_var_definitions();
function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibrary.SystemLibInitializer.TypedFileInitProcedure.SymbolInfo, loc);
this.context.restore_var_definitions();
expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, null, exl.ToArray());
vdn.type = tn;
return expr;
}示例7: create_full_function_call
/// <summary>
/// Этот метод вызывается если мы встречаем простой вызов функии, например f(1).
/// Он определяет является ли эта функция методом класса, вложенной функцией и т.д. и создает соответствующее обращение.
/// Например, для метода класса он добавляет this, а для вложенной функции вычисляет статическую глубину.
/// </summary>
/// <param name="exprs">Список параметров.</param>
/// <param name="si">Список методов.</param>
/// <param name="loc">Расположение вызова.</param>
/// <param name="converted_type">Тип в котором мы находимся. null, если мы вне типа.</param>
/// <param name="top_function">Функция в которой мы находимся.</param>
/// <param name="allow_procedure">Может ли это быть вызов процедуры. false если вызов стоит в выражении или правой части опреатора присваивания.</param>
/// <returns>Возвращает узел вызова метода.</returns>
public expression_node create_full_function_call(expressions_list exprs,SymbolInfo si,location loc,
common_type_node converted_type,common_function_node top_function,bool allow_procedure)
{
function_node fn=select_function(exprs,si,loc);
/*
if (fn.compile_time_executor != null)
{
expression_node ex = fn.compile_time_executor(loc, exprs.ToArray());
if (ex != null)
{
return ex;
}
}
*/
//allow_procedure = true;
if ((!allow_procedure)&&(fn.return_value_type==null))
{
throw new SimpleSemanticError(loc, "FUNCTION_EXPECTED_PROCEDURE_{0}_MEET", fn.name);
}
expression_node expr_node=null;
switch (fn.semantic_node_type)
{
case semantic_node_type.basic_function_node:
case semantic_node_type.common_namespace_function_node:
{
expr_node=create_simple_function_call(fn,loc,exprs.ToArray());
break;
}
case semantic_node_type.common_method_node:
case semantic_node_type.compiled_function_node:
{
SemanticTree.IClassMemberNode icmn=(SemanticTree.IClassMemberNode)fn;
if (icmn.polymorphic_state==SemanticTree.polymorphic_state.ps_static)
{
expr_node=create_simple_function_call(fn,loc,exprs.ToArray());
break;
}
//expression_node tn = new this_node(converted_type,loc);
base_function_call cmc=null;
switch (fn.semantic_node_type)
{
case semantic_node_type.common_method_node:
{
//ssyy добавил
if (((common_method_node)fn).is_constructor)
{
common_constructor_call ccc = new common_constructor_call((common_method_node)fn, loc);
//(ssyy) По-видимому, здесь всегда можно присваивать false, так как при создании нового объекта мы сюда не заходим...
ccc._new_obj_awaited = false;
if (!syntax_tree_visitor.context.allow_inherited_ctor_call)
{
throw new SimpleSemanticError(loc, "INHERITED_CONSTRUCTOR_CALL_MUST_BE_FIRST");
}
cmc = ccc;
}
else
//\ssyy
{
cmc = new common_method_call((common_method_node)fn, syntax_tree_visitor.GetCurrentObjectReference(((common_method_node)fn).cont_type.Scope, fn, loc), loc);
(cmc as common_method_call).virtual_call = !syntax_tree_visitor.inherited_ident_processing;
}
break;
}
case semantic_node_type.compiled_function_node:
{
cmc = new compiled_function_call((compiled_function_node)fn, syntax_tree_visitor.GetCurrentObjectReference(((compiled_function_node)fn).cont_type.Scope, fn, loc), loc);
(cmc as compiled_function_call).virtual_call = !syntax_tree_visitor.inherited_ident_processing;
break;
}
}
cmc.parameters.AddRange(exprs);
expr_node=cmc;
break;
}
case semantic_node_type.common_in_function_function_node:
{
common_in_function_function_node cffn=(common_in_function_function_node)fn;
common_in_function_function_call cffc=new common_in_function_function_call(cffn,
symtab.GetRelativeScopeDepth(cffn.function.scope,top_function.scope),loc);
cffc.parameters.AddRange(exprs);
expr_node=cffc;
break;
}
//ssyy добавил
case semantic_node_type.compiled_constructor_node:
{
//.........这里部分代码省略.........