public static TSpec Expand(ICommandSpec src)
{
if ((src as TSpec)?.Expanded ?? false)
{
return(src as TSpec);
}
var args = src.Arguments;
var expansion = new TSpec
{
CommandName = src.CommandName,
Expanded = true,
};
iter(args, arg =>
{
if (ParameterIndex.ContainsKey(arg.Name))
{
if ((arg.Value as string) != null)
{
var argExpansion = ScriptText.SpecifyEnvironmentParameters((string)arg.Value);
expansion[arg.Name] = new CommandArgument(arg.Name, argExpansion);
}
else
{
expansion[arg.Name] = new CommandArgument(arg.Name, arg.Value);
}
}
});
return(expansion);
}
public override int GetHashCode()
{
int hash = 1;
if (ResourceName.Length != 0)
{
hash ^= ResourceName.GetHashCode();
}
if (adGroupCriterion_ != null)
{
hash ^= AdGroupCriterion.GetHashCode();
}
if (parameterIndex_ != null)
{
hash ^= ParameterIndex.GetHashCode();
}
if (insertionText_ != null)
{
hash ^= InsertionText.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override ICompilationResult GetResult()
{
var results = new Dictionary <ParameterIndex, IExpressionCompilationResult>();
foreach (var argument in myArgumentList.ArgumentsEnumerable)
{
var matchingParameter = argument.MatchingParameter;
var invocationParamNumber = matchingParameter == null ? 0 :
matchingParameter.Element.ContainingParametersOwner.Parameters.IndexOf(matchingParameter.Element);
IExpressionCompilationResult res;
if (MyChildToResult[argument] is IExpressionCompilationResult expressionCompilationResult)
{
res = expressionCompilationResult;
}
else
{
res = new ExpressionCompilationResult();
}
var index = new ParameterIndex(invocationParamNumber);
// for params
if (!results.ContainsKey(index))
{
results.Add(index, res);
}
}
var x = new ArgumentListCompilationResult(results);
return(x);
}
public bool IsMatch(ActionModel actionModel)
{
var parameters = actionModel.ActionMethod.GetParameters();
var offset = ParameterIndex.GetOffset(parameters.Length);
if (offset >= 0 && offset < parameters.Length)
{
var parameter = parameters[ParameterIndex];
if (TypeMatch == ApiConventionTypeMatchBehavior.AssignableFrom && Type != null)
{
if (Type.IsGenericTypeDefinition)
{
var parameterIs = parameter.ParameterType.IsGenericType && parameter.ParameterType.GetGenericTypeDefinition() == Type;
if (!parameterIs)
{
parameterIs = parameter.ParameterType.GetInterfaces().Any(inter => inter.IsGenericType && inter.GetGenericTypeDefinition() == Type);
}
if (!parameterIs)
{
return(false);
}
}
else if (!Type.IsAssignableFrom(parameter.ParameterType))
{
return(false);
}
}
return(NameMatch switch
{
ApiConventionNameMatchBehavior.Exact => Names.Any(name => parameter.Name !.Equals(name, StringComparison.OrdinalIgnoreCase)),
ApiConventionNameMatchBehavior.Prefix => Names.Any(name => parameter.Name !.StartsWith(name, StringComparison.OrdinalIgnoreCase)),
ApiConventionNameMatchBehavior.Suffix => Names.Any(name => parameter.Name !.EndsWith(name, StringComparison.OrdinalIgnoreCase)),
_ => true
});
public StackSymbol(OperationEdge <int> callSite, ResolvedInvocationStatement <Node> invocation)
{
CallSite = callSite;
Owner = null;
if (invocation == null)
{
return;
}
var owner = invocation.TargetEntity;
if (invocation.IsConstructor)
{
var index = new ParameterIndex(-1);
Owner = invocation.ReturnedValues[index] as ResolvedLocalVariable;
}
else if (owner is ResolvedLocalVariable localVariable)
{
Owner = localVariable;
}
else if (owner is SecondaryEntity justSecondary)
{
Owner = Utils.FindClosestLocalOwner(justSecondary);
}
}
private void ProcessReturn(
State state,
GssNode <StackSymbol, EmptyGssData> stack,
InternalReturnStatement returnStatement)
{
if (!(state is ResolvedLocalVariable localState))
{
return;
}
if (!(stack.Symbol.CallSite.Statement is ResolvedInvocationStatement <Node> callingStatement))
{
return;
}
if (state.Equals(stack.Symbol.Owner))
{
Pop(state, stack.Symbol.CallSite.Target);
return;
}
var returnedValues = callingStatement.ReturnedValues;
var currentIndex = new ParameterIndex(localState.LocalId);
var exists = returnedValues.TryGetValue(currentIndex, out var nextState);
if (exists)
{
Pop(nextState, stack.Symbol.CallSite.Target);
}
}
public override int GetHashCode() {
int res = ParameterIndex.GetHashCode() ^ ActionIndex.GetHashCode();
if (Constant != null) {
if (Constant.Value != null) {
res ^= Constant.Value.GetHashCode();
}
}
return res;
}
public bool IsMatch(ActionModel actionModel)
{
var parameters = actionModel.ActionMethod.Parameters;
var offset = ParameterIndex.GetOffset(parameters.Length);
if (offset >= 0 && offset < parameters.Length)
{
var parameter = parameters[ParameterIndex];
if (TypeMatch == ApiConventionTypeMatchBehavior.AssignableFrom && Type != null)
{
if (Type.IsGenericType)
{
/// <summary>
/// Returns a hash code for the <see cref="LSLParameterSignature" /> object.
/// The hash code is generated from the parameter Type, Name, ParameterIndex and Variadic status.
/// </summary>
/// <returns>The generated hash code.</returns>
public override int GetHashCode()
{
unchecked
{
var hash = 17;
hash = hash * 31 + Type.GetHashCode();
hash = hash * 31 + Name.GetHashCode();
hash = hash * 31 + ParameterIndex.GetHashCode();
hash = hash * 31 + Variadic.GetHashCode();
return(hash);
}
}
public override string ToString() {
if (IsAction) {
return "Action" + ActionIndex.ToString();
} else if (IsParameter) {
return "Parameter" + ParameterIndex.ToString();
} else {
object value = Constant.Value;
if (value == null) {
return "(null)";
}
return value.ToString();
}
}
public virtual ActionResult Index(ParameterIndex config)
{
if (ModelState.IsValid)
{
var c = db.Parameters.First();
c.MailMessageOrdered = config.MailMessageOrdered;
c.MailMessagePaid = config.MailMessagePaid;
c.MailMessageShipped = config.MailMessageShipped;
db.SaveChanges();
return(RedirectToAction("index"));
}
// Neu anzeigen mit Fehlern.
return(View(config));
}
public Option <CommandArgument> this[string argname]
{
get
{
var value = ParameterIndex.ContainsKey(argname)
? ParameterIndex[argname].Accessor.GetValue(this)
: null;
return(value != null
? new CommandArgument(argname, value)
: none <CommandArgument>());
}
set
{
ParameterIndex.TryFind(argname).OnSome(parameter
=> parameter.Accessor.SetValue(this, value.MapValueOrDefault(x => x.Value, null)));
}
}
private static void CombineWhereClauseForFilter(string whereClauseTemplate, ParameterIndex parameterIndex, List <string> whereClauses, List <object> parameters, PropertyInfo property, IFilter filter)
{
if (whereClauseTemplate != "{0}")
{
whereClauseTemplate = string.Format(whereClauseTemplate, ".{0}");
}
FilterShortcutAttribute shortcutAttribute = property.GetCustomAttribute <FilterShortcutAttribute>();
if (shortcutAttribute == null || string.IsNullOrEmpty(shortcutAttribute.Path))
{
whereClauseTemplate = string.Format(whereClauseTemplate, property.Name + "{0}");
}
else
{
whereClauseTemplate = string.Format(whereClauseTemplate, ComposeWhereClauseTemplateForShortcutAttributePath(shortcutAttribute));
}
CombineWhereClauses(filter, whereClauseTemplate, parameterIndex, whereClauses, parameters);
}
public void SetParameter(ParameterIndex index, string value)
{
savedGame[(int)index] = value;
}
public string GetParameter(ParameterIndex index)
{
return savedGame[(int)index];
}
protected override void AppendChildren(List <SimpleTreeNode> childList)
{
childList.Add(ContainingMember.ToSimpleTree());
childList.Add(new SimpleLeafNode(ParameterIndex.ToString()));
childList.Add(new SimpleLeafNode(RQNameStrings.PartialImplementation));
}
private static void CombineWhereClauseForValue(string whereClauseTemplate, ParameterIndex parameterIndex, List <string> whereClauses, List <object> parameters, PropertyInfo property, object value)
{
FilterShortcutAttribute shortcutAttribute = property.GetCustomAttribute <FilterShortcutAttribute>();
if (shortcutAttribute != null && !string.IsNullOrEmpty(shortcutAttribute.Path))
{
whereClauseTemplate = string.Format(whereClauseTemplate, ComposeWhereClauseTemplateForShortcutAttributePath(shortcutAttribute));
}
string whereClause;
if (property.Name == "Equals")
{
if (value is DateTime)
{
whereClause = string.Format(whereClauseTemplate, $".Date = @{parameterIndex.Value++}");
}
else
{
whereClause = string.Format(whereClauseTemplate, $" = @{parameterIndex.Value++}");
}
}
else if (property.Name == "From")
{
whereClause = string.Format(whereClauseTemplate, $" >= @{parameterIndex.Value++}");
}
else if (property.Name == "To")
{
whereClause = string.Format(whereClauseTemplate, $" <= @{parameterIndex.Value++}");
}
else if (property.Name == "Contains")
{
whereClause = string.Format(whereClauseTemplate, $".Contains(@{parameterIndex.Value++})");
}
else
{
if (whereClauseTemplate != "{0}")
{
whereClauseTemplate = string.Format(whereClauseTemplate, ".{0}");
}
whereClause = string.Format(whereClauseTemplate, $"{property.Name} = @{parameterIndex.Value++}");
}
whereClauses.Add(whereClause);
if (value is DateTime && property.Name == "Equals")
{
parameters.Add(((DateTime)value).Date);
}
else
{
parameters.Add(value);
}
}
private static void CombineWhereClauses <TEntityFilter>(TEntityFilter filter, string whereClauseTemplate, ParameterIndex parameterIndex, List <string> whereClauses, List <object> parameters) where TEntityFilter : class, IFilter
{
foreach (PropertyInfo property in filter.GetType().GetProperties())
{
if (IsValue(property))
{
object value = property.GetValue(filter);
if (value != null)
{
CombineWhereClauseForValue(whereClauseTemplate, parameterIndex, whereClauses, parameters, property, value);
}
}
else if (IsFilter(property))
{
IFilter subFilter = property.GetValue(filter) as IFilter;
if (subFilter != null && property.GetCustomAttribute <IgnoreFilterAttribute>() == null)
{
CombineWhereClauseForFilter(whereClauseTemplate, parameterIndex, whereClauses, parameters, property, subFilter);
}
}
}
}
public override void Step(SecondaryEntity state, MyGssNode stack, Node position, MyTransition currentTransition)
{
if (stack.Symbol.Trampoline)
{
return;
}
var statement = currentTransition.Statement;
switch (statement.Type)
{
case StatementType.Internal:
var internalStatement = (InternalStatement)statement;
ParameterIndex recipientId;
bool exists;
switch (internalStatement.InternalType)
{
case InternalStatementType.ResolvedInvocation:
var invocation = (ResolvedInvocationStatement <Node>)internalStatement;
exists = invocation.PassedParameters.TryGetValue(state, out recipientId);
var scanning = state is UnknownEntity;
Skip(state);
if (exists || scanning)
{
if (invocation.TargetEntity is SecondaryEntity variable)
{
var instances = CollectInstances(
variable,
invocation.TargetMethodId);
foreach (var instance in instances.ToList())
{
//Logging.Log("dynamic invocation");
if (exists)
{
instance.Variables.TryGetValue(recipientId.Value, out var recipient);
if (recipient != null)
{
Push(recipient, new MyStackData(currentTransition, state, true),
instance.EntryPoint);
//Logging.Log("recipient is not null");
}
else
{
//Logging.Log($"recipient is null: {myProcessingProgram.GetMethodByStartPoint(instance.EntryPoint)}, {recipientId.Value}");
}
}
if (scanning)
{
Push(state, new MyStackData(currentTransition, state, true), instance.EntryPoint);
instance.MarkAsInvoked();
}
}
var head = ExtractHead();
variable.Subscriptions.OnNewPrimaryAdded +=
newType =>
{
myForcedExecutor(head, currentTransition,
InvocationsReExecutor, newType);
};
}
if (invocation.TargetEntity is ResolvedClassId classId)
{
var clazz = myProcessingProgram.FindClassById(classId);
var method = clazz.FindMethodInFullHierarchy(invocation.TargetMethodId);
if (method != null)
{
if (exists)
{
method.Variables.TryGetValue(recipientId.Value, out var recipient);
if (recipient != null)
{
Push(recipient, new MyStackData(currentTransition, state, true),
method.Start);
//Logging.Log("recipient is not null");
}
else
{
//Logging.Log($"recipient is null: {myProcessingProgram.GetMethodByStartPoint(method.EntryPoint)}, {recipientId.Value}");
}
}
if (scanning)
{
Push(state, new MyStackData(currentTransition, state, true), method.EntryPoint);
method.MarkAsInvoked();
}
}
}
}
break;
case InternalStatementType.Return:
var stackTop = stack.Symbol;
if (stackTop.CallingEdge.Statement is NopStatement)
{
break;
}
var callingStatement = (ResolvedInvocationStatement <Node>)stackTop.CallingEdge.Statement;
if (state is ResolvedLocalVariable localVariable)
{
var id = new ParameterIndex(localVariable.LocalId);
exists = callingStatement.ReturnedValues.TryGetValue(id, out var recipient);
if (exists)
{
Pop(new FakeTrampolineEntity(recipient));
}
}
break;
case InternalStatementType.ResolvedAssignment:
var assignment = (ResolvedAssignmentStatement)currentTransition.Statement;
Skip(state);
//Trace.Assert(assignment.Target != null);
if (assignment.Target == null)
{
break;
}
if (state is UnknownEntity)
{
if (assignment.Source is PrimaryEntity primary)
{
assignment.Target.AddPrimary(primary);
Accept(assignment.Target);
}
else
{
((SecondaryEntity)assignment.Source).PropagateForward(assignment.Target);
if (assignment.Target is ResolvedLocalVariable)
{
Accept(assignment.Target);
}
}
}
/*
* if ((assignment.Source is ResolvedObjectField ||
* assignment.Source is ResolvedClassField ||
* assignment.Source is ResolvedObjectMethodReference<Node>) &&
* state is UnknownEntity)
* {
* var asSecondary = (SecondaryEntity) assignment.Source;
* asSecondary.PropagateForward(assignment.Target);
* Accept(assignment.Target);
* }
*/
if (ReferenceEquals(assignment.Source, state))
{
Accept(assignment.Target);
}
break;
}
break;
default:
Skip(state);
break;
}
}
