public statement MyStmt(expression ex, statement st)
{
// Проверить, что в ex - целый тип
// Сделать специальный узел для проверки new semantic_check("Тип проверки",params syntax_node[] ob)
// Включать этот узел первым для "сахарных" узлов синтаксического дерева
var sc = new semantic_check("ExprIsInteger", ex);
var id = new ident("#my");
var idlist = new ident_list(id);
var typ = new named_type_reference("integer");
var one = new int32_const(1);
var vdef = new var_def_statement(idlist, typ, one, definition_attribute.None, false, null);
var vstat = new var_statement(vdef, null);
var ass = new assign(new ident("#my"), one, Operators.AssignmentAddition);
var stlistwhile = new statement_list(st);
stlistwhile.Add(ass);
var bin = new bin_expr(id, ex, Operators.LessEqual);
var wh = new while_node(bin, stlistwhile, WhileCycleType.While);
var stlist = new statement_list(sc);
stlist.Add(vstat);
stlist.Add(wh);
return(stlist);
}
public override void visit(named_type_reference _named_type_reference)
{
foreach (ident id in _named_type_reference.names)
{
id.visit(this);
}
}
public static var_statement CreateVarStatementNode(string idName, string varTypeName, expression initValue)
{
var id = new ident(idName);
var idlist = new ident_list(id);
var varType = new named_type_reference(varTypeName, null);
var vdef = new var_def_statement(idlist, varType, initValue, definition_attribute.None, false, null);
return(new var_statement(vdef, null));
}
public override void visit(named_type_reference ntr)
{
var name = ntr.names[0].name.ToLower();
if (name == "biginteger")
{
BigIntegerTypeCount++;
}
base.visit(ntr);
}
public var_def_statement NewVarOrIdentifier(ident identifier, named_type_reference fptype, LexLocation loc)
{
var n_t_r = fptype;
var vds = new var_def_statement();
vds.vars = new ident_list();
vds.vars.idents.Add(identifier);
vds.vars_type = n_t_r;
vds.source_context = loc;
return(vds);
}
public override void visit(named_type_reference ntr)
{
visit(ntr.names[0]);
if (ntr is template_type_reference ttr)
{
foreach (var tt in ttr.params_list.params_list)
{
ProcessNode(tt);
}
}
}
/// <summary>
/// Создать var-выражение с несколькими переменными
/// </summary>
/// <param name="type">Тип переменных</param>
/// <param name="idents">Имена переменных</param>
/// <returns></returns>
public static var_def_statement CreateVarDef(named_type_reference type, params string[] names)
{
var_def_statement res = new var_def_statement();
foreach (string x in names)
{
res.vars.Add(new ident(x));
}
res.vars_type = type;
return(res);
}
private type_definition get_type_reference(ICSharpCode.NRefactory.Ast.TypeReference tr)
{
string[] names = tr.Type.Split('.');
named_type_reference ntr = new named_type_reference();
ntr.source_context = get_source_context(tr);
for (int i = 0; i < names.Length; i++)
{
ntr.names.Add(new ident(names[i]));
}
return(ntr);
}
private List <type_definition> GetTranslatedTypeclassParameters(List <type_definition> paramList, IEnumerable <string> typeclasses)
{
var possibleOverloadingsForEachTypeclass = typeclasses.Select(x =>
new KeyValuePair <string, List <typeclass_param_list> >(x, instancesAndRestrictedFunctions.instances[x]));
// Find current overloading in possible
var newParams = new List <type_definition>();
foreach (var typeclassOverloadings in possibleOverloadingsForEachTypeclass)
{
foreach (var possibleParamList in typeclassOverloadings.Value)
{
bool isEqual = true;
for (int i = 0; i < possibleParamList.params_list.Count; i++)
{
if ((possibleParamList.params_list[i] as named_type_reference).names[0].name !=
(paramList[i] as named_type_reference).names[0].name)
{
isEqual = false;
break;
}
}
// TODO: need many checks
// Typeclass params and function restriction params are mixed up
// Fix it as soon as it possible
// Btw for 1 argument it's ok.
if (isEqual)
{
var derived_typeclass =
(instancesAndRestrictedFunctions.typeclasses[typeclassOverloadings.Key].type_def as typeclass_definition);
var base_typeclasses = derived_typeclass.additional_restrictions?.types.OfType <typeclass_reference>().Select(x => x.names[0].name);
var typeName = new named_type_reference(CreateInstanceName(possibleParamList, typeclassOverloadings.Key));
if (base_typeclasses == null || base_typeclasses.Count() == 0)
{
newParams.Add(typeName);
}
else
{
var translatedParams = GetTranslatedTypeclassParameters(paramList, base_typeclasses);
newParams.Add(new template_type_reference(
typeName,
new template_param_list(translatedParams)));
}
}
}
}
return(newParams);
}
public expression ConvertNamedTypeReferenceToDotNodeOrIdent(named_type_reference ntr) // либо ident либо dot_node
{
if (ntr.names.Count == 1)
{
return(ntr.names[0]);
}
else
{
var dn = new dot_node(ntr.names[0], ntr.names[1], ntr.names[0].source_context.Merge(ntr.names[1].source_context));
for (var i = 2; i < ntr.names.Count; i++)
{
dn = new dot_node(dn, ntr.names[i], dn.source_context.Merge(ntr.names[i].source_context));
}
dn.source_context = ntr.source_context;
return(dn);
}
}
public ident func_decl_lambda(object lr0, object lr2)
{
statement_list _statement_list = (statement_list)lr2;
expression_list _expression_list = new expression_list();
ident_list _i_l = new ident_list();
formal_parameters _formal_parameters = new formal_parameters();
if (lr0 != null)
{
List <object> ar = (List <object>)lr0;
for (int i = 0; i < ar.Count; i++)
{
if (ar[i] is ident)
{
_i_l.idents.Add((ident)ar[i]);
}
else
{
_i_l.idents.Add(((var_def_statement)ar[i]).vars.idents[0]);
}
}
for (int i = 0; i < _i_l.idents.Count; i++)
{
_expression_list.expressions.Add(_i_l.idents[i]);
}
for (int i = 0; i < ar.Count; i++)
{
ident_list _ident_list = new ident_list();
ident id = _i_l.idents[i];
_ident_list.idents.Add(id);
string name_param = id.name;
typed_parameters _typed_parameters = null;
int k = 0;
{
named_type_reference _named_type_reference = new named_type_reference();
type_definition t_d = new type_definition();
if (ar[i] is ident)
{
ident idtype = new ident("object");
_named_type_reference.names.Add(idtype);
t_d = (type_definition)_named_type_reference;
}
else
{
t_d = ((var_def_statement)ar[i]).vars_type;
}
_typed_parameters = new typed_parameters(_ident_list, t_d, parametr_kind.none, null);
//parsertools.create_source_context(_typed_parameters, _ident_list, t_d);
}
_formal_parameters.params_list.Add(_typed_parameters);
}
}
//////////////////////////
named_type_reference _named_type_reference1 = new named_type_reference();
ident idtype1 = new ident("object");
_named_type_reference1.source_context = idtype1.source_context;
_named_type_reference1.names.Add(idtype1);
/////////////////////////////
lambda_num++;
function_lambda_definition _procedure_definition = new function_lambda_definition();
_procedure_definition.formal_parameters = _formal_parameters;
_procedure_definition.return_type = (type_definition)_named_type_reference1;
_procedure_definition.ident_list = _i_l;
_procedure_definition.proc_body = null;
_procedure_definition.parameters = _expression_list;
_procedure_definition.lambda_name = "__lambda__" + lambda_num;
//new function_lambda_definition(_formal_parameters, (type_definition)_named_type_reference1, _i_l, null, _expression_list, "lambda" + lambda_num);
object rt = _i_l;
_procedure_definition.proc_body = _statement_list;
//////////////////////////////vnutrennie lambda
if (_procedure_definition.defs == null)
{
_procedure_definition.defs = new List <declaration>();
}
while (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] != null)
{
_procedure_definition.defs.Add(lambda((function_lambda_definition)pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1]));
pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1);
}
if (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] == null)
{
pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1);
}
pascalABC_lambda_definitions.Add(_procedure_definition);
///////////////////////////////////////////////
//parsertools.create_source_context(_procedure_definition, _expression_list, rt);
ident _name = new ident(_procedure_definition.lambda_name);
if (lr0 != null)
{
_name.source_context = _i_l.idents[0].source_context;
}
return(_name);
}
public override void visit(named_type_reference _named_type_reference)
{
//text="Type name: "+_named_type_reference.type_name;
}
public override void visit(named_type_reference _named_type_reference)
{
prepare_collection(_named_type_reference.names, "names");
}
public virtual void visit(named_type_reference _named_type_reference)
{
DefaultVisit(_named_type_reference);
}
public virtual void visit(named_type_reference _named_type_reference)
{
}
public virtual void visit(named_type_reference _named_type_reference)
{
DefaultVisit(_named_type_reference);
}
public override void visit(named_type_reference _named_type_reference)
{
DefaultVisit(_named_type_reference);
pre_do_visit(_named_type_reference);
for (int i = 0; i < names.Count; i++)
visit(named_type_reference.names[i]);
post_do_visit(_named_type_reference);
}
public virtual void visit(named_type_reference _named_type_reference)
{
}
public virtual void post_do_visit(named_type_reference _named_type_reference)
{
}
public override void visit(named_type_reference _named_type_reference)
{
executer.visit(_named_type_reference);
if (_named_type_reference.names != null)
foreach (dynamic x in _named_type_reference.names)
if(x != null)
this.visit(x);
if (_named_type_reference.attr_list != null)
this.visit((dynamic)_named_type_reference.attr_list);
if (_named_type_reference.attributes != null)
this.visit((dynamic)_named_type_reference.attributes);
}
