/*
 * @(#)Report.java   1.11 2000/08/16
 *
 */

package net.sourceforge.phpdt.tidy.w3c;

/**
 *
 * Error/informational message reporter.
 *
 * You should only need to edit the file TidyMessages.properties
 * to localize HTML tidy.
 *
 * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
 * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
 * HTML Tidy Release 4 Aug 2000</a>
 *
 * @author  Dave Raggett <dsr@w3.org>
 * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
 * @version 1.0, 1999/05/22
 * @version 1.0.1, 1999/05/29
 * @version 1.1, 1999/06/18 Java Bean
 * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
 * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
 * @version 1.4, 1999/09/04 DOM support
 * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
 * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
 * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
 * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
 * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
 * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
 * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
 */

import java.io.PrintWriter;
import java.text.MessageFormat;
import java.util.Hashtable;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import net.sourceforge.phpdt.tidy.JTidyConsole;
import net.sourceforge.phpdt.tidy.JtidyPlugin;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.ui.texteditor.MarkerUtilities;

public class Report {

	/* used to point to Web Accessibility Guidelines */
	public static final String ACCESS_URL = "http://www.w3.org/WAI/GL";

	public static final String RELEASE_DATE = "4th August 2000";

	public static String currentFile;
	/* sasdjb 01May00 for GNU Emacs error parsing */

	/* error codes for entities */

	public static final short MISSING_SEMICOLON = 1;
	public static final short UNKNOWN_ENTITY = 2;
	public static final short UNESCAPED_AMPERSAND = 3;

	/* error codes for element messages */

	public static final short MISSING_ENDTAG_FOR = 1;
	public static final short MISSING_ENDTAG_BEFORE = 2;
	public static final short DISCARDING_UNEXPECTED = 3;
	public static final short NESTED_EMPHASIS = 4;
	public static final short NON_MATCHING_ENDTAG = 5;
	public static final short TAG_NOT_ALLOWED_IN = 6;
	public static final short MISSING_STARTTAG = 7;
	public static final short UNEXPECTED_ENDTAG = 8;
	public static final short USING_BR_INPLACE_OF = 9;
	public static final short INSERTING_TAG = 10;
	public static final short SUSPECTED_MISSING_QUOTE = 11;
	public static final short MISSING_TITLE_ELEMENT = 12;
	public static final short DUPLICATE_FRAMESET = 13;
	public static final short CANT_BE_NESTED = 14;
	public static final short OBSOLETE_ELEMENT = 15;
	public static final short PROPRIETARY_ELEMENT = 16;
	public static final short UNKNOWN_ELEMENT = 17;
	public static final short TRIM_EMPTY_ELEMENT = 18;
	public static final short COERCE_TO_ENDTAG = 19;
	public static final short ILLEGAL_NESTING = 20;
	public static final short NOFRAMES_CONTENT = 21;
	public static final short CONTENT_AFTER_BODY = 22;
	public static final short INCONSISTENT_VERSION = 23;
	public static final short MALFORMED_COMMENT = 24;
	public static final short BAD_COMMENT_CHARS = 25;
	public static final short BAD_XML_COMMENT = 26;
	public static final short BAD_CDATA_CONTENT = 27;
	public static final short INCONSISTENT_NAMESPACE = 28;
	public static final short DOCTYPE_AFTER_TAGS = 29;
	public static final short MALFORMED_DOCTYPE = 30;
	public static final short UNEXPECTED_END_OF_FILE = 31;
	public static final short DTYPE_NOT_UPPER_CASE = 32;
	public static final short TOO_MANY_ELEMENTS = 33;

	/* error codes used for attribute messages */

	public static final short UNKNOWN_ATTRIBUTE = 1;
	public static final short MISSING_ATTRIBUTE = 2;
	public static final short MISSING_ATTR_VALUE = 3;
	public static final short BAD_ATTRIBUTE_VALUE = 4;
	public static final short UNEXPECTED_GT = 5;
	public static final short PROPRIETARY_ATTR_VALUE = 6;
	public static final short REPEATED_ATTRIBUTE = 7;
	public static final short MISSING_IMAGEMAP = 8;
	public static final short XML_ATTRIBUTE_VALUE = 9;
	public static final short UNEXPECTED_QUOTEMARK = 10;
	public static final short ID_NAME_MISMATCH = 11;

