/// <summary>
/// Parses an assignment or call command
/// </summary>
private ICommandNode ParseAssignmentOrCallCommand()
{
Debugger.Write("Parsing Assignment Command or Call Command");
Position startPosition = CurrentToken.Position;
IdentifierNode identifier = ParseIdentifier();
if (CurrentToken.Type == TokenType.LeftBracket)
{
Debugger.Write("Parsing Call Command");
Accept(TokenType.LeftBracket);
IParameterNode parameter = ParseParameter();
Accept(TokenType.RightBracket);
return(new CallCommandNode(identifier, parameter));
}
else if (CurrentToken.Type == TokenType.Becomes)
{
Debugger.Write("Parsing Assignment Command");
Accept(TokenType.Becomes);
IExpressionNode expression = ParseExpression();
return(new AssignCommandNode(identifier, expression));
}
else
{
return(new ErrorNode(startPosition));
}
}
/// <summary>
/// Checks that the parameter's <see cref="IDomain"/>s are equivalent.
/// </summary>
/// <param name="expected">A <see cref="IParameterNode"/> with expected domain.</param>
/// <param name="parameter">A <see cref="IParameterNode"/> with the actual domain.</param>
private static void CheckDomainEquality(IParameterNode expected, IParameterNode parameter)
{
Assert.Equal(expected.Domain.GetType(), parameter.Domain.GetType());
switch (parameter.Domain)
{
case CategoricalDomain <string> categoricalDomain:
Assert.Equal(
((CategoricalDomain <string>)expected.Domain).PossibleValues.ToArray(),
categoricalDomain.PossibleValues.ToArray());
break;
case NumericalDomain <double> continuousDomain:
Assert.Equal(
((NumericalDomain <double>)expected.Domain).Minimum,
continuousDomain.Minimum);
Assert.Equal(
((NumericalDomain <double>)expected.Domain).Maximum,
continuousDomain.Maximum);
break;
case NumericalDomain <int> discreteDomain:
Assert.Equal(
((NumericalDomain <int>)expected.Domain).Minimum,
discreteDomain.Minimum);
Assert.Equal(
((NumericalDomain <int>)expected.Domain).Maximum,
discreteDomain.Maximum);
break;
default:
throw new NotSupportedException(
$"All domains should either be categorical strings, continuous or discrete, but {parameter.Identifier}'s domain is of type {parameter.Domain.GetType()}.");
}
}
//добавление параметра
public ParamInfo AddParameter(IParameterNode p, ParameterBuilder pb)
{
ParamInfo pi = new ParamInfo(pb);
defs[p] = pi;
return(pi);
}
/// <summary>
/// Changes the given genome by mutating the gene corresponding to the given <see cref="IParameterNode" />.
/// </summary>
/// <param name="genome">The genome to mutate. Will be modified.</param>
/// <param name="parameterNode">Specification of the parameter / gene to mutate.</param>
protected void MutateParameter(Genome genome, IParameterNode parameterNode)
{
var currentValue = genome.GetGeneValue(parameterNode.Identifier);
var mutatedValue = parameterNode.Domain.MutateGeneValue(
currentValue,
this._mutationVariancePercentage);
genome.SetGene(parameterNode.Identifier, mutatedValue);
}
//добавление нелок. параметра
public ParamInfo AddGlobalParameter(IParameterNode p, FieldBuilder fb)
{
ParamInfo pi = new ParamInfo();
pi.kind = ParamKind.pkGlobal;
pi.fb = fb;
defs[p] = pi;
return(pi);
}
public static Func <TParameter1, object> CreateParameterGetter <TParameter1, TResult>(
IParameterNode parameter,
[NotNull] Expression <Func <TParameter1, TResult> > expression)
{
var parameters = expression.Parameters;
var body = ExpressionCreator.CreateParameterBody(parameter);
var lambda = Expression.Lambda <Func <TParameter1, object> >(body, parameters);
return(lambda.Compile());
}
//ParseCallExpression is just an example of the whole expression being parsed
//it is not actually used due to the PaarseIDExpression
private IExpressionNode ParseCallExpression()
{
Debugger.Write("Parsing call expression");
IdentifierNode identifier = ParseIdentifier();
Accept(LeftBracket);
IParameterNode parameter = ParseParameter();
Accept(RightBracket);
return(new CallExpressionNode(identifier, parameter));
}
/// <summary>
/// Parses an ID expression
/// </summary>
/// <returns>An abstract syntax tree representing the expression</returns>
private IExpressionNode ParseIdExpression()
{
Debugger.Write("Parsing Identifier Expression");
IdentifierNode identifier = ParseIdentifier();
if (CurrentToken.Type == LeftBracket)
{
Accept(LeftBracket);
IParameterNode parameter = ParseParameter();
Accept(RightBracket);
return(new IdExpressionNode(identifier, parameter));
}
return(new IdExpressionNode(identifier, null));
}
/// <summary>
/// Parses ID Expression
/// </summary>
private IExpressionNode ParseIdExpression()
{
Debugger.Write("Parsing Call Expression or Identifier Expression");
Position startPosition = CurrentToken.Position;
IdentifierNode identifier = ParseIdentifier();
if (CurrentToken.Type == TokenType.LeftBracket)
{
// Parse call expression
Debugger.Write("Parsing Call Expression");
Accept(TokenType.LeftBracket);
IParameterNode parameter = ParseParameter();
Accept(TokenType.RightBracket);
return(new CallExpressionNode(identifier, parameter));
}
else
{
Debugger.Write("Parsing Identifier Expression");
return(new IdExpressionNode(identifier));
}
}
/// <summary>
/// Parses an assignment or call command
/// <identifier> ( := <expression> | ( <parameter> ) )
/// </summary>
/// <returns>An abstract syntax tree representing the command</returns>
private ICommandNode ParseAssignmentOrCallCommand()
{
Debugger.Write("Parsing Assignment Command or Call Command");
Position startPosition = CurrentToken.Position;
IdentifierNode identifier = ParseIdentifier();
if (CurrentToken.Type == Becomes) //:= <expression>
{
Debugger.Write("Parsing Assignment Command");
Accept(Becomes);
IExpressionNode expression = ParseExpression();
return(new AssignCommandNode(identifier, expression));
}
else if (CurrentToken.Type == LeftBracket) //( <parameter> )
{
Debugger.Write("Parsing Call Command");
Accept(LeftBracket);
IParameterNode parameter = ParseParameter();
Accept(RightBracket);
return(new CallCommandNode(identifier, parameter));
}
AddToErrorPositions(startPosition, "neither assigment or call command was found");
return(new ErrorNode(startPosition));
}
public virtual void visit(IParameterNode value)
{
}
public void visit(IParameterNode value)
{
throw new System.NotSupportedException(value.GetType().ToString());
}
public IdExpressionNode(IdentifierNode identifier, IParameterNode parameterNode)
{
Identifier = identifier;
ParameterNode = parameterNode;
}
//получение параметра
public ParamInfo GetParameter(IParameterNode p)
{
return (ParamInfo)defs[p];
}
//добавление нелок. параметра
public ParamInfo AddGlobalParameter(IParameterNode p, FieldBuilder fb)
{
ParamInfo pi = new ParamInfo();
pi.kind = ParamKind.pkGlobal;
pi.fb = fb;
defs[p] = pi;
return pi;
}
//добавление параметра
public ParamInfo AddParameter(IParameterNode p, ParameterBuilder pb)
{
ParamInfo pi = new ParamInfo(pb);
defs[p] = pi;
return pi;
}
private static string get_parameters(IParameterNode[] prms)
{
StringBuilder sb = new StringBuilder();
if (prms.Length > 0)
{
sb.Append('(');
for (int i=0; i<prms.Length; i++)
{
IParameterNode prm = prms[i];
if (prm.parameter_type == parameter_type.var)
sb.Append(get_span_for_keyword("var")+" ");
else if (prm.is_params)
sb.Append(get_span_for_keyword("params")+" ");
sb.Append(get_span_for_param(prm.name));
sb.Append(" : ");
sb.Append(get_type_html_text(prm.type));
if (i<prms.Length-1)
sb.Append("; ");
}
sb.Append(')');
}
return sb.ToString();
}
/// <summary>
/// Checks whether the provided <paramref name="parameter"/> can be considered as continuous.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <param name="minimumDomainSize">Minimum size of an integer domain to be considered continuous.</param>
/// <returns>Whether the provided <paramref name="parameter"/> can be considered as continuous.</returns>
private static bool ParameterIsConsideredContinuous(IParameterNode parameter, int minimumDomainSize)
{
return(parameter.Domain is NumericalDomain <double> ||
(parameter.Domain is NumericalDomain <int> && parameter.Domain.DomainSize >= minimumDomainSize));
}
public void visit(IParameterNode value)
{
string s = value.GetType().Name + ".";
prepare_string_node(value.name, s + "name");
//value.function
prepare_node(value.inital_value, s + "initial_value");
prepare_string_node(value.is_params.ToString(), s + "is_params");
prepare_string_node(value.node_location_kind.ToString(), s + "node_location_kind");
prepare_string_node(value.parameter_type.ToString(), s + "parameter_type");
//value.type
}
public CallExpressionNode(IdentifierNode identifier, IParameterNode parameter)
{
Identifier = identifier;
Parameter = parameter;
}
/// <summary>
/// Creates a new call command node
/// </summary>
/// <param name="identifier">The function name</param>
/// <param name="parameter">The function call parameter</param>
public CallCommandNode(IdentifierNode identifier, IParameterNode parameter)
{
Identifier = identifier;
Parameter = parameter;
}
public virtual void visit(IParameterNode value)
{
}
//получение параметра
public ParamInfo GetParameter(IParameterNode p)
{
return((ParamInfo)defs[p]);
}
bool CallCloneIfNeed(ILGenerator il, IParameterNode parameter, IExpressionNode expr)
{
TypeInfo ti = helper.GetTypeReference(parameter.type);
if (ti != null && ti.clone_meth != null && parameter.parameter_type == parameter_type.value && !parameter.is_const &&
parameter.type.type_special_kind != type_special_kind.base_set_type /*&&
!(expr is ICompiledConstructorCall) &&
!(expr is ICommonConstructorCall)*/)
{
il.Emit(OpCodes.Call, ti.clone_meth);
return true;
}
return false;
}
