internal void ReportGetValueError(int k, object item, Exception ex) { if (TraceData.IsEnabled) { SourceValueInfo svi = PW.GetSourceValueInfo(k); Type type = PW.GetType(k); string parentName = (k > 0)? PW.GetSourceValueInfo(k - 1).name : String.Empty; TraceData.Trace(ParentBindingExpression.TraceLevel, TraceData.CannotGetClrRawValue( svi.propertyName, type.Name, parentName, AvTrace.TypeName(item)), ParentBindingExpression, ex); } }
internal void ReportSetValueError(int k, object item, object value, Exception ex) { if (TraceData.IsEnabled) { SourceValueInfo svi = PW.GetSourceValueInfo(k); Type type = PW.GetType(k); TraceData.Trace(TraceEventType.Error, TraceData.CannotSetClrRawValue( svi.propertyName, type.Name, AvTrace.TypeName(item), AvTrace.ToStringHelper(value), AvTrace.TypeName(value)), ParentBindingExpression, ex); } }
// Token: 0x06007485 RID: 29829 RVA: 0x002156DC File Offset: 0x002138DC internal void ReportGetValueError(int k, object item, Exception ex) { if (TraceData.IsEnabled) { SourceValueInfo sourceValueInfo = this.PW.GetSourceValueInfo(k); Type type = this.PW.GetType(k); string text = (k > 0) ? this.PW.GetSourceValueInfo(k - 1).name : string.Empty; TraceData.Trace(base.ParentBindingExpression.TraceLevel, TraceData.CannotGetClrRawValue(new object[] { sourceValueInfo.propertyName, type.Name, text, AvTrace.TypeName(item) }), base.ParentBindingExpression, ex); } }
void AddProperty() { int start = _index; int level = 0; // include leading dots in the path (for XLinq) while (_index < _n && _path[_index] == '.') { ++_index; } while (_index < _n && (level > 0 || SpecialChars.IndexOf(_path[_index]) < 0)) { if (_path[_index] == '(') { ++level; } else if (_path[_index] == ')') { --level; } ++_index; } if (level > 0) { SetError(SRID.UnmatchedParen, _path.Substring(start)); return; } if (level < 0) { SetError(SRID.UnmatchedParen, _path.Substring(0, _index)); return; } string name = _path.Substring(start, _index - start).Trim(); SourceValueInfo info = (name.Length > 0) ? new SourceValueInfo(SourceValueType.Property, _drillIn, name) : new SourceValueInfo(SourceValueType.Direct, _drillIn, (string)null); _al.Add(info); StartNewLevel(); }
// Token: 0x06007626 RID: 30246 RVA: 0x0021AE18 File Offset: 0x00219018 private void AddProperty() { int index = this._index; int num = 0; while (this._index < this._n) { if (this._path[this._index] != '.') { break; } this._index++; } while (this._index < this._n && (num > 0 || PathParser.SpecialChars.IndexOf(this._path[this._index]) < 0)) { if (this._path[this._index] == '(') { num++; } else if (this._path[this._index] == ')') { num--; } this._index++; } if (num > 0) { this.SetError("UnmatchedParen", new object[] { this._path.Substring(index) }); return; } if (num < 0) { this.SetError("UnmatchedParen", new object[] { this._path.Substring(0, this._index) }); return; } string text = this._path.Substring(index, this._index - index).Trim(); SourceValueInfo sourceValueInfo = (text.Length > 0) ? new SourceValueInfo(SourceValueType.Property, this._drillIn, text) : new SourceValueInfo(SourceValueType.Direct, this._drillIn, null); this._al.Add(sourceValueInfo); this.StartNewLevel(); }
// Each level of the path consists of // a property or indexer: // .propname // /propname // [index] // /[index] // (The . or / is optional in the very first level.) // The parser is a finite-state machine with two states corresponding // to the two-character lookahead above, plus two more states for the begining // and end. The state transistions are done explicitly in the code below. // // The parser returns a 0-length array if it finds a syntax error. // It sets the Error property, so the caller can find out what happened. public SourceValueInfo[] Parse(string path) { _path = (path != null) ? path.Trim() : String.Empty; _n = _path.Length; if (_n == 0) { // When no path string is specified, use value directly and do not drill-in. (same as Path=".") // ClrBindingWorker needs this information to tell XmlBindingWorker about collectionMode. return new SourceValueInfo[] { new SourceValueInfo(SourceValueType.Direct, DrillIn.Never, (string)null) }; } _index = 0; _drillIn = DrillIn.IfNeeded; _al.Clear(); _error = null; _state = State.Init; while (_state != State.Done) { char c = (_index<_n) ? _path[_index] : NullChar; if (Char.IsWhiteSpace(c)) { ++ _index; continue; } switch (_state) { case State.Init: switch (c) { case '/': case '.': case NullChar: _state = State.DrillIn; break; default: _state = State.Prop; break; } break; case State.DrillIn: switch (c) { case '/': _drillIn = DrillIn.Always; ++ _index; break; case '.': _drillIn = DrillIn.Never; ++ _index; break; case '[': case NullChar: break; default: SetError(SRID.PathSyntax, _path.Substring(0, _index), _path.Substring(_index)); return EmptyInfo; } _state = State.Prop; break; case State.Prop: bool isIndexer = false; switch (c) { case '[': isIndexer = true; break; default: break; } if (isIndexer) AddIndexer(); else AddProperty(); break; } } SourceValueInfo[] result; if (_error == null) { result = new SourceValueInfo[_al.Count]; _al.CopyTo(result); } else { result = EmptyInfo; } return result; }
void AddIndexer() { // indexer args are parsed by a (sub-) state machine with four // states. The string is a comma-separated list of params, each // of which has two parts: a "paren string" and a "value string" // (both parts are optional). The character ^ can be used to // escape any of the special characters: comma, parens, ], ^, // and white space. int start = ++_index; // skip over initial [ int level = 1; // level of nested [] bool escaped = false; // true if current char is escaped bool trimRight = false; // true if value string has trailing white space StringBuilder parenStringBuilder = new StringBuilder(); StringBuilder valueStringBuilder = new StringBuilder(); FrugalObjectList<IndexerParamInfo> paramList = new FrugalObjectList<IndexerParamInfo>(); IndexerState state = IndexerState.BeginParam; while (state != IndexerState.Done) { if (_index >= _n) { SetError(SRID.UnmatchedBracket, _path.Substring(start - 1)); return; } Char c = _path[_index++]; // handle the escape character - set the flag for the next character if (c == EscapeChar && !escaped) { escaped = true; continue; } switch (state) { case IndexerState.BeginParam: // look for optional (...) if (escaped) { // no '(', go parse the value state = IndexerState.ValueString; goto case IndexerState.ValueString; } else if (c == '(') { // '(' introduces optional paren string state = IndexerState.ParenString; } else if (Char.IsWhiteSpace(c)) { // ignore leading white space } else { // no '(', go parse the value state = IndexerState.ValueString; goto case IndexerState.ValueString; } break; case IndexerState.ParenString: // parse (...) if (escaped) { // add an escaped character without question parenStringBuilder.Append(c); } else if (c == ')') { // end of (...), start to parse value state = IndexerState.ValueString; } else { // add normal characters inside (...) parenStringBuilder.Append(c); } break; case IndexerState.ValueString: // parse value if (escaped) { // add an escaped character without question valueStringBuilder.Append(c); trimRight = false; } else if (level > 1) { // inside nested [], add characters without question valueStringBuilder.Append(c); trimRight = false; if (c == ']') { --level; } } else if (Char.IsWhiteSpace(c)) { // add white space, but trim it later if it's trailing valueStringBuilder.Append(c); trimRight = true; } else if (c == ',' || c == ']') { // end of current paramater - assemble the two parts string parenString = parenStringBuilder.ToString(); string valueString = valueStringBuilder.ToString(); if (trimRight) { valueString = valueString.TrimEnd(); } // add the parts to the final result paramList.Add(new IndexerParamInfo(parenString, valueString)); // reset for the next parameter parenStringBuilder.Length = 0; valueStringBuilder.Length = 0; trimRight = false; // after ',' parse next parameter; after ']' we're done state = (c == ']') ? IndexerState.Done : IndexerState.BeginParam; } else { // add normal characters valueStringBuilder.Append(c); trimRight = false; // keep track of nested [] if (c == '[') { ++level; } } break; } // after processing each character, clear the escape flag escaped = false; } // assemble the final result SourceValueInfo info = new SourceValueInfo( SourceValueType.Indexer, _drillIn, paramList); _al.Add(info); StartNewLevel(); }
// Each level of the path consists of // a property or indexer: // .propname // /propname // [index] // /[index] // (The . or / is optional in the very first level.) // The parser is a finite-state machine with two states corresponding // to the two-character lookahead above, plus two more states for the begining // and end. The state transistions are done explicitly in the code below. // // The parser returns a 0-length array if it finds a syntax error. // It sets the Error property, so the caller can find out what happened. public SourceValueInfo[] Parse(string path) { _path = (path != null) ? path.Trim() : String.Empty; _n = _path.Length; if (_n == 0) { // When no path string is specified, use value directly and do not drill-in. (same as Path=".") // ClrBindingWorker needs this information to tell XmlBindingWorker about collectionMode. return(new SourceValueInfo[] { new SourceValueInfo(SourceValueType.Direct, DrillIn.Never, (string)null) }); } _index = 0; _drillIn = DrillIn.IfNeeded; _al.Clear(); _error = null; _state = State.Init; while (_state != State.Done) { char c = (_index < _n) ? _path[_index] : NullChar; if (Char.IsWhiteSpace(c)) { ++_index; continue; } switch (_state) { case State.Init: switch (c) { case '/': case '.': case NullChar: _state = State.DrillIn; break; default: _state = State.Prop; break; } break; case State.DrillIn: switch (c) { case '/': _drillIn = DrillIn.Always; ++_index; break; case '.': _drillIn = DrillIn.Never; ++_index; break; case '[': case NullChar: break; default: SetError(SRID.PathSyntax, _path.Substring(0, _index), _path.Substring(_index)); return(EmptyInfo); } _state = State.Prop; break; case State.Prop: bool isIndexer = false; switch (c) { case '[': isIndexer = true; break; default: break; } if (isIndexer) { AddIndexer(); } else { AddProperty(); } break; } } SourceValueInfo[] result; if (_error == null) { result = new SourceValueInfo[_al.Count]; _al.CopyTo(result); } else { result = EmptyInfo; } return(result); }
void AddIndexer() { // indexer args are parsed by a (sub-) state machine with four // states. The string is a comma-separated list of params, each // of which has two parts: a "paren string" and a "value string" // (both parts are optional). The character ^ can be used to // escape any of the special characters: comma, parens, ], ^, // and white space. int start = ++_index; // skip over initial [ int level = 1; // level of nested [] bool escaped = false; // true if current char is escaped bool trimRight = false; // true if value string has trailing white space StringBuilder parenStringBuilder = new StringBuilder(); StringBuilder valueStringBuilder = new StringBuilder(); FrugalObjectList <IndexerParamInfo> paramList = new FrugalObjectList <IndexerParamInfo>(); IndexerState state = IndexerState.BeginParam; while (state != IndexerState.Done) { if (_index >= _n) { SetError(SRID.UnmatchedBracket, _path.Substring(start - 1)); return; } Char c = _path[_index++]; // handle the escape character - set the flag for the next character if (c == EscapeChar && !escaped) { escaped = true; continue; } switch (state) { case IndexerState.BeginParam: // look for optional (...) if (escaped) { // no '(', go parse the value state = IndexerState.ValueString; goto case IndexerState.ValueString; } else if (c == '(') { // '(' introduces optional paren string state = IndexerState.ParenString; } else if (Char.IsWhiteSpace(c)) { // ignore leading white space } else { // no '(', go parse the value state = IndexerState.ValueString; goto case IndexerState.ValueString; } break; case IndexerState.ParenString: // parse (...) if (escaped) { // add an escaped character without question parenStringBuilder.Append(c); } else if (c == ')') { // end of (...), start to parse value state = IndexerState.ValueString; } else { // add normal characters inside (...) parenStringBuilder.Append(c); } break; case IndexerState.ValueString: // parse value if (escaped) { // add an escaped character without question valueStringBuilder.Append(c); trimRight = false; } else if (level > 1) { // inside nested [], add characters without question valueStringBuilder.Append(c); trimRight = false; if (c == ']') { --level; } } else if (Char.IsWhiteSpace(c)) { // add white space, but trim it later if it's trailing valueStringBuilder.Append(c); trimRight = true; } else if (c == ',' || c == ']') { // end of current paramater - assemble the two parts string parenString = parenStringBuilder.ToString(); string valueString = valueStringBuilder.ToString(); if (trimRight) { valueString = valueString.TrimEnd(); } // add the parts to the final result paramList.Add(new IndexerParamInfo(parenString, valueString)); // reset for the next parameter parenStringBuilder.Length = 0; valueStringBuilder.Length = 0; trimRight = false; // after ',' parse next parameter; after ']' we're done state = (c == ']') ? IndexerState.Done : IndexerState.BeginParam; } else { // add normal characters valueStringBuilder.Append(c); trimRight = false; // keep track of nested [] if (c == '[') { ++level; } } break; } // after processing each character, clear the escape flag escaped = false; } // assemble the final result SourceValueInfo info = new SourceValueInfo( SourceValueType.Indexer, _drillIn, paramList); _al.Add(info); StartNewLevel(); }
// Token: 0x06007625 RID: 30245 RVA: 0x0021AC30 File Offset: 0x00218E30 public SourceValueInfo[] Parse(string path) { this._path = ((path != null) ? path.Trim() : string.Empty); this._n = this._path.Length; if (this._n == 0) { return(new SourceValueInfo[] { new SourceValueInfo(SourceValueType.Direct, DrillIn.Never, null) }); } this._index = 0; this._drillIn = DrillIn.IfNeeded; this._al.Clear(); this._error = null; this._state = PathParser.State.Init; while (this._state != PathParser.State.Done) { char c = (this._index < this._n) ? this._path[this._index] : '\0'; if (char.IsWhiteSpace(c)) { this._index++; } else { switch (this._state) { case PathParser.State.Init: if (c == '\0' || c == '.' || c == '/') { this._state = PathParser.State.DrillIn; } else { this._state = PathParser.State.Prop; } break; case PathParser.State.DrillIn: if (c <= '.') { if (c != '\0') { if (c != '.') { goto IL_13E; } this._drillIn = DrillIn.Never; this._index++; } } else if (c != '/') { if (c != '[') { goto IL_13E; } } else { this._drillIn = DrillIn.Always; this._index++; } this._state = PathParser.State.Prop; break; IL_13E: this.SetError("PathSyntax", new object[] { this._path.Substring(0, this._index), this._path.Substring(this._index) }); return(PathParser.EmptyInfo); case PathParser.State.Prop: { bool flag = false; if (c == '[') { flag = true; } if (flag) { this.AddIndexer(); } else { this.AddProperty(); } break; } } } } SourceValueInfo[] array; if (this._error == null) { array = new SourceValueInfo[this._al.Count]; this._al.CopyTo(array); } else { array = PathParser.EmptyInfo; } return(array); }
// Token: 0x06007627 RID: 30247 RVA: 0x0021AF80 File Offset: 0x00219180 private void AddIndexer() { int num = this._index + 1; this._index = num; int num2 = num; int num3 = 1; bool flag = false; bool flag2 = false; StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder2 = new StringBuilder(); FrugalObjectList <IndexerParamInfo> frugalObjectList = new FrugalObjectList <IndexerParamInfo>(); PathParser.IndexerState indexerState = PathParser.IndexerState.BeginParam; while (indexerState != PathParser.IndexerState.Done) { if (this._index >= this._n) { this.SetError("UnmatchedBracket", new object[] { this._path.Substring(num2 - 1) }); return; } string path = this._path; num = this._index; this._index = num + 1; char c = path[num]; if (c == '^' && !flag) { flag = true; } else { switch (indexerState) { case PathParser.IndexerState.BeginParam: if (flag) { indexerState = PathParser.IndexerState.ValueString; goto IL_108; } if (c == '(') { indexerState = PathParser.IndexerState.ParenString; } else if (!char.IsWhiteSpace(c)) { indexerState = PathParser.IndexerState.ValueString; goto IL_108; } break; case PathParser.IndexerState.ParenString: if (flag) { stringBuilder.Append(c); } else if (c == ')') { indexerState = PathParser.IndexerState.ValueString; } else { stringBuilder.Append(c); } break; case PathParser.IndexerState.ValueString: goto IL_108; } IL_1CC: flag = false; continue; IL_108: if (flag) { stringBuilder2.Append(c); flag2 = false; goto IL_1CC; } if (num3 > 1) { stringBuilder2.Append(c); flag2 = false; if (c == ']') { num3--; goto IL_1CC; } goto IL_1CC; } else { if (char.IsWhiteSpace(c)) { stringBuilder2.Append(c); flag2 = true; goto IL_1CC; } if (c == ',' || c == ']') { string paren = stringBuilder.ToString(); string text = stringBuilder2.ToString(); if (flag2) { text = text.TrimEnd(new char[0]); } frugalObjectList.Add(new IndexerParamInfo(paren, text)); stringBuilder.Length = 0; stringBuilder2.Length = 0; flag2 = false; indexerState = ((c == ']') ? PathParser.IndexerState.Done : PathParser.IndexerState.BeginParam); goto IL_1CC; } stringBuilder2.Append(c); flag2 = false; if (c == '[') { num3++; goto IL_1CC; } goto IL_1CC; } } } SourceValueInfo sourceValueInfo = new SourceValueInfo(SourceValueType.Indexer, this._drillIn, frugalObjectList); this._al.Add(sourceValueInfo); this.StartNewLevel(); }