void LogError(CompilerError error)
 {
     if (error.IsWarning)
         Log.LogWarning(null, error.ErrorNumber, null, error.FileName, error.Line, error.Column, 0, 0, error.ErrorText);
     else
         Log.LogError(null, error.ErrorNumber, null, error.FileName, error.Line, error.Column, 0, 0, error.ErrorText);
 }

		public CompilerError ParseLine(string line)
		{
			// try to match standard mono errors
			Match match = normalError.Match(line); 
			if (match.Success) {
				CompilerError error = new CompilerError();
				error.Column      = Int32.Parse(match.Result("${column}"));
				error.Line        = Int32.Parse(match.Result("${line}"));
				error.FileName    = Path.GetFullPath(match.Result("${file}"));
				error.IsWarning   = match.Result("${error}") == "warning";
				error.ErrorNumber = match.Result("${number}");
				error.ErrorText   = match.Result("${message}");
				return error;
			} else {
				match = generalError.Match(line);
				if (match.Success) {
					CompilerError error = new CompilerError();
					error.IsWarning   = match.Result("${error}") == "warning";
					error.ErrorNumber = match.Result("${number}");
					error.ErrorText   = match.Result("${message}");
					return error;
				}
			}
			return null;
		}

        private static void AppendError(StringBuilder message, CompilerError error, string[] lines)
        {
            message.AppendLine( error.ToString() );

            if (error.Line <= 0)
            {
                return;
            }

            var line = error.Line - 1;

            if( line - 1 > 0 )
            {
                message.AppendLine( string.Format("{0}: {1}", (line - 1).ToString( "0000", CultureInfo.CurrentUICulture ), lines[line - 1]) );
            }

            message.AppendLine( string.Format("{0}: {1}", (line - 1).ToString( "0000", CultureInfo.CurrentUICulture ), lines[line]) );

            if( line + 1 < lines.Length )
            {
                message.AppendLine( string.Format("{0}: {1}", (line + 1).ToString( "0000", CultureInfo.CurrentUICulture ), lines[line + 1]) );
            }

            message.AppendLine();
        }

		public void TaskType_CompilerErrorIsNotWarning_ReturnsError()
		{
			var error = new CompilerError();
			var task = new CompilerErrorTask(error);
			
			Assert.AreEqual(TaskType.Error, task.TaskType);
		}

 private void LogError(string fileName, string format, params object[] args)
 {
     var engineHost = (ITextTemplatingEngineHost)this.TextTemplating;
     string errorText = string.Format(CultureInfo.CurrentCulture, format, args);
     var error = new CompilerError { FileName = fileName, ErrorText = errorText };
     engineHost.LogErrors(new CompilerErrorCollection(new[] { error }));
 }

		public void Warning (string message)
		{
			var err = new CompilerError (null, -1, -1, null, message) {
				IsWarning = true,
			};
			Errors.Add (err);
		}

 public CompilerConversionTestCase(Type sourceType, Type targetType, CastFlag castFlag, string codeline = null, CompilerError compilerError = null)
 {
     this.SourceType = sourceType;
     this.TargetType = targetType;
     this.Codeline = codeline;
     this.CompilerError = compilerError;
     this.CastFlag = castFlag;
 }

        public CompilerErrorTask(CompilerError error)
            : base(GetFileName(error.FileName),
				error.ErrorText,
				error.Column,
				error.Line,
				GetTaskType(error.IsWarning))
        {
        }

		CompilerError AddError (string message)
		{
			CompilerError err = new CompilerError ();
			err.Column = err.Line = -1;
			err.ErrorText = message;
			errors.Add (err);
			return err;
		}

		public void TaskType_CompilerErrorIsWarning_ReturnsWarning()
		{
			var error = new CompilerError();
			error.IsWarning = true;
			var task = new CompilerErrorTask(error);
			
			Assert.AreEqual(TaskType.Warning, task.TaskType);
		}

 /// <devdoc>
 /// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.Compiler.CompilerErrorCollection'/>.</para>
 /// </devdoc>
 public void AddRange(CompilerError[] value) {
     if (value == null) {
         throw new ArgumentNullException("value");
     }
     for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
         this.Add(value[i]);
     }
 }

		public void Line_CompilerErrorLineIsThree_ReturnsThree()
		{
			var error = new CompilerError();
			error.FileName = "test.txt";
			error.Line = 3;
			var task = new CompilerErrorTask(error);
			
			Assert.AreEqual(3, task.Line);
		}

		public void FileName_CompilerErrorFileNameIsTestTxt_ReturnsTestTxt()
		{
			var error = new CompilerError();
			error.FileName = "test.txt";
			var task = new CompilerErrorTask(error);
			
			FileName expectedFileName = new FileName("test.txt");
			Assert.AreEqual(expectedFileName, task.FileName);
		}

 private static string FormatCompilerError(CompilerError compilerError)
 {
     return string.Format(
         "{0}, Line {1}: {2}",
         compilerError.FileName,
         compilerError.Line,
         compilerError.ErrorText
         );
 }

		public BuildError (CompilerError error)
		{
			FileName = error.FileName;
			Line = error.Line;
			Column = error.Column;
			ErrorNumber = error.ErrorNumber;
			ErrorText = error.ErrorText;
			IsWarning = error.IsWarning;
		}

 public ScriptCompilerError(CompilerError compilerError)
 {
     Column = compilerError.Column;
     ErrorNumber = compilerError.ErrorNumber;
     ErrorText = compilerError.ErrorText;
     FileName = compilerError.FileName;
     IsWarning = compilerError.IsWarning;
     Line = compilerError.Line;
 }

        public static ConvertionResult Convert(string code, AlgoType algotype, Model.File[] includeFiles)
        {
            string calgoCode = null;
            IEnumerable<ParsingError> parsingErrors = new ParsingError[0];
            var compilerErrors = new CompilerError[0];

            var codeBase = CodeBase.Mq4;
            if (CSharpCodeDetector.IsCSharpCode(code))
            {
                codeBase = CodeBase.CSharp;
            }
            else if (MqCodeBaseDetector.IsMq5Code(code))
            {
                codeBase = CodeBase.Mq5;
            }
            else if (!MqCodeBaseDetector.IsValidMq4Code(code))
            {
                codeBase = CodeBase.Invalid;
            }
            else
            {
                var parser = new Mq4Parser();

                var indicatorParsingResult = parser.Parse(code, algotype, includeFiles);
                var algo = indicatorParsingResult.Algo;
                parsingErrors = indicatorParsingResult.ParsingErrors;
                if (parsingErrors.All(e => e.ErrorType < ErrorType.Error))
                {
                    var presenter = CreatePresenter(algotype);
                    calgoCode = presenter.GenerateCodeFrom(algo);

                    var compiler = new CSharpCompiler();
                    var fileName = Path.GetTempFileName();
                    try
                    {
                        var codeToCompile = calgoCode;
                        var indexToInsert = codeToCompile.IndexOf("//Custom Indicators Place Holder");
                        foreach (var customIndicatorName in algo.CustomIndicators)
                        {
                            codeToCompile = codeToCompile.Insert(indexToInsert,
                                                                 CustomIndicatorTemplate.Replace("CustomIndicatorName",
                                                                                                 customIndicatorName));
                        }
                        compilerErrors = compiler.Compile(codeToCompile, fileName);

                        codeBase = MqCodeBaseDetector.GetCodeBaseFromErrors(compilerErrors);
                    }
                    finally
                    {
                        File.Delete(fileName);
                    }
                }
            }

            return new ConvertionResult(calgoCode, parsingErrors, compilerErrors, codeBase);
        }

		public void Column_CompilerErrorColumnIsTwo_ReturnsTwo()
		{
			var error = new CompilerError();
			error.FileName = "test.txt";
			error.Line = 1;
			error.Column = 2;
			var task = new CompilerErrorTask(error);
			
			Assert.AreEqual(2, task.Column);
		}

 public CompilerExceptionListViewItem(CompilerError ce, int imgListCount)
     : base(ce.ErrorText)
 {
     this.compilerError = ce;
     //this.ImageIndex = (imgListCount / 2) - 1;
     this.ImageIndex = (imgListCount / 2);
     this.SubItems.Add(ce.Line.ToString() );
     this.SubItems.Add(ce.Column.ToString() );
     this.SubItems.Add(ce.IsWarning.ToString() );
 }

        public void Ctor_sets_properties()
        {
            var message = "Some message";
            var errors = new CompilerError[0];

            var ex = new CompilerErrorException(message, errors);

            Assert.Equal(message, ex.Message);
            Assert.Same(errors, ex.Errors);
        }