private void VisitRecordConst(record_constant node)
{
bw.Write(node.field_values.Count);
foreach (constant_node cn in node.field_values)
VisitExpression(cn);
WriteTypeReference(node.type);
}
public override void visit(SyntaxTree.array_const _array_const)
{
if (_array_const.elements != null)
{
List<constant_node> elements = new List<constant_node>();
List<expression_node> exprs = new List<expression_node>();
foreach (SyntaxTree.expression expr in _array_const.elements.expressions)
{
if (is_typed_const_def)
elements.Add(convert_strong_to_constant_node(expr));
else
exprs.Add(convert_strong(expr));
}
if (is_typed_const_def)
{
array_const arrc = new array_const(elements, get_location(_array_const));
arrc.SetType(new ArrayConstType(elements[0].type, elements.Count, arrc.location));
return_value(arrc);
}
else
{
array_initializer arrc = new array_initializer(exprs, get_location(_array_const));
arrc.type = new ArrayConstType(exprs[0].type, exprs.Count, arrc.location);
return_value(arrc);
}
}
else
{
//это пустой инициализатор записи
record_constant rc = new record_constant(new List<PascalABCCompiler.SyntaxTree.record_const_definition>(), get_location(_array_const));
rc.SetType(new RecordConstType(get_location(_array_const)));
return_value(rc);
}
}
private record_constant ConvertRecordConst(common_type_node ctn, record_constant constant)
{
location loc = constant.location;
if (!ctn.is_value_type)
AddError(loc, "RECORD_CONST_NOT_ALLOWED_{0}", ctn.name);
if (ctn.fields.Count != constant.record_const_definition_list.Count)
AddError(loc, "INVALID_RECORD_CONST_FIELD_COUNT");
constant.SetType(ctn);
constant.field_values.Clear();
bool tmp = this.is_typed_const_def;
this.is_typed_const_def = true;
for (int i = 0; i < ctn.fields.Count; i++)
{
class_field cf = ctn.fields[i];
if (cf.name.ToLower() != constant.record_const_definition_list[i].name.name.ToLower())
AddError(get_location(constant.record_const_definition_list[i].name), "FIELD_NAME_SHOULD_BE_EQUAL_RECORD_FIELD_NAME", cf.name);
constant.field_values.Add(convert_strong_to_constant_node(constant.record_const_definition_list[i].val, cf.type));
}
this.is_typed_const_def = tmp;
return constant;
}
public override void visit(SyntaxTree.record_const node)
{
if (is_typed_const_def)
{
record_constant rc = new record_constant(node.rec_consts, get_location(node));
rc.SetType(new RecordConstType(rc.location));
return_value(rc);
}
else
{
record_initializer ri = new record_initializer(node.rec_consts, get_location(node));
ri.type = new RecordConstType(ri.location);
return_value(ri);
}
}
private record_constant CreateRecordConst()
{
List<constant_node> field_values = new List<constant_node>();
int count = br.ReadInt32();
for (int i = 0; i < count; i++)
field_values.Add((constant_node)CreateExpression());
record_constant recc = new record_constant(field_values, null);
recc.SetType(GetTypeReference());
return recc;
}
