net.sourceforge.phpeclipse/src/org/w3c/tidy/Report.java

   1 /*
   2  * @(#)Report.java   1.11 2000/08/16
   3  *
   4  */
   5
   6 package org.w3c.tidy;
   7
   8 /**
   9  *
  10  * Error/informational message reporter.
  11  *
  12  * You should only need to edit the file TidyMessages.properties
  13  * to localize HTML tidy.
  14  *
  15  * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
  16  * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
  17  * HTML Tidy Release 4 Aug 2000</a>
  18  *
  19  * @author  Dave Raggett <dsr@w3.org>
  20  * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
  21  * @version 1.0, 1999/05/22
  22  * @version 1.0.1, 1999/05/29
  23  * @version 1.1, 1999/06/18 Java Bean
  24  * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
  25  * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
  26  * @version 1.4, 1999/09/04 DOM support
  27  * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
  28  * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
  29  * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
  30  * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
  31  * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
  32  * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
  33  * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
  34  */
  35
  36 import java.io.PrintWriter;
  37 import java.text.MessageFormat;
  38 import java.util.Hashtable;
  39 import java.util.MissingResourceException;
  40 import java.util.ResourceBundle;
  41
  42 import org.eclipse.core.resources.IMarker;
  43 import org.eclipse.core.runtime.CoreException;
  44 import org.eclipse.ui.texteditor.MarkerUtilities;
  45
  46 public class Report {
  47
  48   /* used to point to Web Accessibility Guidelines */
  49   public static final String ACCESS_URL = "http://www.w3.org/WAI/GL";
  50
  51   public static final String RELEASE_DATE = "4th August 2000";
  52
  53   public static String currentFile; /* sasdjb 01May00 for GNU Emacs error parsing */
  54
  55   /* error codes for entities */
  56
  57   public static final short MISSING_SEMICOLON = 1;
  58   public static final short UNKNOWN_ENTITY = 2;
  59   public static final short UNESCAPED_AMPERSAND = 3;
  60
  61   /* error codes for element messages */
  62
  63   public static final short MISSING_ENDTAG_FOR = 1;
  64   public static final short MISSING_ENDTAG_BEFORE = 2;
  65   public static final short DISCARDING_UNEXPECTED = 3;
  66   public static final short NESTED_EMPHASIS = 4;
  67   public static final short NON_MATCHING_ENDTAG = 5;
  68   public static final short TAG_NOT_ALLOWED_IN = 6;
  69   public static final short MISSING_STARTTAG = 7;
  70   public static final short UNEXPECTED_ENDTAG = 8;
  71   public static final short USING_BR_INPLACE_OF = 9;
  72   public static final short INSERTING_TAG = 10;
  73   public static final short SUSPECTED_MISSING_QUOTE = 11;
  74   public static final short MISSING_TITLE_ELEMENT = 12;
  75   public static final short DUPLICATE_FRAMESET = 13;
  76   public static final short CANT_BE_NESTED = 14;
  77   public static final short OBSOLETE_ELEMENT = 15;
  78   public static final short PROPRIETARY_ELEMENT = 16;
  79   public static final short UNKNOWN_ELEMENT = 17;
  80   public static final short TRIM_EMPTY_ELEMENT = 18;
  81   public static final short COERCE_TO_ENDTAG = 19;
  82   public static final short ILLEGAL_NESTING = 20;
  83   public static final short NOFRAMES_CONTENT = 21;
  84   public static final short CONTENT_AFTER_BODY = 22;
  85   public static final short INCONSISTENT_VERSION = 23;
  86   public static final short MALFORMED_COMMENT = 24;
  87   public static final short BAD_COMMENT_CHARS = 25;
  88   public static final short BAD_XML_COMMENT = 26;
  89   public static final short BAD_CDATA_CONTENT = 27;
  90   public static final short INCONSISTENT_NAMESPACE = 28;
  91   public static final short DOCTYPE_AFTER_TAGS = 29;
  92   public static final short MALFORMED_DOCTYPE = 30;
  93   public static final short UNEXPECTED_END_OF_FILE = 31;
  94   public static final short DTYPE_NOT_UPPER_CASE = 32;
  95   public static final short TOO_MANY_ELEMENTS = 33;
  96
  97   /* error codes used for attribute messages */
  98
  99   public static final short UNKNOWN_ATTRIBUTE = 1;
 100   public static final short MISSING_ATTRIBUTE = 2;
 101   public static final short MISSING_ATTR_VALUE = 3;
 102   public static final short BAD_ATTRIBUTE_VALUE = 4;
 103   public static final short UNEXPECTED_GT = 5;
 104   public static final short PROPRIETARY_ATTR_VALUE = 6;
 105   public static final short REPEATED_ATTRIBUTE = 7;
 106   public static final short MISSING_IMAGEMAP = 8;
 107   public static final short XML_ATTRIBUTE_VALUE = 9;
 108   public static final short UNEXPECTED_QUOTEMARK = 10;
 109   public static final short ID_NAME_MISMATCH = 11;
 110
 111   /* accessibility flaws */
 112
 113   public static final short MISSING_IMAGE_ALT = 1;
 114   public static final short MISSING_LINK_ALT = 2;
 115   public static final short MISSING_SUMMARY = 4;
 116   public static final short MISSING_IMAGE_MAP = 8;
 117   public static final short USING_FRAMES = 16;
 118   public static final short USING_NOFRAMES = 32;
 119
 120   /* presentation flaws */
 121
 122   public static final short USING_SPACER = 1;
 123   public static final short USING_LAYER = 2;
 124   public static final short USING_NOBR = 4;
 125   public static final short USING_FONT = 8;
 126   public static final short USING_BODY = 16;
 127
 128   /* character encoding errors */
 129   public static final short WINDOWS_CHARS = 1;
 130   public static final short NON_ASCII = 2;
 131   public static final short FOUND_UTF16 = 4;
 132
 133   private static short optionerrors;
 134
 135   private static ResourceBundle res = null;
 136
 137   static {
 138     try {
 139       res = ResourceBundle.getBundle("org/w3c/tidy/TidyMessages");
 140     } catch (MissingResourceException e) {
 141       throw new Error(e.toString());
 142     }
 143   }
 144
 145   public static void tidyPrint(PrintWriter p, String msg) {
 146     p.print(msg);
 147   }
 148
 149   public static void tidyPrintln(PrintWriter p, String msg) {
 150     p.println(msg);
 151   }
 152
 153   public static void tidyPrintln(PrintWriter p) {
 154     p.println();
 155   }
 156
 157   public static void showVersion(PrintWriter p) {
 158     tidyPrintln(p, "Java HTML Tidy release date: " + RELEASE_DATE);
 159     tidyPrintln(p, "See http://www.w3.org/People/Raggett for details");
 160   }
 161
 162   public static void tag(Lexer lexer, Node tag) {
 163     if (tag != null) {
 164       if (tag.type == Node.StartTag)
 165         tidyPrint(lexer.errout, "<" + tag.element + ">");
 166       else if (tag.type == Node.EndTag)
 167         tidyPrint(lexer.errout, "</" + tag.element + ">");
 168       else if (tag.type == Node.DocTypeTag)
 169         tidyPrint(lexer.errout, "<!DOCTYPE>");
 170       else if (tag.type == Node.TextNode)
 171         tidyPrint(lexer.errout, "plain text");
 172       else
 173         tidyPrint(lexer.errout, tag.element);
 174     }
 175   }
 176
 177   public static void tag(StringBuffer errorMessage, Lexer lexer, Node tag) {
 178     if (tag != null) {
 179       if (tag.type == Node.StartTag) {
 180         tidyPrint(lexer.errout, "<" + tag.element + ">");
 181         errorMessage.append("<" + tag.element + ">");
 182       } else if (tag.type == Node.EndTag) {
 183         tidyPrint(lexer.errout, "</" + tag.element + ">");
 184         errorMessage.append("</" + tag.element + ">");
 185       } else if (tag.type == Node.DocTypeTag) {
 186         tidyPrint(lexer.errout, "<!DOCTYPE>");
 187         errorMessage.append("</" + tag.element + ">");
 188       } else if (tag.type == Node.TextNode) {
 189         tidyPrint(lexer.errout, "plain text");
 190         errorMessage.append("plain text");
 191       } else {
 192         tidyPrint(lexer.errout, tag.element);
 193         errorMessage.append(tag.element);
 194       }
 195     }
 196   }
 197
 198   /* lexer is not defined when this is called */
 199   public static void unknownOption(String option) {
 200     optionerrors++;
 201     try {
 202       System.err.println(MessageFormat.format(res.getString("unknown_option"), new Object[] { option }));
 203     } catch (MissingResourceException e) {
 204       System.err.println(e.toString());
 205     }
 206   }
 207
 208   /* lexer is not defined when this is called */
 209   public static void badArgument(String option) {
 210     optionerrors++;
 211     try {
 212       System.err.println(MessageFormat.format(res.getString("bad_argument"), new Object[] { option }));
 213     } catch (MissingResourceException e) {
 214       System.err.println(e.toString());
 215     }
 216   }
 217
 218   public static void position(Lexer lexer) {
 219     try {
 220       /* Change formatting to be parsable by GNU Emacs */
 221       if (lexer.configuration.Emacs) {
 222         tidyPrint(
 223           lexer.errout,
 224           MessageFormat.format(
 225             res.getString("emacs_format"),
 226             new Object[] { currentFile, new Integer(lexer.lines), new Integer(lexer.columns)}));
 227         tidyPrint(lexer.errout, " ");
 228       } else /* traditional format */ {
 229         tidyPrint(
 230           lexer.errout,
 231           MessageFormat.format(res.getString("line_column"), new Object[] { new Integer(lexer.lines), new Integer(lexer.columns)}));
 232       }
 233     } catch (MissingResourceException e) {
 234       lexer.errout.println(e.toString());
 235     }
 236   }
 237
 238   public static void encodingError(Lexer lexer, short code, int c) {
 239     lexer.warnings++;
 240
 241     if (lexer.configuration.ShowWarnings) {
 242       position(lexer);
 243
 244       if (code == WINDOWS_CHARS) {
 245         lexer.badChars |= WINDOWS_CHARS;
 246         try {
 247           Hashtable attributes = new Hashtable();
 248           StringBuffer errorMessage = new StringBuffer("Column " + lexer.columns + ": ");
 249           MarkerUtilities.setLineNumber(attributes, lexer.lines);
 250           tidyPrint(lexer.errout, MessageFormat.format(res.getString("illegal_char"), new Object[] { new Integer(c)}));
 251           errorMessage.append(MessageFormat.format(res.getString("illegal_char"), new Object[] { new Integer(c)}));
 252           attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 253           // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 254           // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 255           try {
 256             MarkerUtilities.setMessage(attributes, errorMessage.toString());
 257             MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 258           } catch (CoreException e) {
 259           }
 260         } catch (MissingResourceException e) {
 261           lexer.errout.println(e.toString());
 262         }
 263       }
 264
 265       tidyPrintln(lexer.errout);
 266     }
 267   }
 268
 269   public static void entityError(Lexer lexer, short code, String entity, int c) {
 270     lexer.warnings++;
 271
 272     if (lexer.configuration.ShowWarnings) {
 273       position(lexer);
 274       Hashtable attributes = new Hashtable();
 275       StringBuffer errorMessage = new StringBuffer("Column " + lexer.columns + ": ");
 276       MarkerUtilities.setLineNumber(attributes, lexer.lines);
 277
 278       if (code == MISSING_SEMICOLON) {
 279         try {
 280           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_semicolon"), new Object[] { entity }));
 281           errorMessage.append(MessageFormat.format(res.getString("missing_semicolon"), new Object[] { entity }));
 282         } catch (MissingResourceException e) {
 283           lexer.errout.println(e.toString());
 284         }
 285       } else if (code == UNKNOWN_ENTITY) {
 286         try {
 287           tidyPrint(lexer.errout, MessageFormat.format(res.getString("unknown_entity"), new Object[] { entity }));
 288           errorMessage.append(MessageFormat.format(res.getString("unknown_entity"), new Object[] { entity }));
 289         } catch (MissingResourceException e) {
 290           lexer.errout.println(e.toString());
 291         }
 292       } else if (code == UNESCAPED_AMPERSAND) {
 293         try {
 294           tidyPrint(lexer.errout, res.getString("unescaped_ampersand"));
 295           errorMessage.append(res.getString("unescaped_ampersand"));
 296         } catch (MissingResourceException e) {
 297           lexer.errout.println(e.toString());
 298         }
 299       }
 300       attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 301       // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 302       // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 303       try {
 304         MarkerUtilities.setMessage(attributes, errorMessage.toString());
 305         MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 306       } catch (CoreException e) {
 307       }
 308       tidyPrintln(lexer.errout);
 309     }
 310   }
 311
 312   public static void attrError(Lexer lexer, Node node, String attr, short code) {
 313     lexer.warnings++;
 314
 315     /* keep quiet after 6 errors */
 316     if (lexer.errors > 6)
 317       return;
 318
 319     Hashtable attributes = new Hashtable();
 320     StringBuffer errorMessage = new StringBuffer("Column " + lexer.columns + ": ");
 321
 322     if (lexer.configuration.ShowWarnings) {
 323       /* on end of file adjust reported position to end of input */
 324       if (code == UNEXPECTED_END_OF_FILE) {
 325         lexer.lines = lexer.in.curline;
 326         lexer.columns = lexer.in.curcol;
 327       }
 328
 329       position(lexer);
 330
 331       MarkerUtilities.setLineNumber(attributes, lexer.lines);
 332
 333       if (code == UNKNOWN_ATTRIBUTE) {
 334         try {
 335           tidyPrint(lexer.errout, MessageFormat.format(res.getString("unknown_attribute"), new Object[] { attr }));
 336           errorMessage.append(MessageFormat.format(res.getString("unknown_attribute"), new Object[] { attr }));
 337         } catch (MissingResourceException e) {
 338           lexer.errout.println(e.toString());
 339         }
 340       } else if (code == MISSING_ATTRIBUTE) {
 341         try {
 342           tidyPrint(lexer.errout, res.getString("warning"));
 343           errorMessage.append(res.getString("warning"));
 344           tag(errorMessage, lexer, node);
 345           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_attribute"), new Object[] { attr }));
 346           errorMessage.append(MessageFormat.format(res.getString("missing_attribute"), new Object[] { attr }));
 347         } catch (MissingResourceException e) {
 348           lexer.errout.println(e.toString());
 349         }
 350       } else if (code == MISSING_ATTR_VALUE) {
 351         try {
 352           tidyPrint(lexer.errout, res.getString("warning"));
 353           errorMessage.append(res.getString("warning"));
 354           tag(errorMessage, lexer, node);
 355           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_attr_value"), new Object[] { attr }));
 356           errorMessage.append(MessageFormat.format(res.getString("missing_attr_value"), new Object[] { attr }));
 357         } catch (MissingResourceException e) {
 358           lexer.errout.println(e.toString());
 359         }
 360       } else if (code == MISSING_IMAGEMAP) {
 361         try {
 362           tidyPrint(lexer.errout, res.getString("warning"));
 363           errorMessage.append(res.getString("warning"));
 364           tag(errorMessage, lexer, node);
 365           tidyPrint(lexer.errout, res.getString("missing_imagemap"));
 366           errorMessage.append(res.getString("missing_imagemap"));
 367         } catch (MissingResourceException e) {
 368           lexer.errout.println(e.toString());
 369         }
 370         lexer.badAccess |= MISSING_IMAGE_MAP;
 371       } else if (code == BAD_ATTRIBUTE_VALUE) {
 372         try {
 373           tidyPrint(lexer.errout, res.getString("warning"));
 374           errorMessage.append(res.getString("warning"));
 375           tag(lexer, node);
 376           tidyPrint(lexer.errout, MessageFormat.format(res.getString("bad_attribute_value"), new Object[] { attr }));
 377           errorMessage.append(MessageFormat.format(res.getString("bad_attribute_value"), new Object[] { attr }));
 378         } catch (MissingResourceException e) {
 379           lexer.errout.println(e.toString());
 380         }
 381       } else if (code == XML_ATTRIBUTE_VALUE) {
 382         try {
 383           tidyPrint(lexer.errout, res.getString("warning"));
 384           errorMessage.append(res.getString("warning"));
 385           tag(errorMessage, lexer, node);
 386           tidyPrint(lexer.errout, MessageFormat.format(res.getString("xml_attribute_value"), new Object[] { attr }));
 387           errorMessage.append(MessageFormat.format(res.getString("xml_attribute_value"), new Object[] { attr }));
 388         } catch (MissingResourceException e) {
 389           lexer.errout.println(e.toString());
 390         }
 391       } else if (code == UNEXPECTED_GT) {
 392         try {
 393           tidyPrint(lexer.errout, res.getString("error"));
 394           errorMessage.append(res.getString("error"));
 395           tag(errorMessage, lexer, node);
 396           tidyPrint(lexer.errout, res.getString("unexpected_gt"));
 397           errorMessage.append(res.getString("unexpected_gt"));
 398         } catch (MissingResourceException e) {
 399           lexer.errout.println(e.toString());
 400         }
 401         lexer.errors++;
 402         ;
 403       } else if (code == UNEXPECTED_QUOTEMARK) {
 404         try {
 405           tidyPrint(lexer.errout, res.getString("warning"));
 406           errorMessage.append(res.getString("warning"));
 407           tag(errorMessage, lexer, node);
 408           tidyPrint(lexer.errout, res.getString("unexpected_quotemark"));
 409           errorMessage.append(res.getString("unexpected_quotemark"));
 410         } catch (MissingResourceException e) {
 411           lexer.errout.println(e.toString());
 412         }
 413       } else if (code == REPEATED_ATTRIBUTE) {
 414         try {
 415           tidyPrint(lexer.errout, res.getString("warning"));
 416           errorMessage.append(res.getString("warning"));
 417           tag(errorMessage, lexer, node);
 418           tidyPrint(lexer.errout, res.getString("repeated_attribute"));
 419           errorMessage.append(res.getString("repeated_attribute"));
 420         } catch (MissingResourceException e) {
 421           lexer.errout.println(e.toString());
 422         }
 423       } else if (code == PROPRIETARY_ATTR_VALUE) {
 424         try {
 425           tidyPrint(lexer.errout, res.getString("warning"));
 426           errorMessage.append(res.getString("warning"));
 427           tag(errorMessage, lexer, node);
 428           tidyPrint(lexer.errout, MessageFormat.format(res.getString("proprietary_attr_value"), new Object[] { attr }));
 429           errorMessage.append(MessageFormat.format(res.getString("proprietary_attr_value"), new Object[] { attr }));
 430         } catch (MissingResourceException e) {
 431           lexer.errout.println(e.toString());
 432         }
 433       } else if (code == UNEXPECTED_END_OF_FILE) {
 434         try {
 435           tidyPrint(lexer.errout, res.getString("unexpected_end_of_file"));
 436           errorMessage.append(res.getString("unexpected_end_of_file"));
 437         } catch (MissingResourceException e) {
 438           lexer.errout.println(e.toString());
 439         }
 440       } else if (code == ID_NAME_MISMATCH) {
 441         try {
 442           tidyPrint(lexer.errout, res.getString("warning"));
 443           errorMessage.append(res.getString("warning"));
 444           tag(errorMessage, lexer, node);
 445           tidyPrint(lexer.errout, res.getString("id_name_mismatch"));
 446           errorMessage.append(res.getString("id_name_mismatch"));
 447         } catch (MissingResourceException e) {
 448           lexer.errout.println(e.toString());
 449         }
 450       }
 451
 452       // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 453       attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 454       // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 455       try {
 456         MarkerUtilities.setMessage(attributes, errorMessage.toString());
 457         MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 458       } catch (CoreException e) {
 459       }
 460       tidyPrintln(lexer.errout);
 461     } else if (code == UNEXPECTED_GT) {
 462       position(lexer);
 463       MarkerUtilities.setLineNumber(attributes, lexer.lines);
 464       try {
 465         tidyPrint(lexer.errout, res.getString("error"));
 466         errorMessage.append(res.getString("error"));
 467         tag(errorMessage, lexer, node);
 468         tidyPrint(lexer.errout, res.getString("unexpected_gt"));
 469         errorMessage.append(res.getString("unexpected_gt"));
 470         attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 471         // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 472         // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 473         try {
 474           MarkerUtilities.setMessage(attributes, errorMessage.toString());
 475           MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 476         } catch (CoreException e) {
 477         }
 478       } catch (MissingResourceException e) {
 479         lexer.errout.println(e.toString());
 480       }
 481       tidyPrintln(lexer.errout);
 482       lexer.errors++;
 483       ;
 484     }
 485
 486   }
 487
 488   public static void warning(Lexer lexer, Node element, Node node, short code) {
 489
 490     TagTable tt = lexer.configuration.tt;
 491
 492     lexer.warnings++;
 493
 494     /* keep quiet after 6 errors */
 495     if (lexer.errors > 6)
 496       return;
 497
 498     if (lexer.configuration.ShowWarnings) {
 499
 500       /* on end of file adjust reported position to end of input */
 501       if (code == UNEXPECTED_END_OF_FILE) {
 502         lexer.lines = lexer.in.curline;
 503         lexer.columns = lexer.in.curcol;
 504       }
 505
 506       position(lexer);
 507       Hashtable attributes = new Hashtable();
 508       StringBuffer errorMessage = new StringBuffer("Column " + lexer.columns + ": ");
 509
 510       MarkerUtilities.setLineNumber(attributes, lexer.lines);
 511
 512       if (code == MISSING_ENDTAG_FOR) {
 513         try {
 514           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_endtag_for"), new Object[] { element.element }));
 515           errorMessage.append(MessageFormat.format(res.getString("missing_endtag_for"), new Object[] { element.element }));
 516         } catch (MissingResourceException e) {
 517           lexer.errout.println(e.toString());
 518         }
 519       } else if (code == MISSING_ENDTAG_BEFORE) {
 520         try {
 521           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_endtag_before"), new Object[] { element.element }));
 522           errorMessage.append(MessageFormat.format(res.getString("missing_endtag_before"), new Object[] { element.element }));
 523
 524         } catch (MissingResourceException e) {
 525           lexer.errout.println(e.toString());
 526         }
 527         tag(errorMessage, lexer, node);
 528       } else if (code == DISCARDING_UNEXPECTED) {
 529         try {
 530           tidyPrint(lexer.errout, res.getString("discarding_unexpected"));
 531           errorMessage.append(res.getString("discarding_unexpected"));
 532         } catch (MissingResourceException e) {
 533           lexer.errout.println(e.toString());
 534         }
 535         tag(errorMessage, lexer, node);
 536       } else if (code == NESTED_EMPHASIS) {
 537         try {
 538           tidyPrint(lexer.errout, res.getString("nested_emphasis"));
 539           errorMessage.append(res.getString("nested_emphasis"));
 540         } catch (MissingResourceException e) {
 541           lexer.errout.println(e.toString());
 542         }
 543         tag(errorMessage, lexer, node);
 544       } else if (code == COERCE_TO_ENDTAG) {
 545         try {
 546           tidyPrint(lexer.errout, MessageFormat.format(res.getString("coerce_to_endtag"), new Object[] { element.element }));
 547           errorMessage.append(MessageFormat.format(res.getString("coerce_to_endtag"), new Object[] { element.element }));
 548         } catch (MissingResourceException e) {
 549           lexer.errout.println(e.toString());
 550         }
 551       } else if (code == NON_MATCHING_ENDTAG) {
 552         try {
 553           tidyPrint(lexer.errout, res.getString("non_matching_endtag_1"));
 554           errorMessage.append(res.getString("non_matching_endtag_1"));
 555         } catch (MissingResourceException e) {
 556           lexer.errout.println(e.toString());
 557         }
 558         tag(errorMessage, lexer, node);
 559         try {
 560           tidyPrint(lexer.errout, MessageFormat.format(res.getString("non_matching_endtag_2"), new Object[] { element.element }));
 561           errorMessage.append(MessageFormat.format(res.getString("non_matching_endtag_2"), new Object[] { element.element }));
 562         } catch (MissingResourceException e) {
 563           lexer.errout.println(e.toString());
 564         }
 565       } else if (code == TAG_NOT_ALLOWED_IN) {
 566         try {
 567           tidyPrint(lexer.errout, res.getString("warning"));
 568           errorMessage.append(res.getString("warning"));
 569         } catch (MissingResourceException e) {
 570           lexer.errout.println(e.toString());
 571         }
 572         tag(errorMessage, lexer, node);
 573         try {
 574           tidyPrint(lexer.errout, MessageFormat.format(res.getString("tag_not_allowed_in"), new Object[] { element.element }));
 575           errorMessage.append(MessageFormat.format(res.getString("tag_not_allowed_in"), new Object[] { element.element }));
 576         } catch (MissingResourceException e) {
 577           lexer.errout.println(e.toString());
 578         }
 579       } else if (code == DOCTYPE_AFTER_TAGS) {
 580         try {
 581           tidyPrint(lexer.errout, res.getString("doctype_after_tags"));
 582           errorMessage.append(res.getString("doctype_after_tags"));
 583         } catch (MissingResourceException e) {
 584           lexer.errout.println(e.toString());
 585         }
 586       } else if (code == MISSING_STARTTAG) {
 587         try {
 588           tidyPrint(lexer.errout, MessageFormat.format(res.getString("missing_starttag"), new Object[] { node.element }));
 589           errorMessage.append(MessageFormat.format(res.getString("missing_starttag"), new Object[] { node.element }));
 590         } catch (MissingResourceException e) {
 591           lexer.errout.println(e.toString());
 592         }
 593       } else if (code == UNEXPECTED_ENDTAG) {
 594         try {
 595           tidyPrint(lexer.errout, MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
 596           if (element != null)
 597             tidyPrint(
 598               lexer.errout,
 599               MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
 600           errorMessage.append(MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
 601         } catch (MissingResourceException e) {
 602           lexer.errout.println(e.toString());
 603         }
 604       } else if (code == TOO_MANY_ELEMENTS) {
 605         try {
 606           tidyPrint(lexer.errout, MessageFormat.format(res.getString("too_many_elements"), new Object[] { node.element }));
 607           if (element != null)
 608             tidyPrint(
 609               lexer.errout,
 610               MessageFormat.format(res.getString("too_many_elements_suffix"), new Object[] { element.element }));
 611           errorMessage.append(MessageFormat.format(res.getString("too_many_elements"), new Object[] { node.element }));
 612         } catch (MissingResourceException e) {
 613           lexer.errout.println(e.toString());
 614         }
 615       } else if (code == USING_BR_INPLACE_OF) {
 616         try {
 617           tidyPrint(lexer.errout, res.getString("using_br_inplace_of"));
 618           errorMessage.append(res.getString("using_br_inplace_of"));
 619         } catch (MissingResourceException e) {
 620           lexer.errout.println(e.toString());
 621         }
 622         tag(errorMessage, lexer, node);
 623       } else if (code == INSERTING_TAG) {
 624         try {
 625           tidyPrint(lexer.errout, MessageFormat.format(res.getString("inserting_tag"), new Object[] { node.element }));
 626           errorMessage.append(MessageFormat.format(res.getString("inserting_tag"), new Object[] { node.element }));
 627         } catch (MissingResourceException e) {
 628           lexer.errout.println(e.toString());
 629         }
 630       } else if (code == CANT_BE_NESTED) {
 631         try {
 632           tidyPrint(lexer.errout, res.getString("warning"));
 633           errorMessage.append(res.getString("warning"));
 634         } catch (MissingResourceException e) {
 635           lexer.errout.println(e.toString());
 636         }
 637         tag(errorMessage, lexer, node);
 638         try {
 639           tidyPrint(lexer.errout, res.getString("cant_be_nested"));
 640           errorMessage.append(res.getString("cant_be_nested"));
 641         } catch (MissingResourceException e) {
 642           lexer.errout.println(e.toString());
 643         }
 644       } else if (code == PROPRIETARY_ELEMENT) {
 645         try {
 646           tidyPrint(lexer.errout, res.getString("warning"));
 647           errorMessage.append(res.getString("warning"));
 648         } catch (MissingResourceException e) {
 649           lexer.errout.println(e.toString());
 650         }
 651         tag(errorMessage, lexer, node);
 652         try {
 653           tidyPrint(lexer.errout, res.getString("proprietary_element"));
 654           errorMessage.append(res.getString("proprietary_element"));
 655         } catch (MissingResourceException e) {
 656           lexer.errout.println(e.toString());
 657         }
 658
 659         if (node.tag == tt.tagLayer)
 660           lexer.badLayout |= USING_LAYER;
 661         else if (node.tag == tt.tagSpacer)
 662           lexer.badLayout |= USING_SPACER;
 663         else if (node.tag == tt.tagNobr)
 664           lexer.badLayout |= USING_NOBR;
 665       } else if (code == OBSOLETE_ELEMENT) {
 666         try {
 667           if (element.tag != null && (element.tag.model & Dict.CM_OBSOLETE) != 0) {
 668             tidyPrint(lexer.errout, res.getString("obsolete_element"));
 669             errorMessage.append(res.getString("obsolete_element"));
 670           } else {
 671             tidyPrint(lexer.errout, res.getString("replacing_element"));
 672             errorMessage.append(res.getString("replacing_element"));
 673           }
 674
 675         } catch (MissingResourceException e) {
 676           lexer.errout.println(e.toString());
 677         }
 678         tag(errorMessage, lexer, element);
 679         try {
 680           tidyPrint(lexer.errout, res.getString("by"));
 681           errorMessage.append(res.getString("by"));
 682         } catch (MissingResourceException e) {
 683           lexer.errout.println(e.toString());
 684         }
 685         tag(errorMessage, lexer, node);
 686       } else if (code == TRIM_EMPTY_ELEMENT) {
 687         try {
 688           tidyPrint(lexer.errout, res.getString("trim_empty_element"));
 689           errorMessage.append(res.getString("trim_empty_element"));
 690         } catch (MissingResourceException e) {
 691           lexer.errout.println(e.toString());
 692         }
 693         tag(errorMessage, lexer, element);
 694       } else if (code == MISSING_TITLE_ELEMENT) {
 695         try {
 696           tidyPrint(lexer.errout, res.getString("missing_title_element"));
 697           errorMessage.append(res.getString("missing_title_element"));
 698         } catch (MissingResourceException e) {
 699           lexer.errout.println(e.toString());
 700         }
 701       } else if (code == ILLEGAL_NESTING) {
 702         try {
 703           tidyPrint(lexer.errout, res.getString("warning"));
 704           errorMessage.append(res.getString("warning"));
 705         } catch (MissingResourceException e) {
 706           lexer.errout.println(e.toString());
 707         }
 708         tag(errorMessage, lexer, element);
 709         try {
 710           tidyPrint(lexer.errout, res.getString("illegal_nesting"));
 711           errorMessage.append(res.getString("illegal_nesting"));
 712         } catch (MissingResourceException e) {
 713           lexer.errout.println(e.toString());
 714         }
 715       } else if (code == NOFRAMES_CONTENT) {
 716         try {
 717           tidyPrint(lexer.errout, res.getString("warning"));
 718           errorMessage.append(res.getString("warning"));
 719         } catch (MissingResourceException e) {
 720           lexer.errout.println(e.toString());
 721         }
 722         tag(errorMessage, lexer, node);
 723         try {
 724           tidyPrint(lexer.errout, res.getString("noframes_content"));
 725           errorMessage.append(res.getString("noframes_content"));
 726         } catch (MissingResourceException e) {
 727           lexer.errout.println(e.toString());
 728         }
 729       } else if (code == INCONSISTENT_VERSION) {
 730         try {
 731           tidyPrint(lexer.errout, res.getString("inconsistent_version"));
 732           errorMessage.append(res.getString("inconsistent_version"));
 733         } catch (MissingResourceException e) {
 734           lexer.errout.println(e.toString());
 735         }
 736       } else if (code == MALFORMED_DOCTYPE) {
 737         try {
 738           tidyPrint(lexer.errout, res.getString("malformed_doctype"));
 739           errorMessage.append(res.getString("malformed_doctype"));
 740         } catch (MissingResourceException e) {
 741           lexer.errout.println(e.toString());
 742         }
 743       } else if (code == CONTENT_AFTER_BODY) {
 744         try {
 745           tidyPrint(lexer.errout, res.getString("content_after_body"));
 746           errorMessage.append(res.getString("content_after_body"));
 747         } catch (MissingResourceException e) {
 748           lexer.errout.println(e.toString());
 749         }
 750       } else if (code == MALFORMED_COMMENT) {
 751         try {
 752           tidyPrint(lexer.errout, res.getString("malformed_comment"));
 753           errorMessage.append(res.getString("malformed_comment"));
 754         } catch (MissingResourceException e) {
 755           lexer.errout.println(e.toString());
 756         }
 757       } else if (code == BAD_COMMENT_CHARS) {
 758         try {
 759           tidyPrint(lexer.errout, res.getString("bad_comment_chars"));
 760           errorMessage.append(res.getString("bad_comment_chars"));
 761         } catch (MissingResourceException e) {
 762           lexer.errout.println(e.toString());
 763         }
 764       } else if (code == BAD_XML_COMMENT) {
 765         try {
 766           tidyPrint(lexer.errout, res.getString("bad_xml_comment"));
 767           errorMessage.append(res.getString("bad_xml_comment"));
 768         } catch (MissingResourceException e) {
 769           lexer.errout.println(e.toString());
 770         }
 771       } else if (code == BAD_CDATA_CONTENT) {
 772         try {
 773           tidyPrint(lexer.errout, res.getString("bad_cdata_content"));
 774           errorMessage.append(res.getString("bad_cdata_content"));
 775         } catch (MissingResourceException e) {
 776           lexer.errout.println(e.toString());
 777         }
 778       } else if (code == INCONSISTENT_NAMESPACE) {
 779         try {
 780           tidyPrint(lexer.errout, res.getString("inconsistent_namespace"));
 781           errorMessage.append(res.getString("inconsistent_namespace"));
 782         } catch (MissingResourceException e) {
 783           lexer.errout.println(e.toString());
 784         }
 785       } else if (code == DTYPE_NOT_UPPER_CASE) {
 786         try {
 787           tidyPrint(lexer.errout, res.getString("dtype_not_upper_case"));
 788           errorMessage.append(res.getString("dtype_not_upper_case"));
 789         } catch (MissingResourceException e) {
 790           lexer.errout.println(e.toString());
 791         }
 792       } else if (code == UNEXPECTED_END_OF_FILE) {
 793         try {
 794           tidyPrint(lexer.errout, res.getString("unexpected_end_of_file"));
 795           errorMessage.append(res.getString("unexpected_end_of_file"));
 796         } catch (MissingResourceException e) {
 797           lexer.errout.println(e.toString());
 798         }
 799         tag(errorMessage, lexer, element);
 800       }
 801       //       attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 802       attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 803       //  attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 804       try {
 805         MarkerUtilities.setMessage(attributes, errorMessage.toString());
 806         MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 807       } catch (CoreException e) {
 808       }
 809       tidyPrintln(lexer.errout);
 810     }
 811   }
 812
 813   public static void error(Lexer lexer, Node element, Node node, short code) {
 814     lexer.warnings++;
 815
 816     /* keep quiet after 6 errors */
 817     if (lexer.errors > 6)
 818       return;
 819
 820     lexer.errors++;
 821
 822     position(lexer);
 823
 824     Hashtable attributes = new Hashtable();
 825     StringBuffer errorMessage = new StringBuffer("Column " + lexer.columns + ": ");
 826
 827     MarkerUtilities.setLineNumber(attributes, lexer.lines);
 828
 829     if (code == SUSPECTED_MISSING_QUOTE) {
 830       try {
 831         tidyPrint(lexer.errout, res.getString("suspected_missing_quote"));
 832         errorMessage.append(res.getString("suspected_missing_quote"));
 833
 834       } catch (MissingResourceException e) {
 835         lexer.errout.println(e.toString());
 836       }
 837     } else if (code == DUPLICATE_FRAMESET) {
 838       try {
 839         tidyPrint(lexer.errout, res.getString("duplicate_frameset"));
 840         errorMessage.append(res.getString("duplicate_frameset"));
 841       } catch (MissingResourceException e) {
 842         lexer.errout.println(e.toString());
 843       }
 844     } else if (code == UNKNOWN_ELEMENT) {
 845       try {
 846         tidyPrint(lexer.errout, res.getString("error"));
 847         errorMessage.append(res.getString("error"));
 848       } catch (MissingResourceException e) {
 849         lexer.errout.println(e.toString());
 850       }
 851       tag(errorMessage, lexer, node);
 852       try {
 853         tidyPrint(lexer.errout, res.getString("unknown_element"));
 854         errorMessage.append(res.getString("unknown_element"));
 855       } catch (MissingResourceException e) {
 856         lexer.errout.println(e.toString());
 857       }
 858     } else if (code == UNEXPECTED_ENDTAG) {
 859       try {
 860         tidyPrint(lexer.errout, MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
 861         errorMessage.append(MessageFormat.format(res.getString("unexpected_endtag"), new Object[] { node.element }));
 862         if (element != null) {
 863           tidyPrint(
 864             lexer.errout,
 865             MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
 866           errorMessage.append(MessageFormat.format(res.getString("unexpected_endtag_suffix"), new Object[] { element.element }));
 867         }
 868       } catch (MissingResourceException e) {
 869         lexer.errout.println(e.toString());
 870       }
 871     }
 872     attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
 873     // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
 874     // attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
 875     try {
 876       MarkerUtilities.setMessage(attributes, errorMessage.toString());
 877       MarkerUtilities.createMarker(lexer.getIFile(), attributes, IMarker.PROBLEM);
 878     } catch (CoreException e) {
 879     }
 880     tidyPrintln(lexer.errout);
 881   }
 882
 883   public static void errorSummary(Lexer lexer) {
 884     /* adjust badAccess to that its null if frames are ok */
 885     if ((lexer.badAccess & (USING_FRAMES | USING_NOFRAMES)) != 0) {
 886       if (!(((lexer.badAccess & USING_FRAMES) != 0) && ((lexer.badAccess & USING_NOFRAMES) == 0)))
 887         lexer.badAccess &= ~(USING_FRAMES | USING_NOFRAMES);
 888     }
 889
 890     if (lexer.badChars != 0) {
 891       if ((lexer.badChars & WINDOWS_CHARS) != 0) {
 892         try {
 893           tidyPrint(lexer.errout, res.getString("badchars_summary"));
 894         } catch (MissingResourceException e) {
 895           lexer.errout.println(e.toString());
 896         }
 897       }
 898     }
 899
 900     if (lexer.badForm != 0) {
 901       try {
 902         tidyPrint(lexer.errout, res.getString("badform_summary"));
 903       } catch (MissingResourceException e) {
 904         lexer.errout.println(e.toString());
 905       }
 906     }
 907
 908     if (lexer.badAccess != 0) {
 909       if ((lexer.badAccess & MISSING_SUMMARY) != 0) {
 910         try {
 911           tidyPrint(lexer.errout, res.getString("badaccess_missing_summary"));
 912         } catch (MissingResourceException e) {
 913           lexer.errout.println(e.toString());
 914         }
 915       }
 916
 917       if ((lexer.badAccess & MISSING_IMAGE_ALT) != 0) {
 918         try {
 919           tidyPrint(lexer.errout, res.getString("badaccess_missing_image_alt"));
 920         } catch (MissingResourceException e) {
 921           lexer.errout.println(e.toString());
 922         }
 923       }
 924
 925       if ((lexer.badAccess & MISSING_IMAGE_MAP) != 0) {
 926         try {
 927           tidyPrint(lexer.errout, res.getString("badaccess_missing_image_map"));
 928         } catch (MissingResourceException e) {
 929           lexer.errout.println(e.toString());
 930         }
 931       }
 932
 933       if ((lexer.badAccess & MISSING_LINK_ALT) != 0) {
 934         try {
 935           tidyPrint(lexer.errout, res.getString("badaccess_missing_link_alt"));
 936         } catch (MissingResourceException e) {
 937           lexer.errout.println(e.toString());
 938         }
 939       }
 940
 941       if (((lexer.badAccess & USING_FRAMES) != 0) && ((lexer.badAccess & USING_NOFRAMES) == 0)) {
 942         try {
 943           tidyPrint(lexer.errout, res.getString("badaccess_frames"));
 944         } catch (MissingResourceException e) {
 945           lexer.errout.println(e.toString());
 946         }
 947       }
 948
 949       try {
 950         tidyPrint(lexer.errout, MessageFormat.format(res.getString("badaccess_summary"), new Object[] { ACCESS_URL }));
 951       } catch (MissingResourceException e) {
 952         lexer.errout.println(e.toString());
 953       }
 954     }
 955
 956     if (lexer.badLayout != 0) {
 957       if ((lexer.badLayout & USING_LAYER) != 0) {
 958         try {
 959           tidyPrint(lexer.errout, res.getString("badlayout_using_layer"));
 960         } catch (MissingResourceException e) {
 961           lexer.errout.println(e.toString());
 962         }
 963       }
 964
 965       if ((lexer.badLayout & USING_SPACER) != 0) {
 966         try {
 967           tidyPrint(lexer.errout, res.getString("badlayout_using_spacer"));
 968         } catch (MissingResourceException e) {
 969           lexer.errout.println(e.toString());
 970         }
 971       }
 972
 973       if ((lexer.badLayout & USING_FONT) != 0) {
 974         try {
 975           tidyPrint(lexer.errout, res.getString("badlayout_using_font"));
 976         } catch (MissingResourceException e) {
 977           lexer.errout.println(e.toString());
 978         }
 979       }
 980
 981       if ((lexer.badLayout & USING_NOBR) != 0) {
 982         try {
 983           tidyPrint(lexer.errout, res.getString("badlayout_using_nobr"));
 984         } catch (MissingResourceException e) {
 985           lexer.errout.println(e.toString());
 986         }
 987       }
 988
 989       if ((lexer.badLayout & USING_BODY) != 0) {
 990         try {
 991           tidyPrint(lexer.errout, res.getString("badlayout_using_body"));
 992         } catch (MissingResourceException e) {
 993           lexer.errout.println(e.toString());
 994         }
 995       }
 996     }
 997   }
 998
 999   public static void unknownOption(PrintWriter errout, char c) {
1000     try {
1001       tidyPrintln(
1002         errout,
1003         MessageFormat.format(res.getString("unrecognized_option"), new Object[] { new String(new char[] { c })
1004       }));
1005     } catch (MissingResourceException e) {
1006       errout.println(e.toString());
1007     }
1008   }
1009
1010   public static void unknownFile(PrintWriter errout, String program, String file) {
1011     try {
1012       tidyPrintln(errout, MessageFormat.format(res.getString("unknown_file"), new Object[] { program, file }));
1013     } catch (MissingResourceException e) {
1014       errout.println(e.toString());
1015     }
1016   }
1017
1018   public static void needsAuthorIntervention(PrintWriter errout) {
1019     try {
1020       tidyPrintln(errout, res.getString("needs_author_intervention"));
1021     } catch (MissingResourceException e) {
1022       errout.println(e.toString());
1023     }
1024   }
1025
1026   public static void missingBody(PrintWriter errout) {
1027     try {
1028       tidyPrintln(errout, res.getString("missing_body"));
1029     } catch (MissingResourceException e) {
1030       errout.println(e.toString());
1031     }
1032   }
1033
1034   public static void reportNumberOfSlides(PrintWriter errout, int count) {
1035     try {
1036       tidyPrintln(errout, MessageFormat.format(res.getString("slides_found"), new Object[] { new Integer(count)}));
1037     } catch (MissingResourceException e) {
1038       errout.println(e.toString());
1039     }
1040   }
1041
1042   public static void generalInfo(PrintWriter errout) {
1043     try {
1044       tidyPrintln(errout, res.getString("general_info"));
1045     } catch (MissingResourceException e) {
1046       errout.println(e.toString());
1047     }
1048   }
1049
1050   public static void helloMessage(PrintWriter errout, String date, String filename) {
1051     currentFile = filename; /* for use with Gnu Emacs */
1052
1053     try {
1054       tidyPrintln(errout, MessageFormat.format(res.getString("hello_message"), new Object[] { date, filename }));
1055     } catch (MissingResourceException e) {
1056       errout.println(e.toString());
1057     }
1058   }
1059
1060   public static void reportVersion(PrintWriter errout, Lexer lexer, String filename, Node doctype) {
1061     int i, c;
1062     int state = 0;
1063     String vers = lexer.HTMLVersionName();
1064     MutableInteger cc = new MutableInteger();
1065
1066     try {
1067       if (doctype != null) {
1068         tidyPrint(errout, MessageFormat.format(res.getString("doctype_given"), new Object[] { filename }));
1069
1070         for (i = doctype.start; i < doctype.end; ++i) {
1071           c = (int) doctype.textarray[i];
1072
1073           /* look for UTF-8 multibyte character */
1074           if (c < 0) {
1075             i += PPrint.getUTF8(doctype.textarray, i, cc);
1076             c = cc.value;
1077           }
1078
1079           if (c == (char) '"')
1080             ++state;
1081           else if (state == 1)
1082             errout.print((char) c);
1083         }
1084
1085         errout.print('"');
1086       }
1087
1088       tidyPrintln(
1089         errout,
1090         MessageFormat.format(
1091           res.getString("report_version"),
1092           new Object[] { filename, (vers != null ? vers : "HTML proprietary")}));
1093     } catch (MissingResourceException e) {
1094       errout.println(e.toString());
1095     }
1096   }
1097
1098   public static void reportNumWarnings(PrintWriter errout, Lexer lexer) {
1099     if (lexer.warnings > 0) {
1100       try {
1101         tidyPrintln(errout, MessageFormat.format(res.getString("num_warnings"), new Object[] { new Integer(lexer.warnings)}));
1102       } catch (MissingResourceException e) {
1103         errout.println(e.toString());
1104       }
1105     } else {
1106       try {
1107         tidyPrintln(errout, res.getString("no_warnings"));
1108       } catch (MissingResourceException e) {
1109         errout.println(e.toString());
1110       }
1111     }
1112   }
1113
1114   public static void helpText(PrintWriter out, String prog) {
1115     try {
1116       tidyPrintln(out, MessageFormat.format(res.getString("help_text"), new Object[] { prog, RELEASE_DATE }));
1117     } catch (MissingResourceException e) {
1118       out.println(e.toString());
1119     }
1120   }
1121
1122   public static void badTree(PrintWriter errout) {
1123     try {
1124       tidyPrintln(errout, res.getString("bad_tree"));
1125     } catch (MissingResourceException e) {
1126       errout.println(e.toString());
1127     }
1128   }
1129
1130 }