private bool IsExposedExpression(Expression expression) { if (expression.NodeType == NodeType.Literal) { Literal literal = (Literal)expression; TypeNode type = literal.Type; if (!IsExposedType(type)) { return(false); } if (type.FullName == "System.Type") { // if the value is itself a type, we need to test whether that type is visible TypeNode value = literal.Value as TypeNode; if ((value != null) && !IsExposedType(value)) { return(false); } } return(true); } else if (expression.NodeType == NodeType.NamedArgument) { NamedArgument assignment = (NamedArgument)expression; return(IsExposedExpression(assignment.Value)); } else { throw new InvalidOperationException("Encountered unrecognized expression"); } }
public static Literal GetNamedAttributeValue(AttributeNode attr, Identifier name) { if (attr == null) { return(null); } ExpressionList exprs = attr.Expressions; if (exprs == null) { return(null); } for (int i = 0, n = exprs.Count; i < n; i++) { NamedArgument na = exprs[i] as NamedArgument; if (na == null) { continue; } if (na.Name.UniqueIdKey == name.UniqueIdKey) { return(na.Value as Literal); } } return(null); }
public bool TryGetArg(int index, out NamedArgument arg) { if (index < 0 || index >= count) { arg = default(NamedArgument); return(false); } if (args != null) { arg = args[index]; } else { switch (index) { case 0: arg = arg1; break; case 1: arg = arg2; break; case 2: arg = arg3; break; default: arg = arg4; break; } } return(true); }
public void Add(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4) { Add(arg1); Add(arg2); Add(arg3); Add(arg4); }
public static bool Formatted(ref TaggedString __result, string str, NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4, NamedArgument arg5, NamedArgument arg6, NamedArgument arg7, NamedArgument arg8) { List <string> argsLabels = getArgsLabels(); List <object> argsObjects = getArgsObjects(); argsLabels.Clear(); argsObjects.Clear(); argsLabels.Add(arg1.label); argsObjects.Add(arg1.arg); argsLabels.Add(arg2.label); argsObjects.Add(arg2.arg); argsLabels.Add(arg3.label); argsObjects.Add(arg3.arg); argsLabels.Add(arg4.label); argsObjects.Add(arg4.arg); argsLabels.Add(arg5.label); argsObjects.Add(arg5.arg); argsLabels.Add(arg6.label); argsObjects.Add(arg6.arg); argsLabels.Add(arg7.label); argsObjects.Add(arg7.arg); argsLabels.Add(arg8.label); argsObjects.Add(arg8.arg); __result = GrammarResolverSimple.Formatted(str, argsLabels, argsObjects); return(false); }
// Token: 0x0600007C RID: 124 RVA: 0x000067F8 File Offset: 0x000049F8 public static void RemoveTrait(Pawn pawn, Trait trait, string doer, MessageTypeDef MsgType, bool SendMsg = true) { Pawn_StoryTracker story = pawn.story; Trait remTrait = (story != null) ? (from x in story.traits.allTraits where x.def == trait.def select x).FirstOrDefault() : null; if (remTrait == null) { return; } if (pawn != null) { Pawn_StoryTracker story2 = pawn.story; if (story2 != null) { story2.traits.allTraits.Remove(remTrait); } } MSTraitChanger.TraitsUpdated(pawn); if (SendMsg) { string key = "MSExotic.TraitRemoved"; NamedArgument arg = pawn?.LabelShort.CapitalizeFirst(); Trait trait2 = trait; Messages.Message(key.Translate(arg, trait2?.Label.CapitalizeFirst(), doer.CapitalizeFirst()), pawn, MsgType, true); } }
private CustomAttribute HandleCustomAttribute(Cts.MethodDesc constructor, Ecma.CustomAttributeValue <Cts.TypeDesc> decodedValue) { CustomAttribute result = new CustomAttribute { Constructor = HandleQualifiedMethod(constructor), }; result.FixedArguments.Capacity = decodedValue.FixedArguments.Length; foreach (var decodedArgument in decodedValue.FixedArguments) { var fixedArgument = HandleCustomAttributeConstantValue(decodedArgument.Type, decodedArgument.Value); result.FixedArguments.Add(fixedArgument); } result.NamedArguments.Capacity = decodedValue.NamedArguments.Length; foreach (var decodedArgument in decodedValue.NamedArguments) { var namedArgument = new NamedArgument { Flags = decodedArgument.Kind == Ecma.CustomAttributeNamedArgumentKind.Field ? NamedArgumentMemberKind.Field : NamedArgumentMemberKind.Property, Name = HandleString(decodedArgument.Name), Type = HandleType(decodedArgument.Type), Value = HandleCustomAttributeConstantValue(decodedArgument.Type, decodedArgument.Value) }; result.NamedArguments.Add(namedArgument); } return(result); }
// Token: 0x0600007C RID: 124 RVA: 0x000067F8 File Offset: 0x000049F8 public static void RemoveTrait(Pawn pawn, Trait trait, string doer, MessageTypeDef MsgType, bool SendMsg = true) { var story = pawn.story; var remTrait = story != null ? (from x in story.traits.allTraits where x.def == trait.def select x).FirstOrDefault() : null; if (remTrait == null) { return; } var story2 = pawn.story; story2?.traits.allTraits.Remove(remTrait); TraitsUpdated(pawn); if (!SendMsg) { return; } var key = "MSExotic.TraitRemoved"; NamedArgument arg = pawn.LabelShort.CapitalizeFirst(); var trait2 = trait; Messages.Message(key.Translate(arg, trait2?.Label.CapitalizeFirst(), doer.CapitalizeFirst()), pawn, MsgType); }
// // If throwIfMissingMetadata is false, returns null rather than throwing a MissingMetadataException. // internal sealed override IList <CustomAttributeNamedArgument> GetNamedArguments(bool throwIfMissingMetadata) { LowLevelListWithIList <CustomAttributeNamedArgument> customAttributeNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>(); foreach (NamedArgumentHandle namedArgumentHandle in _customAttribute.NamedArguments) { NamedArgument namedArgument = namedArgumentHandle.GetNamedArgument(_reader); String memberName = namedArgument.Name.GetString(_reader); bool isField = (namedArgument.Flags == NamedArgumentMemberKind.Field); CustomAttributeTypedArgument typedValue = ParseFixedArgument( _reader, namedArgument.Value, throwIfMissingMetadata, delegate() { // We got here because the custom attribute blob did not inclue type information. For named arguments, this is considered illegal metadata // (ECMA always includes type info for named arguments.) throw new BadImageFormatException(); } ); if (typedValue.ArgumentType == null) { Debug.Assert(!throwIfMissingMetadata); return(null); } customAttributeNamedArguments.Add(ReflectionAugments.CreateCustomAttributeNamedArgument(this.AttributeType, memberName, isField, typedValue)); } return(customAttributeNamedArguments); }
When_formatting_command_line_with_Single_style_Then_it_should_return_single_string_with_Name_and_Value_delimited_by_equals_sign() { var sut = new NamedArgument("ArgumentName", "ArgumentValue"); IEnumerable <string> commandLine = sut.FormatCommandLine("---", CommandLineArgumentStyle.SingleWithEqualsSignDelimiter); commandLine.Should().Equal("---ArgumentName=ArgumentValue"); }
When_formatting_command_line_with_Separated_style_Then_it_should_return_Name_and_Value_strings() { var sut = new NamedArgument("ArgumentName", "ArgumentValue"); IEnumerable <string> commandLine = sut.FormatCommandLine("---", CommandLineArgumentStyle.Separated); commandLine.Should().Equal("---ArgumentName", "ArgumentValue"); }
public SignalArgs(SignalArgs args) { count = args.count; arg1 = args.arg1; arg2 = args.arg2; arg3 = args.arg3; arg4 = args.arg4; this.args = args.args; }
public SignalArgs(NamedArgument arg1) { count = 1; this.arg1 = arg1; arg2 = default(NamedArgument); arg3 = default(NamedArgument); arg4 = default(NamedArgument); args = null; }
public SignalArgs(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3) { count = 3; this.arg1 = arg1; this.arg2 = arg2; this.arg3 = arg3; arg4 = default(NamedArgument); args = null; }
public static JToken ToJson(NamedArgument arg) { var obj = (JObject)ToJson((SyntaxNode)arg); obj["type"] = "NamedArgument"; obj["name"] = ToJson(arg.Name); obj["value"] = ToJson((dynamic)arg.Value); return(obj); }
public static JToken ToJson(NamedArgument arg) { return(new JObject { { "type", "narg" }, { "name", arg.Name }, { "val", ToJson(arg.Value) } }); }
public SignalArgs(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4) { count = 4; this.arg1 = arg1; this.arg2 = arg2; this.arg3 = arg3; this.arg4 = arg4; args = null; }
public void ComposesArgumentsForRequiredNamedArguments() { NamedArgument <string> namedArgument = this.AddNamedArgument("name", "placeholder", null, Optional <IEnumerable <string> > .CreateNotSet()); this.requiredArguments.Add(namedArgument); Usage result = this.testee.Compose(); result.Arguments.Should().Be("-name <placeholder>"); }
public void ComposesOptionsForNamedArguments_WithAlias() { NamedArgument <string> namedArgument = this.AddNamedArgument("name", "placeholder", "description", Optional <IEnumerable <string> > .CreateNotSet()); this.longAliases.Add("alias", namedArgument); this.longAliases.Add("other_alias", namedArgument); Usage result = this.testee.Compose(); result.Options.Should().Be(Lines("-name <placeholder> (--alias, --other_alias)\tdescription")); }
public SignalArgs(params NamedArgument[] args) { count = args.Length; if (args.Length > 4) { arg1 = default(NamedArgument); arg2 = default(NamedArgument); arg3 = default(NamedArgument); arg4 = default(NamedArgument); this.args = new NamedArgument[args.Length]; for (int i = 0; i < args.Length; i++) { this.args[i] = args[i]; } return; } if (args.Length == 1) { arg1 = args[0]; arg2 = default(NamedArgument); arg3 = default(NamedArgument); arg4 = default(NamedArgument); } else if (args.Length == 2) { arg1 = args[0]; arg2 = args[1]; arg3 = default(NamedArgument); arg4 = default(NamedArgument); } else if (args.Length == 3) { arg1 = args[0]; arg2 = args[1]; arg3 = args[2]; arg4 = default(NamedArgument); } else if (args.Length == 4) { arg1 = args[0]; arg2 = args[1]; arg3 = args[2]; arg4 = args[3]; } else { arg1 = default(NamedArgument); arg2 = default(NamedArgument); arg3 = default(NamedArgument); arg4 = default(NamedArgument); } this.args = null; }
/// <summary> /// Determines if position is in the argument name. Typically used to /// a) suppress general intellisense when typing function arguments /// in a function/ definition such as in 'x <- function(a|' /// b) determine if completion list should contain argumet names /// when user types inside function call. /// </summary> internal static bool IsInFunctionArgumentName <T>(AstRoot ast, int position) where T : class, IFunction { T funcDef = ast.GetNodeOfTypeFromPosition <T>(position); if (funcDef == null || funcDef.OpenBrace == null || funcDef.Arguments == null) { return(false); } if (position < funcDef.OpenBrace.End || position >= funcDef.SignatureEnd) { return(false); } int start = funcDef.OpenBrace.End; int end = funcDef.SignatureEnd; if (funcDef.Arguments.Count == 0 && position >= start && position <= end) { return(true); } for (int i = 0; i < funcDef.Arguments.Count; i++) { CommaSeparatedItem csi = funcDef.Arguments[i]; NamedArgument na = csi as NamedArgument; if (position < csi.Start) { break; } end = csi.End; if (position >= start && position <= end) { if (na == null) { return(true); } if (position <= na.EqualsSign.Start) { return(true); } } } return(false); }
public void Succeeds_WhenRequiredNamedArgumentsArePresent() { var namedArgument = new NamedArgument <string>("name", v => { }); var configuration = new CommandLineConfiguration( new[] { namedArgument }, NoLongAliases, NoRequiredArguments, NoHelp); var testee = new CommandLineParser(configuration); var result = testee.Parse(new[] { "-name", "value" }); result.Succeeded.Should().BeTrue(); }
public bool Is(string option_name, int namespace_id = 1) { if (this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(option_name)) { NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(option_name); if (arg.Turn.Matched) { return(arg.Turn.Value == ON); } return(true); } else { return(false); } }
public static List <IArgument> GetArguments() { var idArgument = new NamedArgument() { Name = "id" }; var newItemCommand = new NewItemCommand() { Name = "newitem" }; var nameArgument = new NamedArgument() { Name = "name" }; var fullSwitch = new SwitchArgument() { Name = "full" }; var exampleSwitch = new SwitchArgument() { Name = "example" }; var cmdCmd = new CmdCommand() { Name = "command", Aliases = new string[] { "cmd" } }; var helpCommand = new HelpCommand() { Name = "help", ArgumentSequence = new List <IArgument> { nameArgument } }; var startCommand = new StartCommand() { Name = "start", RequiredArguments = new List <IArgument>() { idArgument } }; var lst = new List <IArgument>() { helpCommand, startCommand, idArgument, newItemCommand, nameArgument, fullSwitch, exampleSwitch, cmdCmd }; return(lst); }
private NamedArgument <string> AddNamedArgument(string name, string valuePlaceholder, string description, Optional <IEnumerable <string> > allowedValues) { var namedArgument = new NamedArgument <string>(name, _) { AllowedValues = allowedValues }; var namedHelp = new NamedHelp <string>(namedArgument) { ValuePlaceholder = valuePlaceholder, Description = description }; this.arguments.Add(namedArgument); this.help.Add(namedHelp); return(namedArgument); }
public void Fails_WhenRequiredNamedArgumentIsMissing() { var namedArgument = new NamedArgument <string>("name", v => { }); var configuration = new CommandLineConfiguration( new[] { namedArgument }, NoLongAliases, new[] { namedArgument }, NoHelp); var testee = new CommandLineParser(configuration); var result = testee.Parse(new string[] { }); result.Should() .BeFailedParsingResult() .WithMessage(Errors.Errors.RequiredNamedArgumentIsMissing("name")); }
public void Add(NamedArgument arg) { if (args != null) { NamedArgument[] array = new NamedArgument[args.Length + 1]; for (int i = 0; i < args.Length; i++) { array[i] = args[i]; } array[array.Length - 1] = arg; args = array; count = args.Length; return; } if (count == 0) { arg1 = arg; } else if (count == 1) { arg2 = arg; } else if (count == 2) { arg3 = arg; } else if (count == 3) { arg4 = arg; } else { args = new NamedArgument[5]; args[0] = arg1; args[1] = arg2; args[2] = arg3; args[3] = arg4; args[4] = arg; arg1 = default(NamedArgument); arg2 = default(NamedArgument); arg3 = default(NamedArgument); arg4 = default(NamedArgument); } count++; }
public bool TryGetArg(string name, out NamedArgument arg) { if (count == 0) { arg = default(NamedArgument); return(false); } if (args != null) { for (int i = 0; i < args.Length; i++) { if (args[i].label == name) { arg = args[i]; return(true); } } } else { if (count >= 1 && arg1.label == name) { arg = arg1; return(true); } if (count >= 2 && arg2.label == name) { arg = arg2; return(true); } if (count >= 3 && arg3.label == name) { arg = arg3; return(true); } if (count >= 4 && arg4.label == name) { arg = arg4; return(true); } } arg = default(NamedArgument); return(false); }
public string this[string option_name, int namespace_id = 1] { get { if (this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(option_name)) { NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(option_name); if (arg.Turn.Matched) { return(arg.Turn.Value); } return(arg.Value.Matched ? arg.Value.Value : null); } else { return(null); } } }
// // If throwIfMissingMetadata is false, returns null rather than throwing a MissingMetadataException. // internal sealed override IList <CustomAttributeNamedArgument> GetNamedArguments(bool throwIfMissingMetadata) { LowLevelListWithIList <CustomAttributeNamedArgument> customAttributeNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>(); foreach (NamedArgumentHandle namedArgumentHandle in _customAttribute.NamedArguments) { NamedArgument namedArgument = namedArgumentHandle.GetNamedArgument(_reader); string memberName = namedArgument.Name.GetString(_reader); bool isField = (namedArgument.Flags == NamedArgumentMemberKind.Field); Exception? exception = null; RuntimeTypeInfo?argumentType = namedArgument.Type.TryResolve(_reader, new TypeContext(null, null), ref exception); if (argumentType == null) { if (throwIfMissingMetadata) { throw exception !; } else { return(null); } } object? value; Exception e = namedArgument.Value.TryParseConstantValue(_reader, out value); if (e != null) { if (throwIfMissingMetadata) { throw e; } else { return(null); } } CustomAttributeTypedArgument typedValue = WrapInCustomAttributeTypedArgument(value, argumentType); customAttributeNamedArguments.Add(CreateCustomAttributeNamedArgument(this.AttributeType, memberName, isField, typedValue)); } return(customAttributeNamedArguments); }
public virtual Differences VisitNamedArgument(NamedArgument namedArgument1, NamedArgument namedArgument2){ Differences differences = new Differences(namedArgument1, namedArgument2); if (namedArgument1 == null || namedArgument2 == null){ if (namedArgument1 != namedArgument2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } NamedArgument changes = (NamedArgument)namedArgument2.Clone(); NamedArgument deletions = (NamedArgument)namedArgument2.Clone(); NamedArgument insertions = (NamedArgument)namedArgument2.Clone(); if (namedArgument1.IsCustomAttributeProperty == namedArgument2.IsCustomAttributeProperty) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++; Differences diff = this.VisitIdentifier(namedArgument1.Name, namedArgument2.Name); if (diff == null){Debug.Assert(false); return differences;} changes.Name = diff.Changes as Identifier; deletions.Name = diff.Deletions as Identifier; insertions.Name = diff.Insertions as Identifier; Debug.Assert(diff.Changes == changes.Name && diff.Deletions == deletions.Name && diff.Insertions == insertions.Name); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; diff = this.VisitExpression(namedArgument1.Value, namedArgument2.Value); if (diff == null){Debug.Assert(false); return differences;} changes.Value = diff.Changes as Expression; deletions.Value = diff.Deletions as Expression; insertions.Value = diff.Insertions as Expression; Debug.Assert(diff.Changes == changes.Value && diff.Deletions == deletions.Value && diff.Insertions == insertions.Value); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
private void GetCustomAttributeNamedArguments(ExpressionList/*!*/ arguments, ushort numNamed, MemoryCursor/*!*/ sigReader) { for (int j = 0; j < numNamed; j++) { int nameTag = sigReader.ReadByte(); bool mustBox = sigReader.Byte(0) == (byte)ElementType.BoxedEnum; TypeNode/*!*/ vType = this.ParseTypeSignature(sigReader); Identifier id = sigReader.ReadIdentifierFromSerString(); object val = this.GetCustomAttributeLiteralValue(sigReader, ref vType); Literal lit = val as Literal; if (lit == null) lit = new Literal(val, vType); NamedArgument narg = new NamedArgument(id, lit); narg.Type = vType; narg.IsCustomAttributeProperty = nameTag == 0x54; narg.ValueIsBoxed = mustBox; arguments.Add(narg); } }
public override Expression VisitNamedArgument(NamedArgument namedArgument) { if (namedArgument == null) return null; return base.VisitNamedArgument((NamedArgument)namedArgument.Clone()); }
public override Expression VisitNamedArgument(NamedArgument namedArgument) { throw new ApplicationException("unimplemented"); }
public virtual void VisitNamedArgument(NamedArgument namedArgument) { if (namedArgument == null) return; this.VisitExpression(namedArgument.Value); }
public virtual Expression VisitNamedArgument(NamedArgument namedArgument){ if (namedArgument == null) return null; namedArgument.Value = this.VisitExpression(namedArgument.Value); return namedArgument; }
private void ParseAttributes(ref List<SourceCustomAttribute>/*?*/ sourceAttributes, bool globalAttributes, TokenSet followers) { while (this.currentToken == Token.LeftBracket) { int position = this.scanner.CurrentDocumentPosition(); this.GetNextToken(); AttributeTargets target = this.ParseAttributeTarget(); if (globalAttributes) { if (target != AttributeTargets.Assembly && target != AttributeTargets.Module) { this.scanner.RestoreDocumentPosition(position); this.currentToken = Token.None; this.GetNextToken(); return; } } while (true) { Expression expr = this.ParseExpression(followers|Token.Comma|Token.RightBracket); MethodCall/*?*/ mcall = expr as MethodCall; if (mcall != null && (mcall.MethodExpression is SimpleName || mcall.MethodExpression is QualifiedName || mcall.MethodExpression is AliasQualifiedName)) { AttributeTypeExpression type = new AttributeTypeExpression(mcall.MethodExpression); List<Expression> arguments = new List<Expression>(mcall.OriginalArguments); bool seenNamedArgument = false; for (int i = 0, n = arguments.Count; i < n; i++) { Assignment/*?*/ assignment = arguments[i] as Assignment; if (assignment == null) { if (seenNamedArgument) this.HandleError(arguments[i].SourceLocation, Error.NamedArgumentExpected); continue; } SimpleName/*?*/ name = assignment.Target.Expression as SimpleName; if (name == null) { this.HandleError(assignment.Target.SourceLocation, Error.ExpectedIdentifier); name = new SimpleName(Dummy.Name, assignment.Target.SourceLocation, false); } seenNamedArgument = true; arguments[i] = new NamedArgument(name, assignment.Source, assignment.SourceLocation); } if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1); sourceAttributes.Add(new SourceCustomAttribute(target, type, arguments, mcall.SourceLocation)); } else if (expr is SimpleName || expr is QualifiedName || expr is AliasQualifiedName) { AttributeTypeExpression type = new AttributeTypeExpression(expr); if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1); sourceAttributes.Add(new SourceCustomAttribute(target, type, new List<Expression>(0), expr.SourceLocation)); } else { this.HandleError(expr.SourceLocation, Error.ExpectedIdentifier); } if (this.currentToken != Token.Comma) break; this.GetNextToken(); } this.Skip(Token.RightBracket); } if (sourceAttributes != null) sourceAttributes.TrimExcess(); }
public virtual Expression VisitNamedArgument(NamedArgument namedArgument, NamedArgument changes, NamedArgument deletions, NamedArgument insertions){ this.UpdateSourceContext(namedArgument, changes); if (namedArgument == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ } }else if (deletions != null) return null; return namedArgument; }
public virtual Expression VisitNamedArgument(NamedArgument namedArgument1, NamedArgument namedArgument2) { if (namedArgument1 == null) return null; if (namedArgument2 == null) namedArgument1.Value = this.VisitExpression(namedArgument1.Value, null); else namedArgument1.Value = this.VisitExpression(namedArgument1.Value, namedArgument2.Value); return namedArgument1; }