/// <summary> /// Returns false if the item has already been set before and if the already set item is not equal to 'r'. /// Inserts 'r' into the target dictionary and returns true otherwise. /// </summary> bool Set(ITemplateParameter p, ISemantic r, string name = null) { if (string.IsNullOrEmpty(name)) { name = p.Name; } TemplateParameterSymbol rl = null; if (!TargetDictionary.TryGetValue(name, out rl) || rl == null) { TargetDictionary[name] = new TemplateParameterSymbol(p, r, null, TargetDictionary.ParameterOwner); return(true); } else { if (rl != null) { if (ResultComparer.IsEqual(rl.Base, r)) { return(true); } else { // Error: Ambiguous assignment } } TargetDictionary[name] = new TemplateParameterSymbol(p, r, null, TargetDictionary.ParameterOwner); return(false); } }
static bool CheckAndDeduceTypeAgainstTplParameter(ITemplateParameter handledParameter, ISemantic argumentToCheck, DeducedTypeDictionary deducedTypes, ResolverContextStack ctxt) { return(new Templates.TemplateParameterDeduction(deducedTypes, ctxt).Handle(handledParameter, argumentToCheck)); }
// Checks if the input parameter value is a valid choice for the parameter, and returns the canonical value, or defaultValue if there is no appropriate canonical value. // If the parameter or value is null, return defaultValue. // For this to return other than the defaultValue, one of these must occur: // - the input value must either exactly match one of the choices (case-insensitive) // - there must be exactly one choice value starting with the input value (case-insensitive). public static string GetCanonicalValueForChoiceParamOrDefault(ITemplateInfo template, string paramName, string inputParamValue, string defaultValue = null) { if (string.IsNullOrEmpty(paramName) || string.IsNullOrEmpty(inputParamValue)) { return(defaultValue); } ITemplateParameter parameter = template.Parameters.FirstOrDefault(x => string.Equals(x.Name, paramName, StringComparison.Ordinal)); if (parameter == null || parameter.Choices == null || parameter.Choices.Count == 0) { return(defaultValue); } // This is a case-insensitive key lookup, because that is how Choices is initialized. if (parameter.Choices.ContainsKey(inputParamValue)) { return(inputParamValue); } IReadOnlyList <string> startsWithChoices = parameter.Choices.Where(x => x.Key.StartsWith(inputParamValue, StringComparison.OrdinalIgnoreCase)).Select(x => x.Key).ToList(); if (startsWithChoices.Count == 1) { return(startsWithChoices[0]); } return(defaultValue); }
bool IsMoreSpecialized(ITemplateParameter t1, ITemplateParameter t2, Dictionary <string, ISemantic> t1_dummyParameterList) { if (t1 is TemplateTypeParameter && t2 is TemplateTypeParameter && !IsMoreSpecialized((TemplateTypeParameter)t1, (TemplateTypeParameter)t2, t1_dummyParameterList)) { return(false); } else if (t1 is TemplateValueParameter && t2 is TemplateValueParameter && !IsMoreSpecialized((TemplateValueParameter)t1, (TemplateValueParameter)t2)) { return(false); } else if (t1 is TemplateAliasParameter && t2 is TemplateAliasParameter && !IsMoreSpecialized((TemplateAliasParameter)t1, (TemplateAliasParameter)t2, t1_dummyParameterList)) { return(false); } else if (t1 is TemplateThisParameter && t2 is TemplateThisParameter && ! IsMoreSpecialized(((TemplateThisParameter)t1).FollowParameter, ((TemplateThisParameter)t2).FollowParameter, t1_dummyParameterList)) { return(false); } return(false); }
public void ReparseForTemplate(ITemplateInfo templateInfo, HostSpecificTemplateData hostSpecificTemplateData) { Dictionary <string, string> templateParamValues = new Dictionary <string, string>(); Dictionary <string, IList <string> > remainingParams = new Dictionary <string, IList <string> >(); foreach (KeyValuePair <string, string> inputParam in _rawParameterInputs) { ITemplateParameter matchedParam = default(ITemplateParameter); if (templateInfo.Parameters != null) { matchedParam = templateInfo.Parameters?.FirstOrDefault(x => string.Equals(x.Name, inputParam.Key)); } if (matchedParam != default(ITemplateParameter)) { templateParamValues.Add(inputParam.Key, inputParam.Value); } else { remainingParams.Add(inputParam.Key, new List <string>()); } } InputTemplateParams = templateParamValues; RemainingParameters = remainingParams; RemainingArguments = remainingParams.Keys.ToList(); _allParametersForTemplate = templateInfo.Parameters.Select(x => x.Name).ToList(); }
bool IsMoreSpecialized(ITypeDeclaration Spec, ITemplateParameter t2, Dictionary <string, ISemantic> t1_DummyParamList) { // Make a type out of t1's specialization var frame = ctxt.PushNewScope(ctxt.ScopedBlock.Parent as IBlockNode); // Make the T in e.g. T[] a virtual type so T will be replaced by it // T** will be X** then - so a theoretically valid type instead of a template param var dummyType = new ClassType(new DClassLike { Name = "X" }, null, null); foreach (var kv in t1_DummyParamList) { frame.DeducedTemplateParameters[kv.Key] = new TemplateParameterSymbol(t2, dummyType); } var t1_TypeResults = Resolver.TypeResolution.TypeDeclarationResolver.Resolve(Spec, ctxt); if (t1_TypeResults == null || t1_TypeResults.Length == 0) { return(true); } ctxt.Pop(); // Now try to fit the virtual Type t2 into t1 - and return true if it's possible return(new TemplateParameterDeduction(new DeducedTypeDictionary(), ctxt).Handle(t2, t1_TypeResults[0])); }
internal CliTemplateParameter(ITemplateParameter parameter, HostSpecificTemplateData data) { Name = parameter.Name; Description = parameter.Description ?? string.Empty; Type = ParseType(parameter.DataType); DefaultValue = parameter.DefaultValue; DataType = parameter.DataType; if (Type == ParameterType.Boolean && string.Equals(parameter.DefaultIfOptionWithoutValue, "true", StringComparison.OrdinalIgnoreCase)) { //ignore, parser is doing this behavior by default } else { DefaultIfOptionWithoutValue = parameter.DefaultIfOptionWithoutValue; } IsRequired = parameter.Priority == TemplateParameterPriority.Required && parameter.DefaultValue == null; IsHidden = parameter.Priority == TemplateParameterPriority.Implicit || data.HiddenParameterNames.Contains(parameter.Name); AlwaysShow = data.ParametersToAlwaysShow.Contains(parameter.Name); AllowMultipleValues = parameter.AllowMultipleValues; if (data.ShortNameOverrides.ContainsKey(parameter.Name)) { _shortNameOverrides.Add(data.ShortNameOverrides[parameter.Name]); } if (data.LongNameOverrides.ContainsKey(parameter.Name)) { _longNameOverrides.Add(data.LongNameOverrides[parameter.Name]); } }
internal BlobTemplateParameter(ITemplateParameter parameter) { if (parameter is null) { throw new ArgumentNullException(nameof(parameter)); } if (string.IsNullOrWhiteSpace(parameter.Name)) { throw new ArgumentException($"{nameof(Name)} property should not be null or whitespace", nameof(parameter)); } Name = parameter.Name; DataType = !string.IsNullOrWhiteSpace(parameter.DataType) ? parameter.DataType : "string"; Choices = parameter.Choices; if (DataType.Equals("choice", StringComparison.OrdinalIgnoreCase) && Choices == null) { Choices = new Dictionary <string, ParameterChoice>(); } Priority = parameter.Priority; DefaultIfOptionWithoutValue = parameter.DefaultIfOptionWithoutValue; Description = parameter.Description; AllowMultipleValues = parameter.AllowMultipleValues; }
private static bool TryResolveChoiceValue(string literal, ITemplateParameter param, out string match) { if (literal == null) { match = null; return(false); } string partialMatch = null; foreach (string choiceValue in param.Choices.Keys) { if (string.Equals(choiceValue, literal, StringComparison.OrdinalIgnoreCase)) { // exact match is good, regardless of partial matches match = choiceValue; return(true); } else if (choiceValue.StartsWith(literal, StringComparison.OrdinalIgnoreCase)) { if (partialMatch == null) { partialMatch = choiceValue; } else { // multiple partial matches, can't take one. match = null; return(false); } } } match = partialMatch; return(match != null); }
public void TestLocalizedSymbolDescription(string locale, string expectedDescription) { _ = LoadHostWithLocalizationTemplates(locale, out _, out ITemplateInfo localizationTemplate); ITemplateParameter symbol = localizationTemplate.Parameters?.FirstOrDefault(p => p.Name == "someSymbol"); Assert.NotNull(symbol); Assert.Equal(expectedDescription, symbol.Description); }
public TemplateParameterNode(ITemplateParameter param) { TemplateParameter = param; Name = param.Name; Location = NameLocation = param.Location; EndLocation = param.EndLocation; }
public void TestLocalizedSymbolChoiceDisplayName(string locale, string symbolName, string expectedDisplayName) { _ = LoadHostWithLocalizationTemplates(locale, out _, out ITemplateInfo localizationTemplate); ITemplateParameter symbol = localizationTemplate.Parameters?.FirstOrDefault(p => p.Name == symbolName); Assert.NotNull(symbol); Assert.Equal(expectedDisplayName, symbol.DisplayName); }
public bool OnParameterError(ITemplateParameter parameter, string receivedValue, string message, out string newValue) { Console.WriteLine("DotNetNew3TemplateEngineHost::OnParameterError() called"); Console.WriteLine("\tError message: {0}", message); Console.WriteLine("Parameter name = {0}", parameter.Name); Console.WriteLine("Parameter value = {0}", receivedValue); Console.WriteLine("Enter a new value for the param, or:"); newValue = Console.ReadLine(); return(!string.IsNullOrEmpty(newValue)); }
public bool TryGetParameter(string name, out ITemplateParameter parameter) { if (_parameters.TryGetValue(name, out parameter)) { return(true); } parameter = new Parameter(name, TemplateParameterPriority.Optional, "string"); return(true); }
public TemplateParameterSymbol(ITemplateParameter tp, ISemantic representedTypeOrValue, ISyntaxRegion originalParameterIdentifier = null, DNode parentNode = null) : base(new TemplateParameterNode(tp) { Parent = parentNode }, AbstractType.Get(representedTypeOrValue), originalParameterIdentifier ?? tp) { this.Parameter = tp; this.ParameterValue = representedTypeOrValue as ISymbolValue; }
/// <summary> /// Updates the setting. /// </summary> /// <param name="code">The code.</param> /// <param name="value">The value.</param> public void UpdateSetting(string code, string value) { if (_parameters.ContainsKey(code)) { ITemplateParameter parameter = _parameters[code]; if (parameter != null && !string.IsNullOrWhiteSpace(value)) { parameter.UpdateValue(value); } } }
internal ChoiceTemplateParameter(ITemplateParameter parameter, HostSpecificTemplateData data) : base(parameter, data) { if (!parameter.IsChoice()) { throw new ArgumentException($"{nameof(parameter)} should have {nameof(parameter.Type)} {nameof(ParameterType.Choice)}"); } if (parameter.Choices == null) { throw new ArgumentException($"{nameof(parameter)} should have {nameof(parameter.Choices)}"); } _choices = parameter.Choices.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase); }
public TemplateParameterViewModel(ITemplate parent, ITemplateParameter parameter) { _inner = parameter; if (parameter.Name == "name" && string.IsNullOrEmpty(parameter.DefaultValue)) { _value = parent.DefaultName; } else { _value = parameter.DefaultValue; } }
// Construct with name public TemplateInstance(Template template) { this.Template = template; this.Parameters = new List <string>(); if (Template.ParameterTypes is object) { foreach (string parameter in Template.ParameterTypes) { ITemplateParameter panel = TemplatePanel.CreateTemplateParameterPanel(parameter); Parameters.AddRange(panel.GetDefaultParameters()); } } }
public static bool HasDefaultType(ITemplateParameter p) { if (p is TemplateTypeParameter) return ((TemplateTypeParameter)p).Default != null; else if (p is TemplateAliasParameter) { var ap = (TemplateAliasParameter)p; return ap.DefaultExpression != null || ap.DefaultType != null; } else if (p is TemplateThisParameter) return HasDefaultType(((TemplateThisParameter)p).FollowParameter); else if (p is TemplateValueParameter) return ((TemplateValueParameter)p).DefaultExpression != null; return false; }
public bool Handle(ITemplateParameter parameter, ISemantic argumentToAnalyze) { // Packages aren't allowed at all if (argumentToAnalyze is PackageSymbol) return false; // Module symbols can be used as alias only if (argumentToAnalyze is ModuleSymbol && !(parameter is TemplateAliasParameter)) return false; //TODO: Handle __FILE__ and __LINE__ correctly - so don't evaluate them at the template declaration but at the point of instantiation /* * Introduce previously deduced parameters into current resolution context * to allow value parameter to be of e.g. type T whereas T is already set somewhere before */ DeducedTypeDictionary _prefLocalsBackup = null; if (ctxt != null && ctxt.CurrentContext != null) { _prefLocalsBackup = ctxt.CurrentContext.DeducedTemplateParameters; var d = new DeducedTypeDictionary(); foreach (var kv in TargetDictionary) if (kv.Value != null) d[kv.Key] = kv.Value; ctxt.CurrentContext.DeducedTemplateParameters = d; } bool res = false; if (parameter is TemplateAliasParameter) res = Handle((TemplateAliasParameter)parameter, argumentToAnalyze); else if (parameter is TemplateThisParameter) res = Handle((TemplateThisParameter)parameter, argumentToAnalyze); else if (parameter is TemplateTypeParameter) res = Handle((TemplateTypeParameter)parameter, argumentToAnalyze); else if (parameter is TemplateValueParameter) res = Handle((TemplateValueParameter)parameter, argumentToAnalyze); else if (parameter is TemplateTupleParameter) res = Handle((TemplateTupleParameter)parameter, new[] { argumentToAnalyze }); if (ctxt != null && ctxt.CurrentContext != null) ctxt.CurrentContext.DeducedTemplateParameters = _prefLocalsBackup; return res; }
public bool TryGetParameterDefinition(string name, out ITemplateParameter parameter) { if (_parameters.TryGetValue(name, out parameter)) { return(true); } parameter = new Parameter { Name = name, Requirement = TemplateParameterPriority.Optional, IsVariable = true, Type = "string" }; return(true); }
public void ReparseForTemplate(ITemplateInfo templateInfo, HostSpecificTemplateData hostSpecificTemplateData) { Dictionary <string, string> templateParamValues = new Dictionary <string, string>(); Dictionary <string, IList <string> > remainingParams = new Dictionary <string, IList <string> >(); Dictionary <string, string> overrideToCanonicalMap = hostSpecificTemplateData.LongNameOverrides.ToDictionary(o => o.Value, o => o.Key); foreach (KeyValuePair <string, string> shortNameOverride in hostSpecificTemplateData.ShortNameOverrides) { overrideToCanonicalMap[shortNameOverride.Value] = shortNameOverride.Key; } foreach (KeyValuePair <string, string> inputParam in _templateOptions) { ITemplateParameter matchedParam = default(ITemplateParameter); if (templateInfo.Parameters != null) { matchedParam = templateInfo.Parameters?.FirstOrDefault(x => string.Equals(x.Name, inputParam.Key)); } if (matchedParam != default(ITemplateParameter)) { templateParamValues.Add(inputParam.Key, inputParam.Value); } else if (overrideToCanonicalMap.TryGetValue(inputParam.Key, out string canonical)) { templateParamValues.Add(canonical, inputParam.Value); } else { remainingParams.Add(inputParam.Key, new List <string>()); } } InputTemplateParams = templateParamValues; RemainingParameters = remainingParams; RemainingArguments = remainingParams.Keys.ToList(); _allParametersForTemplate = templateInfo.Parameters.Select(x => x.Name).ToList(); }
public static bool HasDefaultType(ITemplateParameter p) { if (p is TemplateTypeParameter) { return(((TemplateTypeParameter)p).Default != null); } else if (p is TemplateAliasParameter) { var ap = (TemplateAliasParameter)p; return(ap.DefaultExpression != null || ap.DefaultType != null); } else if (p is TemplateThisParameter) { return(HasDefaultType(((TemplateThisParameter)p).FollowParameter)); } else if (p is TemplateValueParameter) { return(((TemplateValueParameter)p).DefaultExpression != null); } return(false); }
public TemplatePanel(EntityDefinition entDef, TemplateInstance template) { InitializeComponent(); Title.Content = template.Template.Name.Replace("_", "__").Substring(0, MAX_NAME_LENGTH); if (template.Template.ParameterNames is null) { return; } int templateIndex = 0; for (int i = 0; i < template.Template.ParameterNames.Count; i++) { ITemplateParameter templateParameterPanel = CreateTemplateParameterPanel(template.Template.ParameterTypes[i]); templateParameterPanel.InitialiseTemplate(template.Template.ParameterNames[i], entDef, template, templateIndex); TemplateStackPanel.Children.Add((UserControl)templateParameterPanel); templateIndex += templateParameterPanel.GetParameterCount(); } }
public bool TryGetParameterDefinition(string name, out ITemplateParameter parameter) { parameter = ParameterDefinitions.FirstOrDefault(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase)); if (parameter != null) { return(true); } parameter = new TemplateParameter { Documentation = string.Empty, Name = name, Priority = TemplateParameterPriority.Optional, Type = "string", IsName = false, DefaultValue = string.Empty, DataType = "string", Choices = null }; return(true); }
internal static object InternalConvertParameterValueToType(ITemplateParameter parameter, string untypedValue) { if (untypedValue == null) { throw new TemplateParamException("Parameter value is null", parameter.Name, null, parameter.DataType); } if (!string.IsNullOrEmpty(parameter.DataType)) { object convertedValue = DataTypeSpecifiedConvertLiteral(parameter, untypedValue); if (convertedValue == null) { throw new TemplateParamException("Parameter value could not be converted", parameter.Name, untypedValue, parameter.DataType); } return(convertedValue); } else { return(InferTypeAndConvertLiteral(untypedValue)); } }
public void TestLocalizedSymbolChoices( string locale, string symbolDesc, string choice0Desc, string choice1Desc, string choice2Desc) { _ = LoadHostWithLocalizationTemplates(locale, out _, out ITemplateInfo localizationTemplate); ITemplateParameter symbol = localizationTemplate.Parameters?.FirstOrDefault(p => p.Name == "someChoice"); Assert.NotNull(symbol); Assert.Equal(symbolDesc, symbol.Description); var choices = symbol.Choices; Assert.NotNull(choices); Assert.True(choices.TryGetValue("choice0", out ParameterChoice choice0), "Template symbol should contain a choice with name 'choice0'."); Assert.Equal(choice0Desc, choice0.Description); Assert.True(choices.TryGetValue("choice1", out ParameterChoice choice1), "Template symbol should contain a choice with name 'choice1'."); Assert.Equal(choice1Desc, choice1.Description); Assert.True(choices.TryGetValue("choice2", out ParameterChoice choice2), "Template symbol should contain a choice with name 'choice2'."); Assert.Equal(choice2Desc, choice2.Description); }
/// <summary> /// Returns false if the item has already been set before and if the already set item is not equal to 'r'. /// Inserts 'r' into the target dictionary and returns true otherwise. /// </summary> bool Set(ITemplateParameter p, ISemantic r, string name=null) { if (string.IsNullOrEmpty(name)) name = p.Name; TemplateParameterSymbol rl=null; if (!TargetDictionary.TryGetValue(name, out rl) || rl == null) { TargetDictionary[name] = new TemplateParameterSymbol(p, r, null, TargetDictionary.ParameterOwner); return true; } else { if (rl!=null) if (ResultComparer.IsEqual(rl.Base, r)) return true; else { // Error: Ambiguous assignment } TargetDictionary[name] = new TemplateParameterSymbol(p, r, null, TargetDictionary.ParameterOwner); return false; } }
bool IsMoreSpecialized(ITemplateParameter t1, ITemplateParameter t2, Dictionary<string, ISemantic> t1_dummyParameterList) { if (t1 is TemplateTypeParameter && t2 is TemplateTypeParameter && !IsMoreSpecialized((TemplateTypeParameter)t1, (TemplateTypeParameter)t2, t1_dummyParameterList)) return false; else if (t1 is TemplateValueParameter && t2 is TemplateValueParameter && !IsMoreSpecialized((TemplateValueParameter)t1, (TemplateValueParameter)t2)) return false; else if (t1 is TemplateAliasParameter && t2 is TemplateAliasParameter && !IsMoreSpecialized((TemplateAliasParameter)t1, (TemplateAliasParameter)t2, t1_dummyParameterList)) return false; else if (t1 is TemplateThisParameter && t2 is TemplateThisParameter && ! IsMoreSpecialized(((TemplateThisParameter)t1).FollowParameter, ((TemplateThisParameter)t2).FollowParameter, t1_dummyParameterList)) return false; return false; }
public virtual bool OnParameterError(ITemplateParameter parameter, string receivedValue, string message, out string newValue) { return(_baseHost.OnParameterError(parameter, receivedValue, message, out newValue)); }
bool IsMoreSpecialized(ITypeDeclaration Spec, ITemplateParameter t2, Dictionary<string, ISemantic> t1_DummyParamList) { // Make a type out of t1's specialization var frame = ctxt.PushNewScope(ctxt.ScopedBlock.Parent as IBlockNode); // Make the T in e.g. T[] a virtual type so T will be replaced by it // T** will be X** then - so a theoretically valid type instead of a template param var dummyType = new ClassType(new DClassLike { Name = "X" }, null, null); foreach (var kv in t1_DummyParamList) frame.DeducedTemplateParameters[kv.Key] = new TemplateParameterSymbol(t2,dummyType); var t1_TypeResults = Resolver.TypeResolution.TypeDeclarationResolver.Resolve(Spec, ctxt); if (t1_TypeResults == null || t1_TypeResults.Length == 0) return true; ctxt.Pop(); // Now try to fit the virtual Type t2 into t1 - and return true if it's possible return new TemplateParameterDeduction(new DeducedTypeDictionary(), ctxt).Handle(t2, t1_TypeResults[0]); }
public void AddParameter(ITemplateParameter param) { _parameters[param.Name] = param; }
public TemplateParameterDeductionError(ITemplateParameter parameter, ISemantic argument, string msg) : base(parameter, msg) { this.Argument = argument; }
// For explicitly data-typed variables, attempt to convert the variable value to the specified type. // Data type names: // - choice // - bool // - float // - int // - hex // - text // The data type names are case insensitive. // // Returns the converted value if it can be converted, throw otherwise internal static object DataTypeSpecifiedConvertLiteral(IEngineEnvironmentSettings environmentSettings, ITemplateParameter param, string literal, out bool valueResolutionError) { valueResolutionError = false; if (string.Equals(param.DataType, "bool", StringComparison.OrdinalIgnoreCase)) { if (string.Equals(literal, "true", StringComparison.OrdinalIgnoreCase)) { return(true); } else if (string.Equals(literal, "false", StringComparison.OrdinalIgnoreCase)) { return(false); } else { bool boolVal = false; // Note: if the literal is ever null, it is probably due to a problem in TemplateCreator.Instantiate() // which takes care of making null bool -> true as appropriate. // This else can also happen if there is a value but it can't be converted. string val; while (environmentSettings.Host.OnParameterError(param, null, "ParameterValueNotSpecified", out val) && !bool.TryParse(val, out boolVal)) { } valueResolutionError = !bool.TryParse(val, out boolVal); return(boolVal); } } else if (string.Equals(param.DataType, "choice", StringComparison.OrdinalIgnoreCase)) { if (TryResolveChoiceValue(literal, param, out string match)) { return(match); } if (literal == null && param.Priority != TemplateParameterPriority.Required) { return(param.DefaultValue); } string val; while (environmentSettings.Host.OnParameterError(param, null, "ValueNotValid:" + string.Join(",", param.Choices.Keys), out val) && !TryResolveChoiceValue(literal, param, out val)) { } valueResolutionError = val == null; return(val); } else if (string.Equals(param.DataType, "float", StringComparison.OrdinalIgnoreCase)) { if (ParserExtensions.DoubleTryParseСurrentOrInvariant(literal, out double convertedFloat)) { return(convertedFloat); } else { string val; while (environmentSettings.Host.OnParameterError(param, null, "ValueNotValidMustBeFloat", out val) && (val == null || !ParserExtensions.DoubleTryParseСurrentOrInvariant(val, out convertedFloat))) { } valueResolutionError = !ParserExtensions.DoubleTryParseСurrentOrInvariant(val, out convertedFloat); return(convertedFloat); } } else if (string.Equals(param.DataType, "int", StringComparison.OrdinalIgnoreCase) || string.Equals(param.DataType, "integer", StringComparison.OrdinalIgnoreCase)) { if (long.TryParse(literal, out long convertedInt)) { return(convertedInt); } else { string val; while (environmentSettings.Host.OnParameterError(param, null, "ValueNotValidMustBeInteger", out val) && (val == null || !long.TryParse(val, out convertedInt))) { } valueResolutionError = !long.TryParse(val, out convertedInt); return(convertedInt); } } else if (string.Equals(param.DataType, "hex", StringComparison.OrdinalIgnoreCase)) { if (long.TryParse(literal.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out long convertedHex)) { return(convertedHex); } else { string val; while (environmentSettings.Host.OnParameterError(param, null, "ValueNotValidMustBeHex", out val) && (val == null || val.Length < 3 || !long.TryParse(val.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out convertedHex))) { } valueResolutionError = !long.TryParse(val.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out convertedHex); return(convertedHex); } } else if (string.Equals(param.DataType, "text", StringComparison.OrdinalIgnoreCase) || string.Equals(param.DataType, "string", StringComparison.OrdinalIgnoreCase)) { // "text" is a valid data type, but doesn't need any special handling. return(literal); } else { return(literal); } }
private static bool DeduceParam(ResolverContextStack ctxt, DSymbol overload, DeducedTypeDictionary deducedTypes, IEnumerator<ISemantic> argEnum, ITemplateParameter expectedParam) { if (expectedParam is TemplateThisParameter && overload.Base != null) { var ttp = (TemplateThisParameter)expectedParam; // Get the type of the type of 'this' - so of the result that is the overload's base var t = DResolver.StripMemberSymbols(overload.Base); if (t == null || t.DeclarationOrExpressionBase == null) return false; //TODO: Still not sure if it's ok to pass a type result to it // - looking at things like typeof(T) that shall return e.g. const(A) instead of A only. if (!CheckAndDeduceTypeAgainstTplParameter(ttp, t, deducedTypes, ctxt)) return false; return true; } // Used when no argument but default arg given bool useDefaultType = false; if (argEnum.MoveNext() || (useDefaultType = HasDefaultType(expectedParam))) { // On tuples, take all following arguments and pass them to the check function if (expectedParam is TemplateTupleParameter) { var tupleItems = new List<ISemantic>(); // A tuple must at least contain one item! tupleItems.Add(argEnum.Current); while (argEnum.MoveNext()) tupleItems.Add(argEnum.Current); if (!CheckAndDeduceTypeTuple((TemplateTupleParameter)expectedParam, tupleItems, deducedTypes, ctxt)) return false; } else if (argEnum.Current != null) { if (!CheckAndDeduceTypeAgainstTplParameter(expectedParam, argEnum.Current, deducedTypes, ctxt)) return false; } else if (useDefaultType && CheckAndDeduceTypeAgainstTplParameter(expectedParam, null, deducedTypes, ctxt)) { // It's legit - just do nothing } else return false; } // There might be too few args - but that doesn't mean that it's not correct - it's only required that all parameters got satisfied with a type else if (!AllParamatersSatisfied(deducedTypes)) return false; return true; }
/// <summary> /// Note: /// http://www.digitalmars.com/d/2.0/declaration.html#DeclaratorSuffix /// The definition of a sequence of declarator suffixes is buggy here! Theoretically template parameters can be declared without a surrounding ( and )! /// Also, more than one parameter sequences are possible! /// /// TemplateParameterList[opt] Parameters MemberFunctionAttributes[opt] /// </summary> ITypeDeclaration DeclaratorSuffixes(out ITemplateParameter[] TemplateParameters, out List<INode> _Parameters, List<DAttribute> _Attributes) { ITypeDeclaration td = null; TemplateParameters = null; _Parameters = null; while (MemberFunctionAttribute[laKind]) { _Attributes.Add(new DAttribute(laKind, la.Value)); Step(); } while (laKind == (OpenSquareBracket)) { Step(); var ad = new ArrayDecl() { Location=t.Location }; LastParsedObject = ad; ad.InnerDeclaration = td; if (laKind != (CloseSquareBracket)) { ITypeDeclaration keyType=null; if (!IsAssignExpression()) { AllowWeakTypeParsing = true; keyType= ad.KeyType = Type(); AllowWeakTypeParsing = false; } if (keyType==null) ad.KeyExpression = AssignExpression(); } Expect(CloseSquareBracket); ad.EndLocation = t.EndLocation; td = ad; } if (laKind == (OpenParenthesis)) { if (IsTemplateParameterList()) { TemplateParameters = TemplateParameterList(); } _Parameters = Parameters(null); //TODO: MemberFunctionAttributes -- add them to the declaration while (StorageClass[laKind] || laKind==PropertyAttribute) { Step(); } } while (MemberFunctionAttribute[laKind]) { _Attributes.Add(new DAttribute(laKind,la.Value)); Step(); } return td; }
/// <summary> /// Note: /// http://www.digitalmars.com/d/2.0/declaration.html#DeclaratorSuffix /// The definition of a sequence of declarator suffixes is buggy here! Theoretically template parameters can be declared without a surrounding ( and )! /// Also, more than one parameter sequences are possible! /// /// TemplateParameterList[opt] Parameters MemberFunctionAttributes[opt] /// </summary> ITypeDeclaration DeclaratorSuffixes(out ITemplateParameter[] TemplateParameters, out List<INode> _Parameters, List<DAttribute> _Attributes) { DAttribute attr = null; ITypeDeclaration td = null; TemplateParameters = null; _Parameters = null; while (MemberFunctionAttribute[laKind]) { _Attributes.Add(attr=new DAttribute(laKind, la.Value)); LastParsedObject = attr; Step(); } while (laKind == (OpenSquareBracket)) { Step(); var ad = new ArrayDecl() { Location=t.Location }; LastParsedObject = ad; ad.InnerDeclaration = td; if (laKind != (CloseSquareBracket)) { ad.ClampsEmpty = false; ITypeDeclaration keyType=null; var la_backup = la; if (!IsAssignExpression()) { var weakType = AllowWeakTypeParsing; AllowWeakTypeParsing = true; keyType= ad.KeyType = Type(); AllowWeakTypeParsing = weakType; } if (keyType == null || laKind != CloseSquareBracket) { keyType = ad.KeyType = null; la = la_backup; ad.KeyExpression = AssignExpression(); } } Expect(CloseSquareBracket); ad.EndLocation = t.EndLocation; td = ad; } if (laKind == (OpenParenthesis)) { if (IsTemplateParameterList()) { TemplateParameters = TemplateParameterList(); } _Parameters = Parameters(null); while (StorageClass[laKind] || laKind==PropertyAttribute) { _Attributes.Add(attr=new DAttribute(laKind, la.Value)); LastParsedObject = attr; Step(); } } while (MemberFunctionAttribute[laKind]) { _Attributes.Add(attr=new DAttribute(laKind,la.Value)); LastParsedObject = attr; Step(); } return td; }
public TemplateParameterNode(ITemplateParameter param) { TemplateParameter = param; Name = param.Name; Location = NameLocation = param.Location; EndLocation = param.EndLocation; }
// TODO: rework this method... it's a bit of a god-method, for very specific purposes. // Number of times I've deferred on reworking this method: 4 internal static TemplateUsageInformation GetTemplateUsageInformation(ITemplateInfo templateInfo, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator) { IParameterSet allParams; IReadOnlyList <string> userParamsWithInvalidValues; HashSet <string> userParamsWithDefaultValues; bool hasPostActionScriptRunner; ITemplate template = environmentSettings.SettingsLoader.LoadTemplate(templateInfo, commandInput.BaselineName); TemplateListResolver.ParseTemplateArgs(templateInfo, hostDataLoader, commandInput); allParams = templateCreator.SetupDefaultParamValuesFromTemplateAndHost(template, template.DefaultName ?? "testName", out IReadOnlyList <string> defaultParamsWithInvalidValues); templateCreator.ResolveUserParameters(template, allParams, commandInput.InputTemplateParams, out userParamsWithInvalidValues); hasPostActionScriptRunner = CheckIfTemplateHasScriptRunningPostActions(template, environmentSettings, commandInput, templateCreator); templateCreator.ReleaseMountPoints(template); List <InvalidParameterInfo> invalidParameters = new List <InvalidParameterInfo>(); if (userParamsWithInvalidValues.Any()) { // Lookup the input param formats - userParamsWithInvalidValues has canonical. foreach (string canonical in userParamsWithInvalidValues) { commandInput.InputTemplateParams.TryGetValue(canonical, out string specifiedValue); string inputFormat = commandInput.TemplateParamInputFormat(canonical); InvalidParameterInfo invalidParam = new InvalidParameterInfo(inputFormat, specifiedValue, canonical); invalidParameters.Add(invalidParam); } } if (templateCreator.AnyParametersWithInvalidDefaultsUnresolved(defaultParamsWithInvalidValues, userParamsWithInvalidValues, commandInput.InputTemplateParams, out IReadOnlyList <string> defaultsWithUnresolvedInvalidValues)) { IParameterSet templateParams = template.Generator.GetParametersForTemplate(environmentSettings, template); foreach (string defaultParamName in defaultsWithUnresolvedInvalidValues) { ITemplateParameter param = templateParams.ParameterDefinitions.FirstOrDefault(x => string.Equals(x.Name, defaultParamName, StringComparison.Ordinal)); if (param != null) { // Get the best input format available. IReadOnlyList <string> inputVariants = commandInput.VariantsForCanonical(param.Name); string displayName = inputVariants.FirstOrDefault(x => x.Contains(param.Name)) ?? inputVariants.Aggregate("", (max, cur) => max.Length > cur.Length ? max : cur) ?? param.Name; InvalidParameterInfo invalidParam = new InvalidParameterInfo(displayName, param.DefaultValue, displayName, true); invalidParameters.Add(invalidParam); } } } // get all the flags // get all the user input params that have the default value Dictionary <string, IReadOnlyList <string> > inputFlagVariants = new Dictionary <string, IReadOnlyList <string> >(); userParamsWithDefaultValues = new HashSet <string>(); foreach (string paramName in allParams.ParameterDefinitions.Select(x => x.Name)) { inputFlagVariants[paramName] = commandInput.VariantsForCanonical(paramName); if (commandInput.TemplateParamHasValue(paramName) && string.IsNullOrEmpty(commandInput.TemplateParamValue(paramName))) { userParamsWithDefaultValues.Add(paramName); } } IReadOnlyDictionary <string, IReadOnlyList <string> > variantsForCanonicals = inputFlagVariants; return(new TemplateUsageInformation { InvalidParameters = invalidParameters, AllParameters = allParams, UserParametersWithInvalidValues = userParamsWithInvalidValues, UserParametersWithDefaultValues = userParamsWithDefaultValues, VariantsForCanonicals = variantsForCanonicals, HasPostActionScriptRunner = hasPostActionScriptRunner }); }
static bool CheckAndDeduceTypeAgainstTplParameter(ITemplateParameter handledParameter, ISemantic argumentToCheck, DeducedTypeDictionary deducedTypes, ResolverContextStack ctxt) { return new Templates.TemplateParameterDeduction(deducedTypes, ctxt).Handle(handledParameter, argumentToCheck); }