	/* accessibility flaws */

	public static final short MISSING_IMAGE_ALT = 1;
	public static final short MISSING_LINK_ALT = 2;
	public static final short MISSING_SUMMARY = 4;
	public static final short MISSING_IMAGE_MAP = 8;
	public static final short USING_FRAMES = 16;
	public static final short USING_NOFRAMES = 32;

	/* presentation flaws */

	public static final short USING_SPACER = 1;
	public static final short USING_LAYER = 2;
	public static final short USING_NOBR = 4;
	public static final short USING_FONT = 8;
	public static final short USING_BODY = 16;

	/* character encoding errors */
	public static final short WINDOWS_CHARS = 1;
	public static final short NON_ASCII = 2;
	public static final short FOUND_UTF16 = 4;

	private static short optionerrors;

	private static ResourceBundle res = null;

	static {
		try { 
			res = ResourceBundle.getBundle("net/sourceforge/phpdt/tidy/w3c/TidyMessages");
		} catch (MissingResourceException e) {
			throw new Error(e.toString());
		}
	}

	//  public static void tidyPrint(PrintWriter p, String msg) {
	//    p.print(msg);
	//  }

//	public static void tidyPrint(char c) {
//		// p.println(msg);
//	//	JTidyConsole.print(new String(c));
//	}
	
	public static void tidyPrint(String msg) {
		// p.println(msg);
		JTidyConsole.print(msg);
	}

	public static void tidyPrintln(String msg) {
		// p.println(msg);
		JTidyConsole.println(msg);
	}

	public static void tidyPrintln() {
		JTidyConsole.println("");
	}

	public static void showVersion(PrintWriter p) {
		tidyPrintln("Java HTML Tidy release date: " + RELEASE_DATE);
		tidyPrintln("See http://www.w3.org/People/Raggett for details");
	}

	//  public static void tag(Lexer lexer, Node tag) {
	//    if (tag != null) {
	//      if (tag.type == Node.StartTag)
	//        tidyPrint(lexer.errout, "<" + tag.element + ">");
	//      else if (tag.type == Node.EndTag)
	//        tidyPrint(lexer.errout, "</" + tag.element + ">");
	//      else if (tag.type == Node.DocTypeTag)
	//        tidyPrint(lexer.errout, "<!DOCTYPE>");
	//      else if (tag.type == Node.TextNode)
	//        tidyPrint(lexer.errout, "plain text");
	//      else
	//        tidyPrint(lexer.errout, tag.element);
	//    }
	//  }

	public static void tag(StringBuffer errorMessage, Node tag) {
		if (tag != null) {
			if (tag.type == Node.StartTag) {
				//     tidyPrint(lexer.errout, "<" + tag.element + ">");
				errorMessage.append("<" + tag.element + ">");
			} else if (tag.type == Node.EndTag) {
				//     tidyPrint(lexer.errout, "</" + tag.element + ">");
				errorMessage.append("</" + tag.element + ">");
			} else if (tag.type == Node.DocTypeTag) {
				//     tidyPrint(lexer.errout, "<!DOCTYPE>");
				errorMessage.append("</" + tag.element + ">");
			} else if (tag.type == Node.TextNode) {
				//     tidyPrint(lexer.errout, "plain text");
				errorMessage.append("plain text");
			} else {
				//     tidyPrint(lexer.errout, tag.element);
				errorMessage.append(tag.element);
			}
		}
	}

	/* lexer is not defined when this is called */
	public static void unknownOption(String option) {
		optionerrors++;
		try {
			System.err.println(
				MessageFormat.format(
					res.getString("unknown_option"),
					new Object[] { option }));
		} catch (MissingResourceException e) {
			System.err.println(e.toString());
		}
	}

