import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private void write(PrintWriter writer, Janitor janitor, List messages, String txt) {
    if (messages==null || messages.isEmpty()) return;
    Iterator iterator = messages.iterator();
    while (iterator.hasNext()) {
        Message message = (Message) iterator.next();
        message.write(writer, janitor);
        
        if (configuration.getDebug() && (message instanceof SyntaxErrorMessage)){
            SyntaxErrorMessage sem = (SyntaxErrorMessage) message;
            sem.getCause().printStackTrace(writer);
        } 
        writer.println();
    }

    writer.print(messages.size());
    writer.print(" "+txt);
    if (messages.size()>1) writer.print("s");
    writer.println();
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
public static ScriptError fromGroovyException(MultipleCompilationErrorsException e) {
    ErrorCollector errorCollector = e.getErrorCollector();
    if (errorCollector.getErrorCount() > 0) {
        Message error = errorCollector.getError(0);
        if (error instanceof SyntaxErrorMessage) {
            SyntaxException cause = ((SyntaxErrorMessage) error).getCause();
            return new ScriptError(cause.getMessage(), cause.getStartLine(), cause.getStartColumn(),
                    cause.getEndLine(), cause.getEndColumn());
        } else {
            throw new AssertionError("SyntaxErrorMessage is expected");
        }
    } else {
        throw new AssertionError("At least one error is expected");
    }
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private void handleMalformedDependency(Expression expression) {
	Message message = createSyntaxErrorMessage(
			String.format(
					"The string must be of the form \"group:module:version\"%n"),
			expression);
	getSourceUnit().getErrorCollector().addErrorAndContinue(message);
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private void handleDuplicateDependencyManagementBomAnnotation(
		AnnotationNode annotationNode) {
	Message message = createSyntaxErrorMessage(
			"Duplicate @DependencyManagementBom annotation. It must be declared at most once.",
			annotationNode);
	getSourceUnit().getErrorCollector().addErrorAndContinue(message);
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private RuntimeException mangleMultipleCompilationErrorsException(MultipleCompilationErrorsException e, List<StringSection> sections) {
    RuntimeException result = e;

    ErrorCollector collector = e.getErrorCollector();
    @SuppressWarnings({"unchecked"})
    List<Message> errors = (List<Message>) collector.getErrors();
    if (!errors.isEmpty()) {
        Message firstMessage = errors.get(0);
        if (firstMessage instanceof SyntaxErrorMessage) {
            @SuppressWarnings({"ThrowableResultOfMethodCallIgnored"})
            SyntaxException syntaxException = ((SyntaxErrorMessage) firstMessage).getCause();
            Position errorPosition = new Position(syntaxException.getLine(), syntaxException.getStartColumn());

            //find the string section which precedes the row/col of the thrown exception
            StringSection precedingSection = findPrecedingSection(errorPosition, sections);

            //and now use the string section to mangle the line numbers so that they refer to the
            //appropriate line in the source template data
            if (precedingSection != null) {
                //if the error was thrown on the same row as where the last string section
                //ended, fix column value
                offsetPositionFromSection(errorPosition, precedingSection);
                //the below being true indicates that we had an unterminated ${ or <% sequence and
                //the column is thus meaningless, we reset it to where the %{ or <% starts to at
                //least give the user a sporting chance
                if (sections.get(sections.size() - 1) == precedingSection) {
                    errorPosition.column = precedingSection.lastSourcePosition.column;
                }

                String message = mangleExceptionMessage(e.getMessage(), errorPosition);
                result = new TemplateParseException(message, e, errorPosition.row, errorPosition.column);
            }
        }
    }

    return result;
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Adds an error to the message set, but does not cause a failure. The message is not required to have a source
 * line and column specified, but it is best practice to try and include that information. 
 */
public void addErrorAndContinue(Message message) {
    if (this.errors == null) {
        this.errors = new LinkedList();
    }

    this.errors.add(message);
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Adds a non-fatal error to the message set, which may cause a failure if the error threshold is exceeded.
 * The message is not required to have a source line and column specified, but it is best practice to try
 * and include that information.
 */
public void addError(Message message) throws CompilationFailedException {
    addErrorAndContinue(message);

    if (errors!=null && this.errors.size() >= configuration.getTolerance()) {
        failIfErrors();
    }
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Returns the specified error message, or null.
 */
public Message getError(int index) {
    if (index < getErrorCount()) {
        return (Message) this.errors.get(index);
    }
    return null;
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Convenience routine to return the specified error's
 * underlying SyntaxException, or null if it isn't one.
 */
public SyntaxException getSyntaxError(int index) {
    SyntaxException exception = null;

    Message message = getError(index);
    if (message != null && message instanceof SyntaxErrorMessage) {
        exception = ((SyntaxErrorMessage) message).getCause();
    }
    return exception;
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Convenience routine to return the specified error's
 * underlying Exception, or null if it isn't one.
 */
public Exception getException(int index) {
    Exception exception = null;

    Message message = getError(index);
    if (message != null) {
        if (message instanceof ExceptionMessage) {
            exception = ((ExceptionMessage) message).getCause();
        }
        else if (message instanceof SyntaxErrorMessage) {
            exception = ((SyntaxErrorMessage) message).getCause();
        }
    }
    return exception;
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private void writeErrorMessage(PrintWriter p, Message message) {
    if (message instanceof ExceptionMessage) {
        // Just writes the cause
        //noinspection ThrowableResultOfMethodCallIgnored
        p.format("%n- %s", ((ExceptionMessage) message).getCause().getMessage());
    }
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private Message createSyntaxErrorMessage(String message, ASTNode node) {
	return new SyntaxErrorMessage(
			new SyntaxException(message, node.getLineNumber(), node.getColumnNumber(),
					node.getLastLineNumber(), node.getLastColumnNumber()),
			getSourceUnit());
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
private void handleMalformedDependency(Expression expression) {
	Message message = createSyntaxErrorMessage(
			"The string must be of the form \"group:module:version\"\n", expression);
	getSourceUnit().getErrorCollector().addErrorAndContinue(message);
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Adds a fatal exception to the message set and throws
 * the unit as a PhaseFailedException.
 */
public void addFatalError(Message message) throws CompilationFailedException {
    addError(message);
    failIfErrors();
}
 

import org.codehaus.groovy.control.messages.Message; //导入依赖的package包/类
/**
 * Returns the last error reported
 */
public Message getLastError() {
    return (Message) this.errors.getLast();
}