/// <summary> /// Search for the given symbol definition in the environment. /// </summary> /// <param name="symbolName"></param> /// <returns></returns> private SymbolicDef _InternalGetSymbolDef(string symbolName) { symbolName = _CanonicalizeName(symbolName); // Try each stack frame. foreach (var dictionary in _define_stack.ToArray()) { SymbolicDef symbolic_def; if (dictionary.TryGetValue(symbolName, out symbolic_def) && !_evaluated_symbols.ContainsKey(symbolic_def)) { return(symbolic_def); } } // If nothing is found on the stack, try the system environment variables. string environment_variable = Environment.GetEnvironmentVariable(symbolName); if (environment_variable != null) { var symbolic_def2 = new SymbolicDef { Name = symbolName, Value = _StringToNodeSet(environment_variable) }; return(symbolic_def2); } return(null); }
/// <summary> /// XSLT extension method, called to define a notset symbolic_def in the preprocessor /// environment. The symbolic_def can be referred to symbolically in subsequent /// definitions or expansions. /// </summary> /// <param name="name"></param> /// <param name="value"></param> public IEnumerable <XNode> DefineNodesetSymbol(string name, IEnumerable <XNode> value) { _CheckAlreadyDefined(name); var sym = new SymbolicDef { Name = name, Value = value, IsExplicitlyDefined = true }; _DefineSymbolOnStack(sym); return(new XNode[] {}); }
/// <summary> /// Retrieve the SymbolicDef bound to the given name. If the name occurs multiple times /// in the stack, returns the highest (most-local) definition. /// </summary> /// <param name="name">symbol name</param> /// <returns>SymbolicDef</returns> /// <exception cref="EvaluationException">Symbol was not defined</exception> /// <exception cref="ExplicitDefinitionRequiredException">Symbol was defined in the /// environment, but preprocess is in "explicit definition required" mode.</exception> internal SymbolicDef GetSymbolDef(string name) { if (!_IsDefined(name)) { Utils.ThrowException(UndefinedSymbolException.CreateException, "Reference to unknown symbol '{0}'", new object[] { name }); } SymbolicDef symbolic_def = _InternalGetSymbolDef(_CanonicalizeName(name)); if (_Settings.ExplicitDeclarationRequired && !symbolic_def.IsExplicitlyDefined) { Utils.ThrowException(ExplicitDefinitionRequiredException.CreateException, "Symbol '{0}' must be explicitly declared before usage.", new object[] { name }); } return(symbolic_def); }
private void _DefineTextSymbol(string name, string value, bool isExplicit) { if (string.IsNullOrEmpty(name)) { throw DefinitionException.CreateException( "An attempt was made to define a nameless variable (value = '{0}'", new object[] { value }); } _CheckAlreadyDefined(name); var symbolic_def = new SymbolicDef { Name = name, Value = new[] { new XText(value) }, IsExplicitlyDefined = isExplicit }; _DefineSymbolOnStack(symbolic_def); }
/// <summary> /// Define the given symbol on the current stack frame. /// </summary> /// <param name="symbolicDef"></param> private void _DefineSymbolOnStack(SymbolicDef symbolicDef) { _define_stack.Peek().Add(_CanonicalizeName(symbolicDef.Name), symbolicDef); }