	/* lexer is not defined when this is called */
	public static void badArgument(String option) {
		optionerrors++;
		try {
			System.err.println(
				MessageFormat.format(
					res.getString("bad_argument"),
					new Object[] { option }));
		} catch (MissingResourceException e) {
			System.err.println(e.toString());
		}
	}

	//  public static void position(Lexer lexer) {
	//    try {
	//      /* Change formatting to be parsable by GNU Emacs */
	//      if (lexer.configuration.Emacs) {
	//        tidyPrint(
	//          lexer.errout,
	//          MessageFormat.format(
	//            res.getString("emacs_format"),
	//            new Object[] { currentFile, new Integer(lexer.lines), new Integer(lexer.columns)}));
	//        tidyPrint(lexer.errout, " ");
	//      } else /* traditional format */ {
	//        tidyPrint(
	//          lexer.errout,
	//          MessageFormat.format(res.getString("line_column"), new Object[] { new Integer(lexer.lines), new Integer(lexer.columns)}));
	//      }
	//    } catch (MissingResourceException e) {
	//      lexer.errout.tidyPrintln(e.toString());
	//    }
	//  }

	public static void encodingError(Lexer lexer, short code, int c) {
		lexer.warnings++;

		if (lexer.configuration.ShowWarnings) {
			//    position(lexer);

			if (code == WINDOWS_CHARS) {
				lexer.badChars |= WINDOWS_CHARS;
				try {
					Hashtable attributes = new Hashtable();
					StringBuffer errorMessage =
						new StringBuffer("Column " + lexer.columns + ": ");
					MarkerUtilities.setLineNumber(attributes, lexer.lines);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("illegal_char"), new Object[] { new Integer(c)}));
					errorMessage.append(
						MessageFormat.format(
							res.getString("illegal_char"),
							new Object[] { new Integer(c)}));
					attributes.put(
						IMarker.SEVERITY,
						new Integer(IMarker.SEVERITY_ERROR));
					attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
					// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
					// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
					try {
						MarkerUtilities.setMessage(
							attributes,
							errorMessage.toString());
						MarkerUtilities.createMarker(
							lexer.getIFile(),
							attributes,
							IMarker.PROBLEM);
					} catch (CoreException e) {
					}
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			tidyPrintln();
		}
	}

