public NotificationMessage(StringToken stringToken, params TemplateValue[] values) { StringToken = stringToken; _template = new Template(stringToken, values); _message = new Lazy<string>(() => _template.Render()); }
protected Verifier( XmlReader document, ExpBuilder builder, ErrorHandler handler ) { this.document = document; this.handler = handler; this.builder = builder; this.attPruner = new AttPruner(builder); emptyStringToken = new StringToken("",builder,this); }
private void processToken(StringToken token) { var text = _repository.FindBy<LocalizedText>(x => x.Name == token.Key && x.Culture == EN_US); if (text != null) return; Console.WriteLine("Found new StringToken: " + token.Key); text = new LocalizedText(token.Key, EN_US, token.DefaultValue); _repository.Save(text); }
public static IToken Parse(string text, int startPosition = 0, Action<IToken, int, string> callback = null) { if (string.IsNullOrWhiteSpace(text)) return new NullToken(); if (text.StartsWith("'") && text.IndexOf('\'', 1) <= 0) return new StringToken(text.Substring(1)); List<string> blocks = text.SplitIntoBlocks(new[] {'\'', '\'', '"', '"', '^', '^', '{', '}', '(', ')'}, true, StringUtils.DelimiterInclude.IncludeSeparately); string simplifed = ""; List<IToken> subResults = new List<IToken>(); int currentPosition = startPosition; for (int i = 0; i < blocks.Count; i += 3) { string start = blocks[i]; string entry = blocks[i + 1]; IToken subResult = null; switch (start) { case "\"": case "'": subResult = new StringToken(entry); callback?.Invoke(subResult, currentPosition, "'" + entry + "'"); break; case "^": subResult = Parse(entry); callback?.Invoke(subResult, currentPosition, "'" + entry + "'"); break; case "{": subResult = new ExpressionToken(null, new SubstitutionOperator(), Parse(entry)); callback?.Invoke(subResult, currentPosition, "{" + entry + "}"); break; case "(": subResult = Parse(entry, currentPosition + 1, callback); break; default: simplifed += entry; break; } if (subResult != null) { simplifed += $"█{subResults.Count}█"; subResults.Add(subResult); } if (callback != null) currentPosition += start.Length + entry.Length + blocks[i + 2].Length; } IToken result = ParseExpressionNoBrackets(simplifed, startPosition, callback); result = SubstituteValues(result, subResults); return result ?? new StringToken(text); }
public string FindMissingText(StringToken key, CultureInfo culture) { var defaultValue = culture.Name + "_" + key.Key; if (key.DefaultValue.IsNotEmpty() && culture.Equals(_defaultCulture)) { defaultValue = key.DefaultValue; } _storage.WriteMissing(key.Key, defaultValue, culture); return defaultValue; }
/// <summary> /// Parse identifier list. Identifier list have the syntax: identifierList ::= stringDelimiter identifier* stringDelimiter /// </summary> /// <param name="token">Token containing the string with the identifier list.</param> /// <param name="parseErrorSink">Error sink for reporting parse errors.</param> /// <param name="sourceCodeService">Source code service that can convert tokens to source code span and reports issues.</param> /// <returns>A collection of sub-tokens if successful or null if token string is illegal.</returns> protected internal virtual IEnumerable<SourceReference<string>> ParseIdentifierList(StringToken token, IParseErrorSink parseErrorSink, ISourceCodeReferenceService sourceCodeService) { if (token == null) throw new ArgumentNullException("token"); if (parseErrorSink == null) throw new ArgumentNullException("parseErrorSink"); if (sourceCodeService == null) throw new ArgumentNullException("sourceCodeService"); List<SourceReference<string>> result = new List<SourceReference<string>>(); if (token.Value.Length == 0) return result; Scanner scanner = new Scanner(new StringReader(token.Value)); Token t = scanner.GetToken(); while (!(t is EofToken)) { // Skip whitespaces (incl. comments). if (!(t is WhitespaceToken)) { // Offset the token to the position within the original token. +1 is due to the opening string ' quote. t.SetTokenValues( new SourceLocation(t.StartPosition.Position + token.StartPosition.Position + 1, t.StartPosition.Line + token.StartPosition.Line, t.StartPosition.Column + token.StartPosition.Column + 1), new SourceLocation(t.StopPosition.Position + token.StartPosition.Position + 1, t.StopPosition.Line + token.StartPosition.Line, t.StopPosition.Column + token.StartPosition.Column + 1), t.ScanError); if (t is IdentifierToken) { // identifier OK result.Add(new SourceReference<string>(((IdentifierToken)t).Value, t.StartPosition, t.StopPosition, sourceCodeService)); } else { // Non-identifier, report error parseErrorSink.AddParserError(t.StartPosition, t.StopPosition, "Expected identifier", t); return null; // Error condition } } t = scanner.GetToken(); } return result; }
public IToken Parse(string text) { List<string> blocks = text.SplitIntoBlocks(new[] {'\'', '\'', '"', '"', '{', '}', '(', ')'}, true, StringUtils.DelimiterInclude.IncludeSeparately); string simplifed = ""; List<IToken> subResults = new List<IToken>(); for (int i = 0; i < blocks.Count / 3; i++) { int index = i * 3; string start = blocks[index]; string entry = blocks[index + 1]; IToken subResult; switch (start) { case "\"": case "'": subResult = new StringToken(entry); simplifed += $"█{subResults.Count}█"; subResults.Add(subResult); break; case "{": subResult = new ExpressionToken(null, new SubstitutionToken(), Parse(entry)); simplifed += $"█{subResults.Count}█"; subResults.Add(subResult); break; case "(": subResult = Parse(entry); simplifed += $"█{subResults.Count}█"; subResults.Add(subResult); break; default: simplifed += entry; break; } } IToken result = ParseExpressionNoBrackets(simplifed); result = SubstituteValues(result, subResults); return result ?? new StringToken(text); }
/// <summary> /// Evaluate the function. /// </summary> /// <param name="parameters">The tokens that make up the function parameter list.</param> /// <param name="substitutions">The tokens that can be used for substitutions.</param> /// <param name="isFinal">Whether a result needs to be returned.</param> /// <returns></returns> public override IToken Perform(IToken parameters, TokenTreeList substitutions, bool isFinal) { ListToken listToken = parameters as ListToken; int count = listToken?.Tokens.Count ?? 0; if (count > 0) { IToken separator = new StringToken(" "); if (count > 1) { separator = listToken.Tokens[count - 1]; --count; } IToken current = null; for (int i = 0; i < count; ++i) { IToken token = listToken.Tokens[i]; if (token is ExpressionToken) return UnParsed(parameters); current = AddToken(current, separator, token, substitutions, isFinal); } return current ?? new StringToken(""); } return parameters; }
public string GetTextForKey(StringToken key) { return _textValues.Retrieve(key); }
/** * This is the main lexing algorithm. It consumes source file as string and puts out token list. * Token consists of token type and range that token spans. */ public static IToken[] Parse(string s) { LinkedList <IToken> ll = new LinkedList <IToken>(); // use five kinds of token to produce token stream. var index = 0; var next = 0; while (index < s.Length) { // try to parse as number if (NumberToken.ParseNumber(s, index, out var tokenNumber, out next)) { ll.AddLast(tokenNumber); index = next; continue; } // then try to parse as string if (StringToken.ParseString(s, index, out var tokenString, out next)) { ll.AddLast(tokenString); index = next; continue; } // then try to parse as identifier if (IdentifierToken.ParseIdentifier(s, index, out var tokenIdentifier, out next)) { ll.AddLast(tokenIdentifier); index = next; continue; } // then try to parse as comment if (CommentToken.ParseComment(s, index, out var tokensComment, out next)) { foreach (var t in tokensComment) { ll.AddLast(t); } index = next; continue; } // then try to parse as symbol token if (SymbolToken.ParseSymbol(s, index, out var tokenSymbol, out next)) { ll.AddLast(tokenSymbol); index = next; continue; } if (Char.IsWhiteSpace(s[index])) { // skip spaces index++; continue; } // otherwise token is unknown throw new Exception("unknown token " + s[index] + " at position " + index); } // return collected tokens return(ll.ToArray()); }
public MaxValueFieldRule(IComparable bounds, StringToken token) { _bounds = bounds; Token = token; }
protected virtual StringToken VerifyIdentifierList(StringToken token, string errorMessage) { // stringDelimiter identifier* stringDelimiter if (token == null) return null; if (token.Value.Length == 0) return token; bool inComment = false; bool identifierStart = true; ScanResult scanResult = new ScanResult(); foreach (char ch in token.Value) { scanResult.SetResult(ch); if (scanResult.IsCommentDelimiter()) { inComment = !inComment; identifierStart = true; } else { if (!inComment) { if (scanResult.IsWhitespace()) { identifierStart = true; } else { if (identifierStart) { if (!scanResult.IsLetter()) { this.ReportParserError(errorMessage, token); return null; } identifierStart = false; } else { if (!(scanResult.IsLetter() || scanResult.IsDigit())) { this.ReportParserError(errorMessage, token); return null; } } } } } } return token; }
public MenuNode this[StringToken parentKey] { set { var registration = new MenuRegistration(new AddBefore(), new Literal(parentKey), value); _registry._registrations.Add(registration); } }
public void Run(ICommandInteraction writer, [Values("set", "add", "rem", "create")] LiteralToken action, StringToken name) { Machine machine; switch (action.Value) { case "add": machine = new Machine(); EmulationManager.Instance.CurrentEmulation.AddMachine(machine, name.Value); if (GetCurrentMachine() == null) { SetCurrentMachine(machine); } break; case "set": Machine machineToSet; if (!EmulationManager.Instance.CurrentEmulation.TryGetMachineByName(name.Value, out machineToSet)) { writer.WriteError(string.Format("Machine {0} not found.", name.Value)); break; } SetCurrentMachine(machineToSet); break; case "rem": Machine machineToRemove; if (!EmulationManager.Instance.CurrentEmulation.TryGetMachineByName(name.Value, out machineToRemove)) { writer.WriteError(string.Format("Machine {0} not found.", name.Value)); break; } EmulationManager.Instance.CurrentEmulation.RemoveMachine(name.Value); if (GetCurrentMachine() == machineToRemove) { SetCurrentMachine(null); } break; case "create": machine = new Machine(); EmulationManager.Instance.CurrentEmulation.AddMachine(machine, name.Value); SetCurrentMachine(machine); break; } }
public bool Matches(StringToken token) { return token.ToLocalizationKey().ToString() == _name || token.Key == _name; }
public RangeLengthFieldRule(int min, int max, StringToken token) { _min = min; _max = max; Token = token; }
public void AddCriteria <T>(Expression <Func <T, object> > property, StringToken op, string value) { var criteria = Criteria.For(property, op.Key, value); AddCriteria(criteria); }
public NotificationMessage RegisterMessage <T>(Expression <Func <T, object> > property, StringToken message, params TemplateValue[] values) { return(RegisterMessage(property.ToAccessor(), message, values)); }
public NotificationMessage RegisterMessage(PropertyInfo property, StringToken notificationMessage, params TemplateValue[] values) { return(RegisterMessage(new SingleProperty(property), notificationMessage, values)); }
public void find_by_type() { StringToken.Find(typeof(TargetKey), "One").ShouldBeTheSameAs(TargetKey.One); StringToken.Find(typeof(TargetKey2), "One").ShouldBeTheSameAs(TargetKey2.One); }
public NotificationMessage(StringToken stringToken) : this(stringToken, new Dictionary <string, string>()) { }
public void AddCriteria(Expression <Func <TEntity, object> > property, StringToken op, object value) { _initialCriteria.Add(Criteria.For(property, op.Key, value.ToString())); }
public string GetTextForKey(StringToken key) { var localizationKey = key.ToLocalizationKey(); return _localeCache .Retrieve(localizationKey, () => _missingHandler.FindMissingText(key, _localeCache.Culture)); }
public MinValueFieldRule(IComparable bounds, StringToken token) { _bounds = bounds; Token = token; }
public bool Equals(StringToken obj) { }
public FieldValidationExpression GreaterOrEqualToZero(StringToken token) { return(register(new GreaterOrEqualToZeroRule(token))); }
private static IToken PerformSubstitutionOperation(IReadOnlyList<string> tokens, int startPosition, Action<IToken, int, string> callback) { IToken token = null; string firstToken = tokens[1]; if (!string.IsNullOrWhiteSpace(firstToken)) token = new StringToken(firstToken); IToken result = new ExpressionToken(null, new SubstitutionOperator(), token); //if (token != null) // callback?.Invoke(result, startPosition + tokens[0].Length, firstToken); if (!string.IsNullOrWhiteSpace(tokens[0])) { token = ParseExpressionNoBrackets(tokens[0].Trim(), startPosition, null); ExpressionToken expression = token as ExpressionToken; if (expression?.NeedsSecond ?? false) result = expression.SetSecond(result); else result = new ExpressionToken(token, new StringPlusOperator(), result); } if (!string.IsNullOrWhiteSpace(tokens[4])) { token = ParseExpressionNoBrackets(tokens[4].Trim(), startPosition + tokens[0].Length + tokens[3].Length, null); result = new ExpressionToken(result, new StringPlusOperator(), token); } return result; }
public FieldValidationExpression Required(StringToken token) { return(register(new RequiredFieldRule(token))); }
public GreaterOrEqualToZeroRule(StringToken token) { Token = token; }
public FieldValidationExpression Email(StringToken token) { return(register(new EmailFieldRule(token))); }
public MenuItemAttribute(string title) { _title = new NavigationKey(title); }
public FieldValidationExpression MinimumLength(int length, StringToken token) { return(register(new MinimumLengthRule(length, token))); }
public InterchangeVersionIdentifierNode(StringToken versionId) { this.VersionId = versionId; }
public FieldValidationExpression RangeLength(int min, int max, StringToken token) { return(register(new RangeLengthFieldRule(min, max, token))); }
public bool DependsOn(StringToken token) { return _matcher.Matches(token); }
public FieldValidationExpression MaxValue(IComparable bounds, StringToken token) { return(register(new MaxValueFieldRule(bounds, token))); }
private string findMissingLocalizedText(StringToken token) { //return "Error String Not Found!"; //var localizedText = _repository.FindBy<LocalizedText>(t => t.Name == token.Key && t.Culture == Culture.Name); //if (localizedText == null) //{ string defaultText = "Error String Not Found!"; if (token.DefaultValue.IsNotEmpty()) { var prefix = ""; //((Culture.Name.Equals("en-US", StringComparison.InvariantCultureIgnoreCase)) ? "" : Culture.Name + "_"); defaultText = prefix + token.DefaultValue; } // else // { // defaultText = Culture + "_" + token.Key; // } // localizedText = new LocalizedText(token.Key, Culture.Name, defaultText); // _repository.Save(localizedText); //} //return localizedText.Text; return defaultText; }
public FieldValidationExpression RegEx(string expression, StringToken token) { return(register(new RegularExpressionFieldRule(expression, token))); }
public ViewDisplayExpression <VIEWMODEL> AddDisplayNameForHref(StringToken displayName) { _displayName = displayName.ToString(); return(this); }
public FieldEqualityRuleExpression UseToken(StringToken token) { _rule.Token = token; return(this); }
public static bool op_Inequality(StringToken a, StringToken b) { }
public MenuChain(StringToken key) { _key = key; }
private static IToken PerformSubstitutionOperation(IReadOnlyList<string> tokens) { IToken token = null; if (!string.IsNullOrWhiteSpace(tokens[1])) { token = new StringToken(tokens[1]); } IToken result = new ExpressionToken(null, new SubstitutionToken(), token); if (!string.IsNullOrWhiteSpace(tokens[0])) { token = ParseExpressionNoBrackets(tokens[0].Trim()); ExpressionToken expression = token as ExpressionToken; if (expression?.NeedsSecond ?? false) result = expression.SetSecond(result); else result = new ExpressionToken(token, new StringPlusToken(), result); } if (!string.IsNullOrWhiteSpace(tokens[3])) { token = ParseExpressionNoBrackets(tokens[3].Trim()); result = new ExpressionToken(result, new StringPlusToken(), token); } return result; }
/// <summary> /// Find /// </summary> /// <param name="key"></param> /// <returns></returns> public MenuNode FindByKey(StringToken key) { return(AllNodes().FirstOrDefault(x => x.Key == key)); }
private static IToken CreateStringToken(IReadOnlyList<string> tokens, int startPosition, Action<IToken, int, string> callback) { string item = tokens[0]; IToken token = new StringToken(item); //if (!item.Contains("█")) // callback?.Invoke(token, startPosition, item); return token; }
public static Token Create(TokenKind kind, SourceLocation location) { Token token; switch (kind) { #region case KEYWORD: case TokenKind.T_AS: case TokenKind.T_BREAK: case TokenKind.T_CASE: case TokenKind.T_CATCH: case TokenKind.T_CONST: case TokenKind.T_CONTINUE: case TokenKind.T_DEFAULT: case TokenKind.T_DELETE: case TokenKind.T_DO: case TokenKind.T_ELSE: case TokenKind.T_ENUM: case TokenKind.T_FALSE: case TokenKind.T_FINALLY: case TokenKind.T_FOR: case TokenKind.T_FUNCTION: case TokenKind.T_IF: case TokenKind.T_IMPORT: case TokenKind.T_IN: case TokenKind.T_INSTANCEOF: case TokenKind.T_LET: case TokenKind.T_NEW: case TokenKind.T_NULL: case TokenKind.T_ON: case TokenKind.T_PRAGMA: case TokenKind.T_PROPERTY: case TokenKind.T_PUBLIC: case TokenKind.T_READONLY: case TokenKind.T_RESERVED_WORD: case TokenKind.T_RETURN: case TokenKind.T_SET: case TokenKind.T_SIGNAL: case TokenKind.T_SWITCH: case TokenKind.T_THIS: case TokenKind.T_THROW: case TokenKind.T_TRUE: case TokenKind.T_TRY: case TokenKind.T_TYPEOF: case TokenKind.T_VAR: case TokenKind.T_VOID: case TokenKind.T_WHILE: case TokenKind.T_WITH: #endregion token = new KeywordToken(); break; case TokenKind.T_NUMERIC_LITERAL: token = new NumberToken(); break; case TokenKind.T_MULTILINE_STRING_LITERAL: case TokenKind.T_STRING_LITERAL: token = new StringToken(); break; case TokenKind.T_COMMENT: token = new CommentToken(); break; default: token = new Token(); break; } token.Kind = kind; token.Location = location; return(token); }
public IEnumerable <MenuItemToken> MenuFor(StringToken key) { var chain = _navigation.MenuFor(key); return(chain.Select(BuildToken)); }
public NotificationMessage RegisterMessage <T>(Expression <Func <T, object> > property, StringToken message) { return(RegisterMessage(property.ToAccessor(), message)); }
public string GetTextForKey(StringToken key) { return key.DefaultValue ?? Culture.Name + "_" + key.Key; }
public void Description(StringToken description) { alter = feed => feed.Description = description.ToString().ToContent(); }
public MinimumLengthRule(int length, StringToken token) { _length = length; Token = token; }
public RegularExpressionFieldRule(string expression, StringToken token) { Expression = new Regex(expression); Token = token; }
protected virtual StringToken VerifyIdentifierString(StringToken token, string errorMessage) { // stringDelimiter identifier stringDelimiter // identifier ::= letter (letter | digit)* if (token == null) return null; string str = token.Value; if (str.Length == 0) { this.ReportParserError(errorMessage, token); return null; // Empty } ScanResult scanResult = new ScanResult(); scanResult.SetResult(str[0]); if (!scanResult.IsLetter()) { this.ReportParserError(errorMessage, token); return null; // First char non-letter } foreach (char ch in str) { scanResult.SetResult(ch); if (!(scanResult.IsLetter() || scanResult.IsDigit())) { this.ReportParserError(errorMessage, token); return null; // Non-letter or non-digit char } } return token; // OK }
private StringToken buildCommonToken() { const string key = "test"; return(StringToken.FromKeyString(key, "default")); }
public MenuItemAttribute(string key, string defaultText) { _title = new NavigationKey(key, defaultText); }
public void Title(StringToken title) { alter = feed => feed.Title = title.ToString().ToContent(); }
public AddExpression ForMenu(StringToken key) { _lastKey = key; return new AddExpression(this); }
public bool Equals(StringToken obj) { if (ReferenceEquals(null, obj)) return false; if (ReferenceEquals(this, obj)) return true; return Equals(obj._key, _key); }
public void Run(ICommandInteraction writer, StringToken command) { Execute(command.Value, writer); }
public bool TryTokenize(byte currentByte, IInputBytes inputBytes, out IToken token) { var builder = new StringBuilder(); token = null; if (inputBytes == null) { return(false); } if (currentByte != '(') { return(false); } int numberOfBrackets = 1; bool isEscapeActive = false; bool isLineBreaking = false; bool octalModeActive = false; short[] octal = { 0, 0, 0 }; int octalsRead = 0; while (inputBytes.MoveNext()) { var b = inputBytes.CurrentByte; var c = (char)b; if (octalModeActive) { var nextCharacterOctal = c >= '0' && c <= '7'; if (nextCharacterOctal) { // left shift the octals. LeftShiftOctal(c, octalsRead, octal); octalsRead++; } if (octalsRead == 3 || !nextCharacterOctal) { var characterCode = OctalHelpers.FromOctalDigits(octal); // For now :( // TODO: I have a sneaking suspicion this is wrong, not sure what behaviour is for large octal numbers builder.Append((char)characterCode); octal[0] = 0; octal[1] = 0; octal[2] = 0; octalsRead = 0; octalModeActive = false; } if (nextCharacterOctal) { continue; } } switch (c) { case ')': isLineBreaking = false; if (!isEscapeActive) { numberOfBrackets--; } if (numberOfBrackets > 0) { builder.Append(c); break; } // TODO: Check for other ends of string where the string is improperly formatted. See commented method // numberOfBrackets = CheckForEndOfString(inputBytes, numberOfBrackets); isEscapeActive = false; break; case '(': isLineBreaking = false; if (!isEscapeActive) { numberOfBrackets++; } builder.Append(c); break; // Escape case '\\': isLineBreaking = false; // Escaped backslash if (isEscapeActive) { builder.Append(c); } else { isEscapeActive = true; } break; default: if (isLineBreaking) { if (ReadHelper.IsEndOfLine(c)) { continue; } isLineBreaking = false; builder.Append(c); } else if (isEscapeActive) { ProcessEscapedCharacter(c, builder, octal, ref octalModeActive, ref octalsRead, ref isLineBreaking); isEscapeActive = false; } else { builder.Append(c); } break; } if (numberOfBrackets <= 0) { break; } } token = new StringToken(builder.ToString()); return(true); }