Beispiel #1
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ReportMessage"/> class.
 /// </summary>
 /// <param name="level">The type.</param>
 /// <param name="code">The error code.</param>
 /// <param name="text">The text.</param>
 /// <param name="span">The span.</param>
 public ReportMessage(ReportMessageLevel level, string code, string text, SourceSpan span)
 {
     this.Level = level;
     this.Code = code;
     this.Text = text;
     this.Span = span;
 }
Beispiel #2
0
 private static RawSourceSpan ConvertToRawLocation(SourceSpan span)
 {
     return new RawSourceSpan()
     {
         File = span.Location.FileSource,
         Line = span.Location.Line,
         EndLine = span.Location.Line,
         Column = span.Location.Column,
         EndColumn = span.Location.Column + span.Length
     };
 }
 /// <summary>
 /// Logs an Info with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 protected void Info(string message, SourceSpan span)
 {
     ParsingResult.Info(message, span);
 }
 /// <summary>
 /// Logs an Info with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 protected void Info(string message, SourceSpan span, params object[] parameters)
 {
     ParsingResult.Info(message, span, parameters);
 }
 /// <summary>
 /// Logs an Error with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 protected void Error(MessageCode message, SourceSpan span)
 {
     ParsingResult.Error(message, span);
 }
 /// <summary>
 /// Logs an Error with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 protected void Error(MessageCode message, SourceSpan span, params object[] parameters)
 {
     ParsingResult.Error(message, span, parameters);
 }
Beispiel #7
0
 /// <summary>
 /// Logs an Warning with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 public void Warning(MessageCode message, SourceSpan span, params object[] parameters)
 {
     this.AddMessage(ReportMessageLevel.Warning, message, span, parameters);
 }
 private void AddPushPopParameters(BlockStatement blockStatement, Identifier parameterType, Identifier parameterMember, Expression paramValue, SourceSpan span)
 {
     var pushStatement = new ExpressionStatement(new MethodInvocationExpression(new MemberReferenceExpression(new VariableReferenceExpression("context"), "PushParameters"), paramValue)) {Span = span};
     var popStatement = new ExpressionStatement(new MethodInvocationExpression(new MemberReferenceExpression(new VariableReferenceExpression("context"), "PopParameters"))) {Span = span};
     blockStatement.Statements.Insert(0, pushStatement);
     ;
     blockStatement.Statements.Add(popStatement);
 }
        /// <summary>
        /// Gets the type of the binary implicit conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>The implicit conversion between between to two types</returns>
        protected override TypeBase GetMultiplyImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
        {
            if (left.ResolveType() is StreamsType || right.ResolveType() is StreamsType)
                return StreamsType.Streams;

            return base.GetMultiplyImplicitConversionType(span, left, right);
        }
 public virtual TypeBase ToNonGenericType(SourceSpan? span = null)
 {
     return this;
 }
Beispiel #11
0
 /// <summary>
 /// Logs an Error with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 public void Error(MessageCode message, SourceSpan span, params object[] parameters)
 {
     this.AddMessage(ReportMessageLevel.Error, message, span, parameters);
 }
Beispiel #12
0
 /// <summary>
 /// Logs an Info with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 public void Info(MessageCode message, SourceSpan span)
 {
     this.AddMessage(ReportMessageLevel.Info, message, span);
 }
Beispiel #13
0
 /// <summary>
 /// Logs an Error with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 public void Error(MessageCode message, SourceSpan span)
 {
     this.AddMessage(ReportMessageLevel.Error, message, span);
 }
Beispiel #14
0
 /// <summary>
 /// Adds the message.
 /// </summary>
 /// <param name="level">The type.</param>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 protected void AddMessage(ReportMessageLevel level, MessageCode message, SourceSpan span, params object[] parameters)
 {
     if (level == ReportMessageLevel.Error) this.HasErrors = true;
     this.Messages.Add(new ReportMessage(level, message.Code, string.Format(message.Text, parameters), span));
 }
Beispiel #15
0
 /// <summary>
 /// Adds the message.
 /// </summary>
 /// <param name="level">The type.</param>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 protected void AddMessage(ReportMessageLevel level, MessageCode message, SourceSpan span)
 {
     if (level == ReportMessageLevel.Error) this.HasErrors = true;
     this.Messages.Add(new ReportMessage(level, message.Code, message.Text, span));
 }
 /// <summary>
 /// Logs an Warning with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 protected void Warning(MessageCode message, SourceSpan span)
 {
     ParsingResult.Warning(message, span);
 }
Beispiel #17
0
 public override TypeBase ToNonGenericType(SourceSpan? span = null)
 {
     var typeName = new TypeName();
     var name = string.Format("{0}{1}", Type.Name, Dimension);
     typeName.Name = new Identifier(name);
     if (span.HasValue)
     {
         typeName.Span = span.Value;
         typeName.Name.Span = span.Value;
     };
     typeName.TypeInference.TargetType = this;
     return typeName;
 }
 /// <summary>
 /// Logs an Warning with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 /// <param name="parameters">The parameters.</param>
 protected void Warning(MessageCode message, SourceSpan span, params object[] parameters)
 {
     ParsingResult.Warning(message, span, parameters);
 }
        /// <summary>
        /// Gets the type of the binary implicit conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param>
        /// <returns>
        /// The implicit conversion between between to two types
        /// </returns>
        protected override TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator)
        {
            if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType())
                return StreamsType.Streams;

            return base.GetBinaryImplicitConversionType(span, left, right, isBinaryOperator);
        }
        /// <summary>
        /// Gets the type of the binary implicit conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param>
        /// <returns>
        /// The implicit conversion between between to two types
        /// </returns>
        protected virtual TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator)
        {
            var result = CastHelper.GetBinaryImplicitConversionType(left, right, isBinaryOperator);

            if (result == null)
                Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right);

            return result;
        }
Beispiel #21
0
 /// <summary>
 /// Logs an Warning with the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="span">The span.</param>
 public void Warning(MessageCode message, SourceSpan span)
 {
     this.AddMessage(ReportMessageLevel.Warning, message, span);
 }
        /// <summary>
        /// Gets the type of the binary implicit conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>The implicit conversion between between to two types</returns>
        protected virtual TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
        {
            var result = CastHelper.GetDivideImplicitConversionType(left.ResolveType(), right.ResolveType());

            if (result == null)
                Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right);

            return result;
        }
        /// <summary>
        /// Gets the type of the binary implicit scalar conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The implicit conversion between the two scalar types
        /// </returns>
        protected ScalarType GetBinaryImplicitScalarConversionType(SourceSpan span, TypeBase left, TypeBase right)
        {
            var result = CastHelper.GetBinaryImplicitScalarConversionType(left, right);

            if (result == null)
                Error(MessageCode.ErrorScalarTypeConversion, span, left, right);
            return result;
        }
        /// <summary>
        /// Gets the type of the binary implicit conversion.
        /// </summary>
        /// <param name="span">The span.</param>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>The implicit conversion between between to two types</returns>
        protected override TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
        {
            if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType())
                return StreamsType.Streams;

            return base.GetDivideImplicitConversionType(span, left, right);
        }
        private static bool IsValidIndex(SourceSpan span, char valueChar, int min, int max, ParsingResult result = null)
        {
            int value;
            var isParseOk = int.TryParse(valueChar.ToString(), out value);

            if (!isParseOk || value < min || value > max)
            {
                if (result != null)
                    result.Error(MessageCode.ErrorMatrixInvalidIndex, span, valueChar, min, max);
                return false;
            }

            return true;
        }