	public static void entityError(
		Lexer lexer,
		short code,
		String entity,
		int c) {
		lexer.warnings++;

		if (lexer.configuration.ShowWarnings) {
			//  position(lexer);
			Hashtable attributes = new Hashtable();
			StringBuffer errorMessage =
				new StringBuffer("Column " + lexer.columns + ": ");
			MarkerUtilities.setLineNumber(attributes, lexer.lines);

			if (code == MISSING_SEMICOLON) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_semicolon"), new Object[] { entity }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_semicolon"),
							new Object[] { entity }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNKNOWN_ENTITY) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("unknown_entity"), new Object[] { entity }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("unknown_entity"),
							new Object[] { entity }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNESCAPED_AMPERSAND) {
				try {
					// tidyPrint(lexer.errout, res.getString("unescaped_ampersand"));
					errorMessage.append(res.getString("unescaped_ampersand"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}
			attributes.put(
				IMarker.SEVERITY,
				new Integer(IMarker.SEVERITY_ERROR));
			attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
			try {
				MarkerUtilities.setMessage(attributes, errorMessage.toString());
				MarkerUtilities.createMarker(
					lexer.getIFile(),
					attributes,
					IMarker.PROBLEM);
			} catch (CoreException e) {
			}
			tidyPrintln();
		}
	}

	public static void attrError(
		Lexer lexer,
		Node node,
		String attr,
		short code) {
		lexer.warnings++;

		/* keep quiet after 6 errors */
		if (lexer.errors > 6)
			return;

		Hashtable attributes = new Hashtable();
		StringBuffer errorMessage =
			new StringBuffer("Column " + lexer.columns + ": ");

		if (lexer.configuration.ShowWarnings) {
			/* on end of file adjust reported position to end of input */
			if (code == UNEXPECTED_END_OF_FILE) {
				lexer.lines = lexer.in.curline;
				lexer.columns = lexer.in.curcol;
			}

			//  position(lexer);

			MarkerUtilities.setLineNumber(attributes, lexer.lines);

			if (code == UNKNOWN_ATTRIBUTE) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("unknown_attribute"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("unknown_attribute"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MISSING_ATTRIBUTE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_attribute"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_attribute"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MISSING_ATTR_VALUE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_attr_value"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_attr_value"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MISSING_IMAGEMAP) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, res.getString("missing_imagemap"));
					errorMessage.append(res.getString("missing_imagemap"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				lexer.badAccess |= MISSING_IMAGE_MAP;
			} else if (code == BAD_ATTRIBUTE_VALUE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("bad_attribute_value"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("bad_attribute_value"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == XML_ATTRIBUTE_VALUE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("xml_attribute_value"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("xml_attribute_value"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNEXPECTED_GT) {
				try {
					// tidyPrint(lexer.errout, res.getString("error"));
					errorMessage.append(res.getString("error"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, res.getString("unexpected_gt"));
					errorMessage.append(res.getString("unexpected_gt"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				lexer.errors++;
				;
			} else if (code == UNEXPECTED_QUOTEMARK) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, res.getString("unexpected_quotemark"));
					errorMessage.append(res.getString("unexpected_quotemark"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == REPEATED_ATTRIBUTE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, res.getString("repeated_attribute"));
					errorMessage.append(res.getString("repeated_attribute"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == PROPRIETARY_ATTR_VALUE) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("proprietary_attr_value"), new Object[] { attr }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("proprietary_attr_value"),
							new Object[] { attr }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNEXPECTED_END_OF_FILE) {
				try {
					// tidyPrint(lexer.errout, res.getString("unexpected_end_of_file"));
					errorMessage.append(
						res.getString("unexpected_end_of_file"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == ID_NAME_MISMATCH) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
					tag(errorMessage, node);
					// tidyPrint(lexer.errout, res.getString("id_name_mismatch"));
					errorMessage.append(res.getString("id_name_mismatch"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
			attributes.put(
				IMarker.SEVERITY,
				new Integer(IMarker.SEVERITY_WARNING));
			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
			attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
			try {
				MarkerUtilities.setMessage(attributes, errorMessage.toString());
				MarkerUtilities.createMarker(
					lexer.getIFile(),
					attributes,
					IMarker.PROBLEM);
			} catch (CoreException e) {
			}
			tidyPrintln();
		} else if (code == UNEXPECTED_GT) {
			//   position(lexer);
			MarkerUtilities.setLineNumber(attributes, lexer.lines);
			try {
				// tidyPrint(lexer.errout, res.getString("error"));
				errorMessage.append(res.getString("error"));
				tag(errorMessage, node);
				// tidyPrint(lexer.errout, res.getString("unexpected_gt"));
				errorMessage.append(res.getString("unexpected_gt"));
				attributes.put(
					IMarker.SEVERITY,
					new Integer(IMarker.SEVERITY_ERROR));
				// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
				// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
				attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
				try {
					MarkerUtilities.setMessage(
						attributes,
						errorMessage.toString());
					MarkerUtilities.createMarker(
						lexer.getIFile(),
						attributes,
						IMarker.PROBLEM);
				} catch (CoreException e) {
				}
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
			tidyPrintln();
			lexer.errors++;
			;
		}

	}

	public static void warning(
		Lexer lexer,
		Node element,
		Node node,
		short code) {

              
		TagTable tt = lexer.configuration.tt;

		lexer.warnings++;

		/* keep quiet after 6 errors */
		if (lexer.errors > 6)
			return;

		if (lexer.configuration.ShowWarnings) {

			/* on end of file adjust reported position to end of input */
			if (code == UNEXPECTED_END_OF_FILE) {
				lexer.lines = lexer.in.curline;
				lexer.columns = lexer.in.curcol;
			}

			//    position(lexer);
			Hashtable attributes = new Hashtable();
			StringBuffer errorMessage =
				new StringBuffer("Column " + lexer.columns + ": ");

			MarkerUtilities.setLineNumber(attributes, lexer.lines);

			if (code == MISSING_ENDTAG_FOR) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_endtag_for"), new Object[] { element.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_endtag_for"),
							new Object[] { element.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MISSING_ENDTAG_BEFORE) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_endtag_before"), new Object[] { element.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_endtag_before"),
							new Object[] { element.element }));

				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
			} else if (code == DISCARDING_UNEXPECTED) {
				//REVISIT: DIscarding... message
				//return;
				//        try {
				//          // tidyPrint(lexer.errout, res.getString("discarding_unexpected"));
				//          errorMessage.append(res.getString("discarding_unexpected"));
				//        } catch (MissingResourceException e) {
				//          tidyPrintln(e.toString());
				//        }
				//        tag(errorMessage, lexer, node);
			} else if (code == NESTED_EMPHASIS) {
				try {
					// tidyPrint(lexer.errout, res.getString("nested_emphasis"));
					errorMessage.append(res.getString("nested_emphasis"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
			} else if (code == COERCE_TO_ENDTAG) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("coerce_to_endtag"), new Object[] { element.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("coerce_to_endtag"),
							new Object[] { element.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == NON_MATCHING_ENDTAG) {
				try {
					// tidyPrint(lexer.errout, res.getString("non_matching_endtag_1"));
					errorMessage.append(res.getString("non_matching_endtag_1"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("non_matching_endtag_2"), new Object[] { element.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("non_matching_endtag_2"),
							new Object[] { element.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == TAG_NOT_ALLOWED_IN) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("tag_not_allowed_in"), new Object[] { element.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("tag_not_allowed_in"),
							new Object[] { element.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == DOCTYPE_AFTER_TAGS) {
				try {
					// tidyPrint(lexer.errout, res.getString("doctype_after_tags"));
					errorMessage.append(res.getString("doctype_after_tags"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MISSING_STARTTAG) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_starttag"), new Object[] { node.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("missing_starttag"),
							new Object[] { node.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNEXPECTED_ENDTAG) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
					if (element != null)
						//            tidyPrint(
						//              lexer.errout,
						//              MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
						errorMessage.append(
							MessageFormat.format(
								res.getString("unexpected_endtag"),
								new Object[] { node.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == TOO_MANY_ELEMENTS) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("too_many_elements"), new Object[] { node.element }));
					if (element != null)
						//            tidyPrint(
						//              lexer.errout,
						//              MessageFormat.format(res.getString("too_many_elements_suffix"), new Object[] { element.element }));
						errorMessage.append(
							MessageFormat.format(
								res.getString("too_many_elements"),
								new Object[] { node.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == USING_BR_INPLACE_OF) {
				try {
					// tidyPrint(lexer.errout, res.getString("using_br_inplace_of"));
					errorMessage.append(res.getString("using_br_inplace_of"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
			} else if (code == INSERTING_TAG) {
				try {
					// tidyPrint(lexer.errout, MessageFormat.format(res.getString("inserting_tag"), new Object[] { node.element }));
					errorMessage.append(
						MessageFormat.format(
							res.getString("inserting_tag"),
							new Object[] { node.element }));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == CANT_BE_NESTED) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
				try {
					// tidyPrint(lexer.errout, res.getString("cant_be_nested"));
					errorMessage.append(res.getString("cant_be_nested"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == PROPRIETARY_ELEMENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
				try {
					// tidyPrint(lexer.errout, res.getString("proprietary_element"));
					errorMessage.append(res.getString("proprietary_element"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}

				if (node.tag == tt.tagLayer)
					lexer.badLayout |= USING_LAYER;
				else if (node.tag == tt.tagSpacer)
					lexer.badLayout |= USING_SPACER;
				else if (node.tag == tt.tagNobr)
					lexer.badLayout |= USING_NOBR;
			} else if (code == OBSOLETE_ELEMENT) {
				try {
					if (element.tag != null
						&& (element.tag.model & Dict.CM_OBSOLETE) != 0) {
						// tidyPrint(lexer.errout, res.getString("obsolete_element"));
						errorMessage.append(res.getString("obsolete_element"));
					} else {
						// tidyPrint(lexer.errout, res.getString("replacing_element"));
						errorMessage.append(res.getString("replacing_element"));
					}

				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, element);
				try {
					// tidyPrint(lexer.errout, res.getString("by"));
					errorMessage.append(res.getString("by"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
			} else if (code == TRIM_EMPTY_ELEMENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("trim_empty_element"));
					errorMessage.append(res.getString("trim_empty_element"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, element);
			} else if (code == MISSING_TITLE_ELEMENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("missing_title_element"));
					errorMessage.append(res.getString("missing_title_element"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == ILLEGAL_NESTING) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, element);
				try {
					// tidyPrint(lexer.errout, res.getString("illegal_nesting"));
					errorMessage.append(res.getString("illegal_nesting"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == NOFRAMES_CONTENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("warning"));
					errorMessage.append(res.getString("warning"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, node);
				try {
					// tidyPrint(lexer.errout, res.getString("noframes_content"));
					errorMessage.append(res.getString("noframes_content"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == INCONSISTENT_VERSION) {
				try {
					// tidyPrint(lexer.errout, res.getString("inconsistent_version"));
					errorMessage.append(res.getString("inconsistent_version"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MALFORMED_DOCTYPE) {
				try {
					// tidyPrint(lexer.errout, res.getString("malformed_doctype"));
					errorMessage.append(res.getString("malformed_doctype"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == CONTENT_AFTER_BODY) {
				try {
					// tidyPrint(lexer.errout, res.getString("content_after_body"));
					errorMessage.append(res.getString("content_after_body"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == MALFORMED_COMMENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("malformed_comment"));
					errorMessage.append(res.getString("malformed_comment"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == BAD_COMMENT_CHARS) {
				try {
					// tidyPrint(lexer.errout, res.getString("bad_comment_chars"));
					errorMessage.append(res.getString("bad_comment_chars"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == BAD_XML_COMMENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("bad_xml_comment"));
					errorMessage.append(res.getString("bad_xml_comment"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == BAD_CDATA_CONTENT) {
				try {
					// tidyPrint(lexer.errout, res.getString("bad_cdata_content"));
					errorMessage.append(res.getString("bad_cdata_content"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == INCONSISTENT_NAMESPACE) {
				try {
					// tidyPrint(lexer.errout, res.getString("inconsistent_namespace"));
					errorMessage.append(
						res.getString("inconsistent_namespace"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == DTYPE_NOT_UPPER_CASE) {
				try {
					// tidyPrint(lexer.errout, res.getString("dtype_not_upper_case"));
					errorMessage.append(res.getString("dtype_not_upper_case"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			} else if (code == UNEXPECTED_END_OF_FILE) {
				try {
					// tidyPrint(lexer.errout, res.getString("unexpected_end_of_file"));
					errorMessage.append(
						res.getString("unexpected_end_of_file"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
				tag(errorMessage, element);
			}
			//       attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
			attributes.put(
				IMarker.SEVERITY,
				new Integer(IMarker.SEVERITY_WARNING));
			attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
			//  attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
			try {
				MarkerUtilities.setMessage(attributes, errorMessage.toString());
				MarkerUtilities.createMarker(
					lexer.getIFile(),
					attributes,
					IMarker.PROBLEM);
			} catch (CoreException e) {
			}
			tidyPrintln();
		}
	}

	public static void error(
		Lexer lexer,
		Node element,
		Node node,
		short code) {
		lexer.warnings++;

		/* keep quiet after 6 errors */
		if (lexer.errors > 6)
			return;

		lexer.errors++;

		// position(lexer);

		Hashtable attributes = new Hashtable();
		StringBuffer errorMessage =
			new StringBuffer("Column " + lexer.columns + ": ");

		MarkerUtilities.setLineNumber(attributes, lexer.lines);

		if (code == SUSPECTED_MISSING_QUOTE) {
			try {
				// tidyPrint(lexer.errout, res.getString("suspected_missing_quote"));
				errorMessage.append(res.getString("suspected_missing_quote"));

			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		} else if (code == DUPLICATE_FRAMESET) {
			try {
				// tidyPrint(lexer.errout, res.getString("duplicate_frameset"));
				errorMessage.append(res.getString("duplicate_frameset"));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		} else if (code == UNKNOWN_ELEMENT) {
			try {
				// tidyPrint(lexer.errout, res.getString("error"));
				errorMessage.append(res.getString("error"));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
			tag(errorMessage, node);
			try {
				// tidyPrint(lexer.errout, res.getString("unknown_element"));
				errorMessage.append(res.getString("unknown_element"));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		} else if (code == UNEXPECTED_ENDTAG) {
			try {
				// tidyPrint(lexer.errout, MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
				errorMessage.append(
					MessageFormat.format(
						res.getString("unexpected_endtag"),
						new Object[] { node.element }));
				if (element != null) {
					//          tidyPrint(
					//            lexer.errout,
					//            MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
					//          errorMessage.append(MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
				}
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		}
		attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
		// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
		// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
		attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
		try {
			MarkerUtilities.setMessage(attributes, errorMessage.toString());
			MarkerUtilities.createMarker(
				lexer.getIFile(),
				attributes,
				IMarker.PROBLEM);
		} catch (CoreException e) {
		}
		//   tidyPrintln(lexer.errout);
	}

	public static void errorSummary(Lexer lexer) {
		/* adjust badAccess to that its null if frames are ok */
		if ((lexer.badAccess & (USING_FRAMES | USING_NOFRAMES)) != 0) {
			if (!(((lexer.badAccess & USING_FRAMES) != 0)
				&& ((lexer.badAccess & USING_NOFRAMES) == 0)))
				lexer.badAccess &= ~(USING_FRAMES | USING_NOFRAMES);
		}

		Hashtable attributes = new Hashtable();
		StringBuffer errorMessage =
			new StringBuffer("Column " + lexer.columns + ": ");

		MarkerUtilities.setLineNumber(attributes, lexer.lines);

		if (lexer.badChars != 0) {
			if ((lexer.badChars & WINDOWS_CHARS) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badchars_summary"));
					errorMessage.append(res.getString("badchars_summary"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}
		}

		if (lexer.badForm != 0) {
			try {
				// tidyPrint(lexer.errout, res.getString("badform_summary"));
				errorMessage.append(res.getString("badform_summary"));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		}

		if (lexer.badAccess != 0) {
			if ((lexer.badAccess & MISSING_SUMMARY) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badaccess_missing_summary"));
					errorMessage.append(
						res.getString("badaccess_missing_summary"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badAccess & MISSING_IMAGE_ALT) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badaccess_missing_image_alt"));
					errorMessage.append(
						res.getString("badaccess_missing_image_alt"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badAccess & MISSING_IMAGE_MAP) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badaccess_missing_image_map"));
					errorMessage.append(
						res.getString("badaccess_missing_image_map"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badAccess & MISSING_LINK_ALT) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badaccess_missing_link_alt"));
					errorMessage.append(
						res.getString("badaccess_missing_link_alt"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if (((lexer.badAccess & USING_FRAMES) != 0)
				&& ((lexer.badAccess & USING_NOFRAMES) == 0)) {
				try {
					// tidyPrint(lexer.errout, res.getString("badaccess_frames"));
					errorMessage.append(res.getString("badaccess_frames"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			try {
				// tidyPrint(lexer.errout, MessageFormat.format(res.getString("badaccess_summary"), new Object[] { ACCESS_URL }));
				errorMessage.append(
					MessageFormat.format(
						res.getString("badaccess_summary"),
						new Object[] { ACCESS_URL }));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		}

		if (lexer.badLayout != 0) {
			if ((lexer.badLayout & USING_LAYER) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badlayout_using_layer"));
					errorMessage.append(res.getString("badlayout_using_layer"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badLayout & USING_SPACER) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badlayout_using_spacer"));
					errorMessage.append(
						res.getString("badlayout_using_spacer"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badLayout & USING_FONT) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badlayout_using_font"));
					errorMessage.append(res.getString("badlayout_using_font"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badLayout & USING_NOBR) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badlayout_using_nobr"));
					errorMessage.append(res.getString("badlayout_using_nobr"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}

			if ((lexer.badLayout & USING_BODY) != 0) {
				try {
					// tidyPrint(lexer.errout, res.getString("badlayout_using_body"));
					errorMessage.append(res.getString("badlayout_using_body"));
				} catch (MissingResourceException e) {
					tidyPrintln(e.toString());
				}
			}
			attributes.put(
				IMarker.SEVERITY,
				new Integer(IMarker.SEVERITY_ERROR));
			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
			// attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
			attributes.put(JtidyPlugin.MARKER_NAME, Boolean.TRUE);
			try {
				MarkerUtilities.setMessage(attributes, errorMessage.toString());
				MarkerUtilities.createMarker(
					lexer.getIFile(),
					attributes,
					IMarker.PROBLEM);
			} catch (CoreException e) {
			}
		}
	}

	public static void unknownOption(PrintWriter errout, char c) {
		try {
			tidyPrintln(
				MessageFormat.format(
					res.getString("unrecognized_option"),
					new Object[] { new String(new char[] { c })
			}));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void unknownFile(
		PrintWriter errout,
		String program,
		String file) {
		try {
			tidyPrintln(
				MessageFormat.format(
					res.getString("unknown_file"),
					new Object[] { program, file }));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void needsAuthorIntervention(PrintWriter errout) {
		try {
			tidyPrintln(res.getString("needs_author_intervention"));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void missingBody(PrintWriter errout) {
		try {
			tidyPrintln(res.getString("missing_body"));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void reportNumberOfSlides(PrintWriter errout, int count) {
		try {
			tidyPrintln(
				MessageFormat.format(
					res.getString("slides_found"),
					new Object[] { new Integer(count)}));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void generalInfo(PrintWriter errout) {
		try {
			tidyPrintln(res.getString("general_info"));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void helloMessage(
		PrintWriter errout,
		String date,
		String filename) {
		currentFile = filename; /* for use with Gnu Emacs */

		try {
			tidyPrintln(
				MessageFormat.format(
					res.getString("hello_message"),
					new Object[] { date, filename }));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void reportVersion(
		PrintWriter errout,
		Lexer lexer,
		String filename,
		Node doctype) {
		int i, c;
		int state = 0;
		String vers = lexer.HTMLVersionName();
		MutableInteger cc = new MutableInteger();

		try {
			if (doctype != null) {
				tidyPrint(
					MessageFormat.format(
						res.getString("doctype_given"),
						new Object[] { filename }));
                StringBuffer buf = new StringBuffer();
				for (i = doctype.start; i < doctype.end; ++i) {
					c = (int) doctype.textarray[i];

					/* look for UTF-8 multibyte character */
					if (c < 0) {
						i += PPrint.getUTF8(doctype.textarray, i, cc);
						c = cc.value;
					}

					if (c == (char) '"')
						++state;
					else if (state == 1) {
						buf.append(c);
					// tidyPrint((char) c);
					}
				}

			//	tidyPrint('"');
				buf.append('"');
				tidyPrint( buf.toString() );
			}

			tidyPrintln(
				MessageFormat.format(
					res.getString("report_version"),
					new Object[] {
						filename,
						(vers != null ? vers : "HTML proprietary")}));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void reportNumWarnings(PrintWriter errout, Lexer lexer) {
		if (lexer.warnings > 0) {
			try {
				tidyPrintln(
					MessageFormat.format(
						res.getString("num_warnings"),
						new Object[] { new Integer(lexer.warnings)}));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		} else {
			try {
				tidyPrintln(res.getString("no_warnings"));
			} catch (MissingResourceException e) {
				tidyPrintln(e.toString());
			}
		}
	}

	public static void helpText(PrintWriter out, String prog) {
		try {
			tidyPrintln(
				MessageFormat.format(
					res.getString("help_text"),
					new Object[] { prog, RELEASE_DATE }));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

	public static void badTree(PrintWriter errout) {
		try {
			tidyPrintln(res.getString("bad_tree"));
		} catch (MissingResourceException e) {
			tidyPrintln(e.toString());
		}
	}

}