//----------------------------------------------------------------------------- // Limits on 'As' operator //----------------------------------------------------------------------------- public static SymbolErrorException AsOpOnlyOnRefTypes( FileRange location ) { return(new SymbolErrorException(Code.cAsOpOnlyOnRefTypes, location, "The 'as' operator can only be used on reference types, not value types.")); }
public SymEntry EnsureSymbolType(SymEntry sym, System.Type tExpected, FileRange location) { if (sym == null) return null; /* Type tSym = sym.GetType(); if (tSym == tExpected) return sym; if (tSym.IsSubclassOf(tExpected)) return sym; */ bool fMatch = SymbolEngine.TypeEntry.IsAssignable(sym.GetType(), tExpected); if (fMatch) return sym; ThrowError(SymbolError.BadSymbolType(sym, tExpected, location)); /* this.ThrowError(Code.cBadSymbolType, location, "Symbol '" + sym.Name + "' must be of type '" + tExpected.ToString() + "', not '" + sym.GetType().ToString() + "'"); */ return sym; }
/// <summary> /// Constructs a web request to write a range of pages in a file from the source file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="sourceUri">A <see cref="System.Uri"/> specifying the absolute URI to the source file.</param> /// <param name="sourceFileRange">The beginning and ending source offsets.</param> /// <param name="destFileRange">The beginning and ending destination offsets.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="sourceContentChecksum">The checksum calculated for the range of bytes of the source.</param> /// <param name="sourceAccessCondition">The source access condition to apply to the request</param> /// <param name="content">The HTTP entity body and content headers.</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> /// <param name="canonicalizer">A canonicalizer that converts HTTP request data into a standard form appropriate for signing.</param> /// <param name="credentials">A <see cref="StorageCredentials"/> object providing credentials for the request.</param> /// <returns></returns> public static StorageRequestMessage PutRangeFromUrl( Uri uri, Uri sourceUri, FileRange sourceFileRange, FileRange destFileRange, int?timeout, Checksum sourceContentChecksum, AccessCondition sourceAccessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage( HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, sourceUri.AbsoluteUri); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, FileRangeWrite.Update.ToString()); request.Headers.Add(Constants.HeaderConstants.RangeHeader, destFileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.SourceRangeHeader, sourceFileRange.ToString()); request.ApplySourceContentChecksumHeaders(sourceContentChecksum); request.ApplyAccessConditionToSource(sourceAccessCondition); return(request); }
//----------------------------------------------------------------------------- // No acceptable indexer (matched by parameter types) //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableIndexer(FileRange location, System.Type [] alTypes, bool fIsLeft) { StringBuilder sb = new StringBuilder(); sb.Append("No acceptable '"); sb.Append(fIsLeft ? "get" : "set"); sb.Append("' indexer has signature: ("); bool fComma = false; foreach (Type t in alTypes) { if (fComma) { sb.Append(","); } sb.Append(t.FullName); fComma = true; } sb.Append(")."); return(new SymbolErrorException( Code.cNoAcceptableIndexer, location, sb.ToString())); }
//----------------------------------------------------------------------------- // When doing 'base.X(.....)', X must not be static. // If it was, we should have done 'T.X(.....)' //----------------------------------------------------------------------------- public static SymbolErrorException BaseAccessCantBeStatic(FileRange location, MethodExpEntry m) { return(new SymbolErrorException( Code.cBaseAccessCantBeStatic, location, "Can't access static member '" + m.PrettyDecoratedName + "' via a 'base' accessor.")); }
// No data (for practically everything else) public Token(Type type, FileRange pos) { m_filepos = pos; m_type = type; m_text = ""; }
private bool TryParseComponentPosition(string s, FileRange range, out ComponentPosition componentPosition, out string remaining) { if (s.StartsWith("_Start", StringComparison.OrdinalIgnoreCase)) { componentPosition = ComponentPosition.Start; remaining = s.Substring("_Start".Length); return(true); } else if (s.StartsWith("_Middle", StringComparison.OrdinalIgnoreCase)) { componentPosition = ComponentPosition.Middle; remaining = s.Substring("_Middle".Length); return(true); } else if (s.StartsWith("_End", StringComparison.OrdinalIgnoreCase)) { componentPosition = ComponentPosition.End; remaining = s.Substring("_End".Length); return(true); } else { _logger.Log(LogLevel.Error, range, $"Invalid point '{s}' (expected a string beginning with '_Start', '_Middle' or '_End'", null); componentPosition = ComponentPosition.Absolute; remaining = null; return(false); } }
public bool TryParse(string x, string y, FileRange xRange, FileRange yRange, out XmlComponentPoint componentPoint) { if (!TryParseComponentPosition(x, xRange, out var relativeToX, out var remainingX)) { componentPoint = null; return(false); } if (!TryParseOffsets(remainingX, OffsetAxis.X, xRange, out var xOffsets)) { componentPoint = null; return(false); } if (!TryParseComponentPosition(y, yRange, out var relativeToY, out var remainingY)) { componentPoint = null; return(false); } if (!TryParseOffsets(remainingY, OffsetAxis.Y, yRange, out var yOffsets)) { componentPoint = null; return(false); } var offsets = xOffsets.Concat(yOffsets).ToList(); componentPoint = new XmlComponentPoint(relativeToX, relativeToY, offsets); return(true); }
//----------------------------------------------------------------------------- // The specified feature is not yet implemented //----------------------------------------------------------------------------- public static SymbolErrorException NotYetImpl(FileRange location, string stHint) { return(new SymbolErrorException( Code.cNotYetImplemented, location, "'" + stHint + "' not implemented." )); }
//----------------------------------------------------------------------------- // This label is already defined //----------------------------------------------------------------------------- public static SymbolErrorException LabelAlreadyDefined(string stName, FileRange lNew, FileRange lOld) { return(new SymbolErrorException( Code.cLabelAlreadyDefined, lNew, "Label '" + stName + "' is already defined at '" + lOld + "' in the current scope")); }
// For chars public Token(Type type, char chValue, FileRange pos) { Debug.Assert(type == Type.cChar); m_filepos = pos; m_type = type; m_nValue = (int) chValue; }
// Int data (for integers) public Token(Type type, int nValue, FileRange pos) { Debug.Assert(type == Type.cInt || type == Type.cLRSquare); m_filepos = pos; m_type = type; m_nValue = nValue; }
// String data (for string literals & identifiers) public Token(Type type, string stText, FileRange pos) { Debug.Assert(type == Type.cId || type == Type.cString); m_filepos = pos; m_type = type; m_text = stText; }
//----------------------------------------------------------------------------- // The expression is not valid on the lefthand side //----------------------------------------------------------------------------- public static SymbolErrorException NotValidLHS(FileRange location) { return(new SymbolErrorException( Code.cNotValidLHS, location, "This expression is not a valid Left-Hand-Side expression" )); }
// String data (for string literals & identifiers) public Token(Type type, bool fValue, FileRange pos) { Debug.Assert(type == Type.cBool); m_filepos = pos; m_type = type; m_fValue = fValue; }
//----------------------------------------------------------------------------- // Shadow //----------------------------------------------------------------------------- public static SymbolErrorException ShadowCatchHandlers( FileRange location, System.Type tCatchType, System.Type tPrevCatchType) { return(new SymbolErrorException( Code.cShadowCatchHandlers, location, "Catch handler for type '" + tCatchType.ToString() + "' is inaccessible because of a previous handler of type '" + tPrevCatchType.ToString() + "'")); }
//----------------------------------------------------------------------------- // The method is not defined. //----------------------------------------------------------------------------- public static SymbolErrorException MethodNotDefined( FileRange location, string stFullyQualifiedName ) { return(new SymbolErrorException( Code.cMethodNotDefined, location, "The method '" + stFullyQualifiedName + "' is not defined." )); }
//----------------------------------------------------------------------------- // There is no suitable overload //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableOverload( FileRange location, string stFullyQualifiedName ) { return(new SymbolErrorException( Code.cNoAcceptableOverload, location, "No acceptable overload for '" + stFullyQualifiedName + "' exists" )); }
public virtual void EnsureAssignable( System.Type tFrom, System.Type tTo, FileRange location ) { bool fOk = TypeEntry.IsAssignable(tFrom, tTo); if (!fOk) { ThrowError(SymbolError.TypeMismatch(tFrom, tTo, location)); } }
protected FileRange CalcCurFileRange() { FileRange r = new FileRange(); r.Filename = this.m_stFilenameHint; r.ColStart = m_StartPos.col; r.RowStart = m_StartPos.row; r.ColEnd = m_col; r.RowEnd = m_row; return r; }
private bool ReportUndeclared(FileRange position, ISet <string> allUndeclared) { if (allUndeclared.Any()) { foreach (var undeclared in allUndeclared) { logger.Log(LogLevel.Error, position, $"Usage of variable not present in the enclosing 'whenDefined' attribute: ${undeclared}", null); } return(false); } return(true); }
//----------------------------------------------------------------------------- // Overload for binary & unary //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableOperator( FileRange location, System.Type tLeft, System.Type tRight, BinaryExp.BinaryOp op ) { return(new SymbolErrorException( Code.cNoAcceptableOperator, location, "No binary operator '" + op + "' that takes arguments '" + tLeft.ToString() + "' and '" + tRight.ToString() + "'.")); }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="content">The corresponding Http content.</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage PutRange(Uri uri, int?timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return(request); }
// For errors public Token(Type type, char ch1, int chPeek, FileRange pos) { Debug.Assert(type == Type.cError); m_filepos = pos; m_type = type; if (chPeek == -1 || Lexer.IsWhitespace(chPeek)) { m_text = "" + ch1; } else { m_text = "" + ch1 + (char) chPeek; } }
//----------------------------------------------------------------------------- // The methdo must be public because it is implementing an interface. //----------------------------------------------------------------------------- public static SymbolErrorException IMethodMustBePublic( FileRange location, MethodExpEntry mInterface, TypeEntry tClass ) { string stClass = tClass.FullName; string stMethod = mInterface.PrettyDecoratedName; string stInterface = mInterface.SymbolClass.FullName; return(new SymbolErrorException( Code.cIMethodMustBePublic, location, "The method '" + stMethod + "' must be public to implement interface '" + stInterface + "'")); }
//----------------------------------------------------------------------------- // Missing an method inherited from an interface //----------------------------------------------------------------------------- public static SymbolErrorException MissingInterfaceMethod( FileRange location, MethodExpEntry mInterface, TypeEntry tClass ) { string stClass = tClass.FullName; string stMethod = mInterface.PrettyDecoratedName; string stInterface = mInterface.SymbolClass.FullName; return(new SymbolErrorException( Code.cMissingInterfaceMethod, location, "The type '" + stClass + "' does not implement method '" + stMethod + "' from interface '" + stInterface + "'")); }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpWebRequest PutRange(Uri uri, int?timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { CommonUtility.AssertNotNull("fileRange", fileRange); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return(request); }
private async Task <(Stream, string)> GetStreamAsync(FileRange info, CancellationToken token) { token.ThrowIfCancellationRequested(); var request = new HttpRequestMessage { RequestUri = Target }; request.Headers.ConnectionClose = false; request.Headers.Range = info.Range; var response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token); var stream = await response.Content.ReadAsStreamAsync(token); return(stream, info.FileName); }
public static bool Parse(this IConditionParser parser, XAttribute conditionsAttribute, ComponentDescription description, IXmlLoadLogger logger, out IConditionTreeItem value) { try { value = parser.Parse(description, conditionsAttribute.Value); return(true); } catch (ConditionFormatException ex) { IXmlLineInfo line = conditionsAttribute; int startCol = line.LinePosition + conditionsAttribute.Name.LocalName.Length + 2 + ex.PositionStart; var position = new FileRange(line.LineNumber, startCol, line.LineNumber, startCol + ex.Length); logger.Log(LogLevel.Error, position, ex.Message, null); value = null; return(false); } }
public bool TryParse(string point, FileRange range, out XmlComponentPoint componentPoint) { if (!TryParseComponentPosition(point, range, out var relativeTo, out var remaining)) { componentPoint = null; return(false); } if (!TryParseOffsets(remaining, null, range, out var offsets)) { componentPoint = null; return(false); } componentPoint = new XmlComponentPoint(relativeTo, relativeTo, offsets); return(true); }
// Resolve expression as a RHS value. The exp node can totally change on us // (operator overloading, constant folding, etc), so we must pass as a ref public static void ResolveExpAsRight(ref Exp e, ISemanticResolver s) { // Debugging helper. Useful when we want to break when resolving // a particular symbol. #if false // Set lTarget to a symbol that we want to see resolved. FileRange lTarget = new FileRange("SemanticChecker.cs", 143, 39, 143, 43); if (lTarget.Equals(e.Location)) { System.Diagnostics.Debugger.Break(); } #endif e = e.ResolveExpAsRight(s); Debug.Assert(e != null); }
internal ErrorException(SymbolError.Code e, FileRange location, string stMessage) : this(ERResolve(e), location, stMessage) { }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpWebRequest PutRange(Uri uri, int? timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { CommonUtility.AssertNotNull("fileRange", fileRange); UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return request; }
public DoubleExp(double d, FileRange location) { m_filerange = location; m_dValue = d; }
public static void ContentRangeHeader(HttpWebResponse response, FileRange expectedValue) { Assert.IsNotNull(response); Assert.IsNotNull(response.Headers[HttpResponseHeader.ContentRange]); Assert.AreEqual(expectedValue.ToString(), response.Headers[HttpResponseHeader.ContentRange]); }
//----------------------------------------------------------------------------- // There is no suitable overload //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableOverload( FileRange location, string stFullyQualifiedName ) { return new SymbolErrorException( Code.cNoAcceptableOverload, location, "No acceptable overload for '" + stFullyQualifiedName + "' exists" ); }
private void PrettyPrintWarning(int iErrorNum, FileRange location, string stText) { PrettyPrint(iErrorNum, location, Severity.Warning, stText); }
//----------------------------------------------------------------------------- // No acceptable indexer (matched by parameter types) //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableIndexer(FileRange location, System.Type [] alTypes, bool fIsLeft) { StringBuilder sb = new StringBuilder(); sb.Append("No acceptable '"); sb.Append(fIsLeft ? "get" : "set"); sb.Append("' indexer has signature: ("); bool fComma = false; foreach(Type t in alTypes) { if (fComma) sb.Append(","); sb.Append(t.FullName); fComma = true; } sb.Append(")."); return new SymbolErrorException( Code.cNoAcceptableIndexer, location, sb.ToString()); }
//----------------------------------------------------------------------------- // The symbol is of the wrong type. //----------------------------------------------------------------------------- public static SymbolErrorException BadSymbolType(SymEntry sym, System.Type tExpected, FileRange location) { return new SymbolErrorException( Code.cBadSymbolType, location, "Symbol '" + sym.Name + "' must be of type '" + tExpected.ToString() + "', not '" + sym.GetType().ToString() + "'" ); }
//----------------------------------------------------------------------------- // Limits on 'As' operator //----------------------------------------------------------------------------- public static SymbolErrorException AsOpOnlyOnRefTypes( FileRange location ) { return new SymbolErrorException(Code.cAsOpOnlyOnRefTypes, location, "The 'as' operator can only be used on reference types, not value types."); }
//----------------------------------------------------------------------------- // Shadow //----------------------------------------------------------------------------- public static SymbolErrorException ShadowCatchHandlers( FileRange location, System.Type tCatchType, System.Type tPrevCatchType) { return new SymbolErrorException( Code.cShadowCatchHandlers, location, "Catch handler for type '"+ tCatchType.ToString()+ "' is inaccessible because of a previous handler of type '" + tPrevCatchType.ToString() + "'"); }
//----------------------------------------------------------------------------- // Overload for binary & unary //----------------------------------------------------------------------------- public static SymbolErrorException NoAcceptableOperator( FileRange location, System.Type tLeft, System.Type tRight, BinaryExp.BinaryOp op ) { return new SymbolErrorException( Code.cNoAcceptableOperator, location, "No binary operator '" + op + "' that takes arguments '" + tLeft.ToString() + "' and '" + tRight.ToString() + "'."); }
internal ErrorException(Blue.CodeGen.EmitCodeGen.ErrorCodes e, FileRange location, string stMessage) : this(ERCodeGen(e), location, stMessage) { }
//----------------------------------------------------------------------------- // This label is already defined //----------------------------------------------------------------------------- public static SymbolErrorException LabelAlreadyDefined(string stName, FileRange lNew, FileRange lOld) { return new SymbolErrorException( Code.cLabelAlreadyDefined, lNew, "Label '" + stName + "' is already defined at '"+ lOld + "' in the current scope"); }
// Constructor used once we've translated an error-enum into // a raw integer private ErrorException( int iCode, FileRange location, string stMessage) { m_iCode = iCode; m_location = location; m_stMessage = stMessage; // Debugging facility #if false int iBreakOnErrorCode = 0; if (iCode == iBreakOnErrorCode) { Console.WriteLine("UserBreakpoint on error code {0}", iCode); System.Diagnostics.Debugger.Break(); } #endif }
public NullExp(FileRange location) { m_filerange = location; }
private void PrettyPrint(int iErrorNum, FileRange location, Severity idxSeverity, string stText) { StringBuilder sb = new StringBuilder(); if (location != null) { sb.AppendFormat("{0}({1},{2}): {5} B{3}:{4}", location.Filename, location.RowStart, location.ColStart, iErrorNum, stText, s_arstSeverity[(int) idxSeverity]); } else { sb.AppendFormat("{0} B{1}:{2}", s_arstSeverity[(int) idxSeverity], iErrorNum, stText); } Console.WriteLine(sb.ToString()); m_arcOccurences[(int) idxSeverity]++; }
public StringExp(string s, FileRange location) { m_filerange = location; m_stValue = s; }
//----------------------------------------------------------------------------- // The method is not defined. //----------------------------------------------------------------------------- public static SymbolErrorException MethodNotDefined( FileRange location, string stFullyQualifiedName ) { return new SymbolErrorException( Code.cMethodNotDefined, location, "The method '" + stFullyQualifiedName + "' is not defined." ); }
//----------------------------------------------------------------------------- // When doing 'base.X(.....)', X must not be static. // If it was, we should have done 'T.X(.....)' //----------------------------------------------------------------------------- public static SymbolErrorException BaseAccessCantBeStatic(FileRange location, MethodExpEntry m) { return new SymbolErrorException( Code.cBaseAccessCantBeStatic, location, "Can't access static member '"+m.PrettyDecoratedName+"' via a 'base' accessor."); }
public static HttpWebRequest WriteRangeRequest(FileContext context, string shareName, string fileName, FileRange range, int length, AccessCondition accessCondition) { bool valid = FileTests.ShareNameValidator(shareName) && FileTests.FileNameValidator(fileName); Uri uri = FileTests.ConstructPutUri(context.Address, shareName, fileName); HttpWebRequest request = null; OperationContext opContext = new OperationContext(); try { request = FileHttpWebRequestFactory.PutRange(uri, context.Timeout, range, FileRangeWrite.Update, accessCondition, true, opContext); request.ContentLength = length; } catch (InvalidOperationException) { if (valid) { Assert.Fail(); } } if (valid) { Assert.IsNotNull(request); Assert.IsNotNull(request.Method); Assert.AreEqual("PUT", request.Method); FileTestUtils.RangeHeader(request, range.StartOffset, range.EndOffset); } return request; }
//----------------------------------------------------------------------------- // The methdo must be public because it is implementing an interface. //----------------------------------------------------------------------------- public static SymbolErrorException IMethodMustBePublic( FileRange location, MethodExpEntry mInterface, TypeEntry tClass ) { string stClass = tClass.FullName; string stMethod = mInterface.PrettyDecoratedName; string stInterface = mInterface.SymbolClass.FullName; return new SymbolErrorException( Code.cIMethodMustBePublic, location, "The method '" + stMethod + "' must be public to implement interface '" + stInterface + "'"); }
public IntExp(int i, FileRange location) { m_filerange = location; m_value = i; }
/// <summary> /// Constructs a web request to write or clear a range of pages in a file. /// </summary> /// <param name="uri">The absolute URI to the file.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="fileRange">The beginning and ending offsets.</param> /// <param name="fileRangeWrite">Action describing whether we are writing to a file or clearing a set of ranges.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="content">The corresponding Http content.</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static StorageRequestMessage PutRange(Uri uri, int? timeout, FileRange fileRange, FileRangeWrite fileRangeWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder builder = new UriQueryBuilder(); builder.Add(Constants.QueryConstants.Component, "range"); StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials); request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, fileRange.ToString()); request.Headers.Add(Constants.HeaderConstants.FileRangeWrite, fileRangeWrite.ToString()); request.ApplyAccessCondition(accessCondition); return request; }
public BoolExp(bool f, FileRange location) { m_filerange = location; m_fValue = f; }
// Have typesafe ctors for each error-subsystem internal ErrorException(Blue.Driver.ErrorCodes e, FileRange location, string stMessage) : this(ERGeneral(e), location, stMessage) { }
public CharExp(char ch, FileRange location) { m_filerange = location; m_chValue = ch; }
internal ErrorException(ManualParser.Parser.Code e, FileRange location, string stMessage) : this(ERParser(e), location, stMessage) { }
//----------------------------------------------------------------------------- // Missing an method inherited from an interface //----------------------------------------------------------------------------- public static SymbolErrorException MissingInterfaceMethod( FileRange location, MethodExpEntry mInterface, TypeEntry tClass ) { string stClass = tClass.FullName; string stMethod = mInterface.PrettyDecoratedName; string stInterface = mInterface.SymbolClass.FullName; return new SymbolErrorException( Code.cMissingInterfaceMethod, location, "The type '"+stClass+"' does not implement method '"+ stMethod + "' from interface '" + stInterface + "'"); }
// @dogfood - if a parameter is of type 'code', then that gets confused with // the ErrorException get_Code Property from our base class. // For now, use a fully-qualified name. But we should fix this. //internal SymbolErrorException(Code c, FileRange location, string s) : internal SymbolErrorException(SymbolError.Code c, FileRange location, string s) : base (c, location, s) { // All Symbol errors will come through this body. }