archive/net.sourceforge.phpeclipse.jtidy/src/net/sourceforge/phpdt/tidy/w3c/Tidy.java

   1 /*
   2  * @(#)Tidy.java   1.11 2000/08/16
   3  *
   4  */
   5
   6 /*
   7   HTML parser and pretty printer
   8
   9   Copyright (c) 1998-2000 World Wide Web Consortium (Massachusetts
  10   Institute of Technology, Institut National de Recherche en
  11   Informatique et en Automatique, Keio University). All Rights
  12   Reserved.
  13
  14   Contributing Author(s):
  15
  16      Dave Raggett <dsr@w3.org>
  17      Andy Quick <ac.quick@sympatico.ca> (translation to Java)
  18
  19   The contributing author(s) would like to thank all those who
  20   helped with testing, bug fixes, and patience.  This wouldn't
  21   have been possible without all of you.
  22
  23   COPYRIGHT NOTICE:
  24
  25   This software and documentation is provided "as is," and
  26   the copyright holders and contributing author(s) make no
  27   representations or warranties, express or implied, including
  28   but not limited to, warranties of merchantability or fitness
  29   for any particular purpose or that the use of the software or
  30   documentation will not infringe any third party patents,
  31   copyrights, trademarks or other rights.
  32
  33   The copyright holders and contributing author(s) will not be
  34   liable for any direct, indirect, special or consequential damages
  35   arising out of any use of the software or documentation, even if
  36   advised of the possibility of such damage.
  37
  38   Permission is hereby granted to use, copy, modify, and distribute
  39   this source code, or portions hereof, documentation and executables,
  40   for any purpose, without fee, subject to the following restrictions:
  41
  42   1. The origin of this source code must not be misrepresented.
  43   2. Altered versions must be plainly marked as such and must
  44      not be misrepresented as being the original source.
  45   3. This Copyright notice may not be removed or altered from any
  46      source or altered source distribution.
  47
  48   The copyright holders and contributing author(s) specifically
  49   permit, without fee, and encourage the use of this source code
  50   as a component for supporting the Hypertext Markup Language in
  51   commercial products. If you use this source code in a product,
  52   acknowledgment is not required but would be appreciated.
  53 */
  54
  55 package net.sourceforge.phpdt.tidy.w3c;
  56
  57 import java.io.FileInputStream;
  58 import java.io.FileNotFoundException;
  59 import java.io.FileOutputStream;
  60 import java.io.FileWriter;
  61 import java.io.IOException;
  62 import java.io.InputStream;
  63 import java.io.OutputStream;
  64 import java.io.PrintWriter;
  65 import java.util.Properties;
  66
  67 import org.eclipse.core.resources.IFile;
  68
  69 /**
  70  *
  71  * <p>HTML parser and pretty printer</p>
  72  *
  73  * <p>
  74  * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
  75  * See Tidy.java for the copyright notice.
  76  * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
  77  * HTML Tidy Release 4 Aug 2000</a>
  78  * </p>
  79  *
  80  * <p>
  81  * Copyright (c) 1998-2000 World Wide Web Consortium (Massachusetts
  82  * Institute of Technology, Institut National de Recherche en
  83  * Informatique et en Automatique, Keio University). All Rights
  84  * Reserved.
  85  * </p>
  86  *
  87  * <p>
  88  * Contributing Author(s):<br>
  89  *    <a href="mailto:dsr@w3.org">Dave Raggett</a><br>
  90  *    <a href="mailto:ac.quick@sympatico.ca">Andy Quick</a> (translation to Java)
  91  * </p>
  92  *
  93  * <p>
  94  * The contributing author(s) would like to thank all those who
  95  * helped with testing, bug fixes, and patience.  This wouldn't
  96  * have been possible without all of you.
  97  * </p>
  98  *
  99  * <p>
 100  * COPYRIGHT NOTICE:<br>
 101  *
 102  * This software and documentation is provided "as is," and
 103  * the copyright holders and contributing author(s) make no
 104  * representations or warranties, express or implied, including
 105  * but not limited to, warranties of merchantability or fitness
 106  * for any particular purpose or that the use of the software or
 107  * documentation will not infringe any third party patents,
 108  * copyrights, trademarks or other rights.
 109  * </p>
 110  *
 111  * <p>
 112  * The copyright holders and contributing author(s) will not be
 113  * liable for any direct, indirect, special or consequential damages
 114  * arising out of any use of the software or documentation, even if
 115  * advised of the possibility of such damage.
 116  * </p>
 117  *
 118  * <p>
 119  * Permission is hereby granted to use, copy, modify, and distribute
 120  * this source code, or portions hereof, documentation and executables,
 121  * for any purpose, without fee, subject to the following restrictions:
 122  * </p>
 123  *
 124  * <p>
 125  * <ol>
 126  * <li>The origin of this source code must not be misrepresented.</li>
 127  * <li>Altered versions must be plainly marked as such and must
 128  * not be misrepresented as being the original source.</li>
 129  * <li>This Copyright notice may not be removed or altered from any
 130  * source or altered source distribution.</li>
 131  * </ol>
 132  * </p>
 133  *
 134  * <p>
 135  * The copyright holders and contributing author(s) specifically
 136  * permit, without fee, and encourage the use of this source code
 137  * as a component for supporting the Hypertext Markup Language in
 138  * commercial products. If you use this source code in a product,
 139  * acknowledgment is not required but would be appreciated.
 140  * </p>
 141  *
 142  * @author  Dave Raggett <dsr@w3.org>
 143  * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
 144  * @version 1.0, 1999/05/22
 145  * @version 1.0.1, 1999/05/29
 146  * @version 1.1, 1999/06/18 Java Bean
 147  * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
 148  * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
 149  * @version 1.4, 1999/09/04 DOM support
 150  * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
 151  * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
 152  * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
 153  * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
 154  * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
 155  * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
 156  * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
 157  *
 158  */
 159
 160 public class Tidy implements java.io.Serializable {
 161
 162         static final long serialVersionUID = -2794371560623987718L;
 163
 164         private boolean initialized = false;
 165         private PrintWriter errout = null; /* error output stream */
 166         private PrintWriter stderr = null;
 167         private Configuration configuration = null;
 168         private String inputStreamName = "InputStream";
 169         private int parseErrors = 0;
 170         private int parseWarnings = 0;
 171
 172         public Tidy() {
 173                 init();
 174         }
 175
 176         public Configuration getConfiguration() {
 177                 return configuration;
 178         }
 179
 180         public PrintWriter getStderr() {
 181                 return stderr;
 182         }
 183
 184         /**
 185          * ParseErrors - the number of errors that occurred in the most
 186          * recent parse operation
 187          */
 188
 189         public int getParseErrors() {
 190                 return parseErrors;
 191         }
 192
 193         /**
 194          * ParseWarnings - the number of warnings that occurred in the most
 195          * recent parse operation
 196          */
 197
 198         public int getParseWarnings() {
 199                 return parseWarnings;
 200         }
 201
 202         /**
 203          * Errout - the error output stream
 204          */
 205
 206         public PrintWriter getErrout() {
 207                 return errout;
 208         }
 209
 210         public void setErrout(PrintWriter errout) {
 211                 this.errout = errout;
 212         }
 213
 214         /**
 215          * Spaces - default indentation
 216          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#spaces
 217          */
 218
 219         public void setSpaces(int spaces) {
 220                 configuration.spaces = spaces;
 221         }
 222
 223         public int getSpaces() {
 224                 return configuration.spaces;
 225         }
 226
 227         /**
 228          * Wraplen - default wrap margin
 229          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#wraplen
 230          */
 231
 232         public void setWraplen(int wraplen) {
 233                 configuration.wraplen = wraplen;
 234         }
 235
 236         public int getWraplen() {
 237                 return configuration.wraplen;
 238         }
 239
 240         /**
 241          * CharEncoding
 242          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#CharEncoding
 243          */
 244
 245         public void setCharEncoding(int charencoding) {
 246                 configuration.CharEncoding = charencoding;
 247         }
 248
 249         public int getCharEncoding() {
 250                 return configuration.CharEncoding;
 251         }
 252
 253         /**
 254          * Tabsize
 255          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#tabsize
 256          */
 257
 258         public void setTabsize(int tabsize) {
 259                 configuration.tabsize = tabsize;
 260         }
 261
 262         public int getTabsize() {
 263                 return configuration.tabsize;
 264         }
 265
 266         /**
 267          * Errfile - file name to write errors to
 268          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#errfile
 269          */
 270
 271         public void setErrfile(String errfile) {
 272                 configuration.errfile = errfile;
 273         }
 274
 275         public String getErrfile() {
 276                 return configuration.errfile;
 277         }
 278
 279         /**
 280          * Writeback - if true then output tidied markup
 281          * NOTE: this property is ignored when parsing from an InputStream.
 282          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#writeback
 283          */
 284
 285         public void setWriteback(boolean writeback) {
 286                 configuration.writeback = writeback;
 287         }
 288
 289         public boolean getWriteback() {
 290                 return configuration.writeback;
 291         }
 292
 293         /**
 294          * OnlyErrors - if true normal output is suppressed
 295          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#OnlyErrors
 296          */
 297
 298         public void setOnlyErrors(boolean OnlyErrors) {
 299                 configuration.OnlyErrors = OnlyErrors;
 300         }
 301
 302         public boolean getOnlyErrors() {
 303                 return configuration.OnlyErrors;
 304         }
 305
 306         /**
 307          * ShowWarnings - however errors are always shown
 308          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#ShowWarnings
 309          */
 310
 311         public void setShowWarnings(boolean ShowWarnings) {
 312                 configuration.ShowWarnings = ShowWarnings;
 313         }
 314
 315         public boolean getShowWarnings() {
 316                 return configuration.ShowWarnings;
 317         }
 318
 319         /**
 320          * Quiet - no 'Parsing X', guessed DTD or summary
 321          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#Quiet
 322          */
 323
 324         public void setQuiet(boolean Quiet) {
 325                 configuration.Quiet = Quiet;
 326         }
 327
 328         public boolean getQuiet() {
 329                 return configuration.Quiet;
 330         }
 331
 332         /**
 333          * IndentContent - indent content of appropriate tags
 334          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#IndentContent
 335          */
 336
 337         public void setIndentContent(boolean IndentContent) {
 338                 configuration.IndentContent = IndentContent;
 339         }
 340
 341         public boolean getIndentContent() {
 342                 return configuration.IndentContent;
 343         }
 344
 345         /**
 346          * SmartIndent - does text/block level content effect indentation
 347          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#SmartIndent
 348          */
 349
 350         public void setSmartIndent(boolean SmartIndent) {
 351                 configuration.SmartIndent = SmartIndent;
 352         }
 353
 354         public boolean getSmartIndent() {
 355                 return configuration.SmartIndent;
 356         }
 357
 358         /**
 359          * HideEndTags - suppress optional end tags
 360          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#HideEndTags
 361          */
 362
 363         public void setHideEndTags(boolean HideEndTags) {
 364                 configuration.HideEndTags = HideEndTags;
 365         }
 366
 367         public boolean getHideEndTags() {
 368                 return configuration.HideEndTags;
 369         }
 370
 371         /**
 372          * XmlTags - treat input as XML
 373          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#XmlTags
 374          */
 375
 376         public void setXmlTags(boolean XmlTags) {
 377                 configuration.XmlTags = XmlTags;
 378         }
 379
 380         public boolean getXmlTags() {
 381                 return configuration.XmlTags;
 382         }
 383
 384         /**
 385          * XmlOut - create output as XML
 386          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#XmlOut
 387          */
 388
 389         public void setXmlOut(boolean XmlOut) {
 390                 configuration.XmlOut = XmlOut;
 391         }
 392
 393         public boolean getXmlOut() {
 394                 return configuration.XmlOut;
 395         }
 396
 397         /**
 398          * XHTML - output extensible HTML
 399          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#xHTML
 400          */
 401
 402         public void setXHTML(boolean xHTML) {
 403                 configuration.xHTML = xHTML;
 404         }
 405
 406         public boolean getXHTML() {
 407                 return configuration.xHTML;
 408         }
 409
 410         /**
 411          * RawOut - avoid mapping values > 127 to entities
 412          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#RawOut
 413          */
 414
 415         public void setRawOut(boolean RawOut) {
 416                 configuration.RawOut = RawOut;
 417         }
 418
 419         public boolean getRawOut() {
 420                 return configuration.RawOut;
 421         }
 422
 423         /**
 424          * UpperCaseTags - output tags in upper not lower case
 425          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#UpperCaseTags
 426          */
 427
 428         public void setUpperCaseTags(boolean UpperCaseTags) {
 429                 configuration.UpperCaseTags = UpperCaseTags;
 430         }
 431
 432         public boolean getUpperCaseTags() {
 433                 return configuration.UpperCaseTags;
 434         }
 435
 436         /**
 437          * UpperCaseAttrs - output attributes in upper not lower case
 438          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#UpperCaseAttrs
 439          */
 440
 441         public void setUpperCaseAttrs(boolean UpperCaseAttrs) {
 442                 configuration.UpperCaseAttrs = UpperCaseAttrs;
 443         }
 444
 445         public boolean getUpperCaseAttrs() {
 446                 return configuration.UpperCaseAttrs;
 447         }
 448
 449         /**
 450          * MakeClean - remove presentational clutter
 451          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#MakeClean
 452          */
 453
 454         public void setMakeClean(boolean MakeClean) {
 455                 configuration.MakeClean = MakeClean;
 456         }
 457
 458         public boolean getMakeClean() {
 459                 return configuration.MakeClean;
 460         }
 461
 462         /**
 463          * BreakBeforeBR - o/p newline before &lt;br&gt; or not?
 464          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#BreakBeforeBR
 465          */
 466
 467         public void setBreakBeforeBR(boolean BreakBeforeBR) {
 468                 configuration.BreakBeforeBR = BreakBeforeBR;
 469         }
 470
 471         public boolean getBreakBeforeBR() {
 472                 return configuration.BreakBeforeBR;
 473         }
 474
 475         /**
 476          * BurstSlides - create slides on each h2 element
 477          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#BurstSlides
 478          */
 479
 480         public void setBurstSlides(boolean BurstSlides) {
 481                 configuration.BurstSlides = BurstSlides;
 482         }
 483
 484         public boolean getBurstSlides() {
 485                 return configuration.BurstSlides;
 486         }
 487
 488         /**
 489          * NumEntities - use numeric entities
 490          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#NumEntities
 491          */
 492
 493         public void setNumEntities(boolean NumEntities) {
 494                 configuration.NumEntities = NumEntities;
 495         }
 496
 497         public boolean getNumEntities() {
 498                 return configuration.NumEntities;
 499         }
 500
 501         /**
 502          * QuoteMarks - output " marks as &amp;quot;
 503          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#QuoteMarks
 504          */
 505
 506         public void setQuoteMarks(boolean QuoteMarks) {
 507                 configuration.QuoteMarks = QuoteMarks;
 508         }
 509
 510         public boolean getQuoteMarks() {
 511                 return configuration.QuoteMarks;
 512         }
 513
 514         /**
 515          * QuoteNbsp - output non-breaking space as entity
 516          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#QuoteNbsp
 517          */
 518
 519         public void setQuoteNbsp(boolean QuoteNbsp) {
 520                 configuration.QuoteNbsp = QuoteNbsp;
 521         }
 522
 523         public boolean getQuoteNbsp() {
 524                 return configuration.QuoteNbsp;
 525         }
 526
 527         /**
 528          * QuoteAmpersand - output naked ampersand as &amp;
 529          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#QuoteAmpersand
 530          */
 531
 532         public void setQuoteAmpersand(boolean QuoteAmpersand) {
 533                 configuration.QuoteAmpersand = QuoteAmpersand;
 534         }
 535
 536         public boolean getQuoteAmpersand() {
 537                 return configuration.QuoteAmpersand;
 538         }
 539
 540         /**
 541          * WrapAttVals - wrap within attribute values
 542          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapAttVals
 543          */
 544
 545         public void setWrapAttVals(boolean WrapAttVals) {
 546                 configuration.WrapAttVals = WrapAttVals;
 547         }
 548
 549         public boolean getWrapAttVals() {
 550                 return configuration.WrapAttVals;
 551         }
 552
 553         /**
 554          * WrapScriptlets - wrap within JavaScript string literals
 555          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapScriptlets
 556          */
 557
 558         public void setWrapScriptlets(boolean WrapScriptlets) {
 559                 configuration.WrapScriptlets = WrapScriptlets;
 560         }
 561
 562         public boolean getWrapScriptlets() {
 563                 return configuration.WrapScriptlets;
 564         }
 565
 566         /**
 567          * WrapSection - wrap within &lt;![ ... ]&gt; section tags
 568          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapSection
 569          */
 570
 571         public void setWrapSection(boolean WrapSection) {
 572                 configuration.WrapSection = WrapSection;
 573         }
 574
 575         public boolean getWrapSection() {
 576                 return configuration.WrapSection;
 577         }
 578
 579         /**
 580          * AltText - default text for alt attribute
 581          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#altText
 582          */
 583
 584         public void setAltText(String altText) {
 585                 configuration.altText = altText;
 586         }
 587
 588         public String getAltText() {
 589                 return configuration.altText;
 590         }
 591
 592         /**
 593          * Slidestyle - style sheet for slides
 594          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#slidestyle
 595          */
 596
 597         public void setSlidestyle(String slidestyle) {
 598                 configuration.slidestyle = slidestyle;
 599         }
 600
 601         public String getSlidestyle() {
 602                 return configuration.slidestyle;
 603         }
 604
 605         /**
 606          * XmlPi - add &lt;?xml?&gt; for XML docs
 607          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#XmlPi
 608          */
 609
 610         public void setXmlPi(boolean XmlPi) {
 611                 configuration.XmlPi = XmlPi;
 612         }
 613
 614         public boolean getXmlPi() {
 615                 return configuration.XmlPi;
 616         }
 617
 618         /**
 619          * DropFontTags - discard presentation tags
 620          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#DropFontTags
 621          */
 622
 623         public void setDropFontTags(boolean DropFontTags) {
 624                 configuration.DropFontTags = DropFontTags;
 625         }
 626
 627         public boolean getDropFontTags() {
 628                 return configuration.DropFontTags;
 629         }
 630
 631   //gschadow patch start
 632   /**
 633     * Remove all those stupid pseudo-XML tags. If only XSLT had been
 634     * around 5 years earlier, we wouldn't need to bother about all
 635     * this ASP, JSP, PHP and other sh..!
 636     *
 637     * @see net.sourceforge.phpdt.tidy.w3c.Configuration#DropFontTags
 638     */
 639   public void setDropPseudoXMLCrap(boolean DropPseudoXMLCrap) {
 640      configuration.DropPseudoXMLCrap = DropPseudoXMLCrap;
 641   }
 642   //gschadow patch end
 643
 644   public boolean getDropPseudoXMLCrap() {
 645        return configuration.DropPseudoXMLCrap;
 646   }
 647
 648         /**
 649          * DropEmptyParas - discard empty p elements
 650          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#DropEmptyParas
 651          */
 652
 653         public void setDropEmptyParas(boolean DropEmptyParas) {
 654                 configuration.DropEmptyParas = DropEmptyParas;
 655         }
 656
 657         public boolean getDropEmptyParas() {
 658                 return configuration.DropEmptyParas;
 659         }
 660
 661         /**
 662          * FixComments - fix comments with adjacent hyphens
 663          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#FixComments
 664          */
 665
 666         public void setFixComments(boolean FixComments) {
 667                 configuration.FixComments = FixComments;
 668         }
 669
 670         public boolean getFixComments() {
 671                 return configuration.FixComments;
 672         }
 673
 674         /**
 675          * WrapAsp - wrap within ASP pseudo elements
 676          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapAsp
 677          */
 678
 679         public void setWrapAsp(boolean WrapAsp) {
 680                 configuration.WrapAsp = WrapAsp;
 681         }
 682
 683         public boolean getWrapAsp() {
 684                 return configuration.WrapAsp;
 685         }
 686
 687         /**
 688          * WrapJste - wrap within JSTE pseudo elements
 689          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapJste
 690          */
 691
 692         public void setWrapJste(boolean WrapJste) {
 693                 configuration.WrapJste = WrapJste;
 694         }
 695
 696         public boolean getWrapJste() {
 697                 return configuration.WrapJste;
 698         }
 699
 700         /**
 701          * WrapPhp - wrap within PHP pseudo elements
 702          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#WrapPhp
 703          */
 704
 705         public void setWrapPhp(boolean WrapPhp) {
 706                 configuration.WrapPhp = WrapPhp;
 707         }
 708
 709         public boolean getWrapPhp() {
 710                 return configuration.WrapPhp;
 711         }
 712
 713         /**
 714          * FixBackslash - fix URLs by replacing \ with /
 715          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#FixBackslash
 716          */
 717
 718         public void setFixBackslash(boolean FixBackslash) {
 719                 configuration.FixBackslash = FixBackslash;
 720         }
 721
 722         public boolean getFixBackslash() {
 723                 return configuration.FixBackslash;
 724         }
 725
 726         /**
 727          * IndentAttributes - newline+indent before each attribute
 728          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#IndentAttributes
 729          */
 730
 731         public void setIndentAttributes(boolean IndentAttributes) {
 732                 configuration.IndentAttributes = IndentAttributes;
 733         }
 734
 735         public boolean getIndentAttributes() {
 736                 return configuration.IndentAttributes;
 737         }
 738
 739         /**
 740          * DocType - user specified doctype
 741          * omit | auto | strict | loose | <i>fpi</i>
 742          * where the <i>fpi</i> is a string similar to
 743          *    &quot;-//ACME//DTD HTML 3.14159//EN&quot;
 744          * Note: for <i>fpi</i> include the double-quotes in the string.
 745          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#docTypeStr
 746          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#docTypeMode
 747          */
 748
 749         public void setDocType(String doctype) {
 750                 if (doctype != null)
 751                         configuration.docTypeStr = configuration.parseDocType(doctype, "doctype");
 752         }
 753
 754         public String getDocType() {
 755                 String result = null;
 756                 switch (configuration.docTypeMode) {
 757                         case Configuration.DOCTYPE_OMIT :
 758                                 result = "omit";
 759                                 break;
 760                         case Configuration.DOCTYPE_AUTO :
 761                                 result = "auto";
 762                                 break;
 763                         case Configuration.DOCTYPE_STRICT :
 764                                 result = "strict";
 765                                 break;
 766                         case Configuration.DOCTYPE_LOOSE :
 767                                 result = "loose";
 768                                 break;
 769                         case Configuration.DOCTYPE_USER :
 770                                 result = configuration.docTypeStr;
 771                                 break;
 772                 }
 773                 return result;
 774         }
 775
 776         /**
 777          * LogicalEmphasis - replace i by em and b by strong
 778          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#LogicalEmphasis
 779          */
 780
 781         public void setLogicalEmphasis(boolean LogicalEmphasis) {
 782                 configuration.LogicalEmphasis = LogicalEmphasis;
 783         }
 784
 785         public boolean getLogicalEmphasis() {
 786                 return configuration.LogicalEmphasis;
 787         }
 788
 789         /**
 790          * XmlPIs - if set to true PIs must end with ?>
 791          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#XmlPIs
 792          */
 793
 794         public void setXmlPIs(boolean XmlPIs) {
 795                 configuration.XmlPIs = XmlPIs;
 796         }
 797
 798         public boolean getXmlPIs() {
 799                 return configuration.XmlPIs;
 800         }
 801
 802         /**
 803          * EncloseText - if true text at body is wrapped in &lt;p&gt;'s
 804          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#EncloseBodyText
 805          */
 806
 807         public void setEncloseText(boolean EncloseText) {
 808                 configuration.EncloseBodyText = EncloseText;
 809         }
 810
 811         public boolean getEncloseText() {
 812                 return configuration.EncloseBodyText;
 813         }
 814
 815         /**
 816          * EncloseBlockText - if true text in blocks is wrapped in &lt;p&gt;'s
 817          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#EncloseBlockText
 818          */
 819
 820         public void setEncloseBlockText(boolean EncloseBlockText) {
 821                 configuration.EncloseBlockText = EncloseBlockText;
 822         }
 823
 824         public boolean getEncloseBlockText() {
 825                 return configuration.EncloseBlockText;
 826         }
 827
 828         /**
 829          * KeepFileTimes - if true last modified time is preserved<br>
 830          * <b>this is NOT supported at this time.</b>
 831          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#KeepFileTimes
 832          */
 833
 834         public void setKeepFileTimes(boolean KeepFileTimes) {
 835                 configuration.KeepFileTimes = KeepFileTimes;
 836         }
 837
 838         public boolean getKeepFileTimes() {
 839                 return configuration.KeepFileTimes;
 840         }
 841
 842         /**
 843          * Word2000 - draconian cleaning for Word2000
 844          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#Word2000
 845          */
 846
 847         public void setWord2000(boolean Word2000) {
 848                 configuration.Word2000 = Word2000;
 849         }
 850
 851         public boolean getWord2000() {
 852                 return configuration.Word2000;
 853         }
 854
 855         /**
 856          * TidyMark - add meta element indicating tidied doc
 857          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#TidyMark
 858          */
 859
 860         public void setTidyMark(boolean TidyMark) {
 861                 configuration.TidyMark = TidyMark;
 862         }
 863
 864         public boolean getTidyMark() {
 865                 return configuration.TidyMark;
 866         }
 867
 868         /**
 869          * XmlSpace - if set to yes adds xml:space attr as needed
 870          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#XmlSpace
 871          */
 872
 873         public void setXmlSpace(boolean XmlSpace) {
 874                 configuration.XmlSpace = XmlSpace;
 875         }
 876
 877         public boolean getXmlSpace() {
 878                 return configuration.XmlSpace;
 879         }
 880
 881         /**
 882          * Emacs - if true format error output for GNU Emacs
 883          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#Emacs
 884          */
 885
 886         public void setEmacs(boolean Emacs) {
 887                 configuration.Emacs = Emacs;
 888         }
 889
 890         public boolean getEmacs() {
 891                 return configuration.Emacs;
 892         }
 893
 894         /**
 895          * LiteralAttribs - if true attributes may use newlines
 896          * @see net.sourceforge.phpdt.tidy.w3c.Configuration#LiteralAttribs
 897          */
 898
 899         public void setLiteralAttribs(boolean LiteralAttribs) {
 900                 configuration.LiteralAttribs = LiteralAttribs;
 901         }
 902
 903         public boolean getLiteralAttribs() {
 904                 return configuration.LiteralAttribs;
 905         }
 906
 907         /**
 908          * InputStreamName - the name of the input stream (printed in the
 909          * header information).
 910          */
 911         public void setInputStreamName(String name) {
 912                 if (name != null)
 913                         inputStreamName = name;
 914         }
 915
 916         public String getInputStreamName() {
 917                 return inputStreamName;
 918         }
 919
 920         /**
 921          * Sets the configuration from a configuration file.
 922          */
 923
 924         public void setConfigurationFromFile(String filename) {
 925                 configuration.parseFile(filename);
 926         }
 927
 928         /**
 929          * Sets the configuration from a properties object.
 930          */
 931
 932         public void setConfigurationFromProps(Properties props) {
 933                 configuration.addProps(props);
 934         }
 935
 936         /**
 937          * first time initialization which should
 938          * precede reading the command line
 939          */
 940
 941         private void init() {
 942                 configuration = new Configuration();
 943                 if (configuration == null)
 944                         return;
 945
 946                 AttributeTable at = AttributeTable.getDefaultAttributeTable();
 947                 if (at == null)
 948                         return;
 949                 TagTable tt = new TagTable();
 950                 if (tt == null)
 951                         return;
 952                 tt.setConfiguration(configuration);
 953                 configuration.tt = tt;
 954                 EntityTable et = EntityTable.getDefaultEntityTable();
 955                 if (et == null)
 956                         return;
 957
 958                 /* Unnecessary - same initial values in Configuration
 959                 Configuration.XmlTags       = false;
 960                 Configuration.XmlOut        = false;
 961                 Configuration.HideEndTags   = false;
 962                 Configuration.UpperCaseTags = false;
 963                 Configuration.MakeClean     = false;
 964                 Configuration.writeback     = false;
 965                 Configuration.OnlyErrors    = false;
 966                 */
 967
 968                 configuration.errfile = null;
 969                 stderr = new PrintWriter(System.err, true);
 970                 errout = stderr;
 971                 initialized = true;
 972         }
 973
 974         /**
 975          * Parses InputStream in and returns the root Node.
 976          * If out is non-null, pretty prints to OutputStream out.
 977          */
 978
 979         public Node parse(IFile iFile, InputStream in, OutputStream out) {
 980                 Node document = null;
 981
 982                 try {
 983                         document = parse(iFile, in, null, out);
 984
 985                 } catch (FileNotFoundException fnfe) {
 986                 } catch (IOException e) {
 987                 }
 988
 989                 return document;
 990         }
 991
 992         /**
 993          * Internal routine that actually does the parsing.  The caller
 994          * can pass either an InputStream or file name.  If both are passed,
 995          * the file name is preferred.
 996          */
 997
 998         private Node parse(IFile iFile, InputStream in, String file, OutputStream out)
 999                 throws FileNotFoundException, IOException {
1000                 Lexer lexer;
1001                 Node document = null;
1002                 Node doctype;
1003                 Out o = new OutImpl(); /* normal output stream */
1004                 PPrint pprint;
1005
1006                 if (!initialized)
1007                         return null;
1008
1009                 if (errout == null)
1010                         return null;
1011
1012                 parseErrors = 0;
1013                 parseWarnings = 0;
1014
1015                 /* ensure config is self-consistent */
1016                 configuration.adjust();
1017
1018                 if (file != null) {
1019                         in = new FileInputStream(file);
1020                         inputStreamName = file;
1021                 } else if (in == null) {
1022                         in = System.in;
1023                         inputStreamName = "stdin";
1024                 }
1025
1026                 if (in != null) {
1027                         lexer =
1028                                 new Lexer(
1029                                         iFile,
1030                                         new StreamInImpl(in, configuration.CharEncoding, configuration.tabsize),
1031                                         configuration);
1032                         lexer.errout = errout;
1033
1034                         /*
1035                           store pointer to lexer in input stream
1036                           to allow character encoding errors to be
1037                           reported
1038                         */
1039                         lexer.in.lexer = lexer;
1040
1041                         /* Tidy doesn't alter the doctype for generic XML docs */
1042                         if (configuration.XmlTags)
1043                                 document = ParserImpl.parseXMLDocument(lexer);
1044                         else {
1045                                 lexer.warnings = 0;
1046                                 if (!configuration.Quiet)
1047                                         Report.helloMessage(errout, Report.RELEASE_DATE, inputStreamName);
1048
1049                                 document = ParserImpl.parseDocument(lexer);
1050
1051                                 if (!document.checkNodeIntegrity()) {
1052                                         Report.badTree(errout);
1053                                         return null;
1054                                 }
1055
1056                                 Clean cleaner = new Clean(configuration.tt);
1057
1058                                 /* simplifies <b><b> ... </b> ...</b> etc. */
1059                                 cleaner.nestedEmphasis(document);
1060
1061                                 /* cleans up <dir>indented text</dir> etc. */
1062                                 cleaner.list2BQ(document);
1063                                 cleaner.bQ2Div(document);
1064
1065                                 /* replaces i by em and b by strong */
1066                                 if (configuration.LogicalEmphasis)
1067                                         cleaner.emFromI(document);
1068
1069                                 if (configuration.Word2000 && cleaner.isWord2000(document, configuration.tt)) {
1070                                         /* prune Word2000's <![if ...]> ... <![endif]> */
1071                                         cleaner.dropSections(lexer, document);
1072
1073                                         /* drop style & class attributes and empty p, span elements */
1074                                         cleaner.cleanWord2000(lexer, document);
1075                                 }
1076
1077         //gschadow patch start
1078         if (configuration.DropPseudoXMLCrap) {
1079           cleaner.dropPseudoXMLCrap(lexer, document);
1080         }
1081         //gschadow patch end
1082
1083                                 /* replaces presentational markup by style rules */
1084                                 if (configuration.MakeClean || configuration.DropFontTags)
1085                                         cleaner.cleanTree(lexer, document);
1086
1087                                 if (!document.checkNodeIntegrity()) {
1088                                         Report.badTree(errout);
1089                                         return null;
1090                                 }
1091                                 doctype = document.findDocType();
1092                                 if (document.content != null) {
1093                                         if (configuration.xHTML)
1094                                                 lexer.setXHTMLDocType(document);
1095                                         else
1096                                                 lexer.fixDocType(document);
1097
1098                                         if (configuration.TidyMark)
1099                                                 lexer.addGenerator(document);
1100                                 }
1101
1102                                 /* ensure presence of initial <?XML version="1.0"?> */
1103                                 if (configuration.XmlOut && configuration.XmlPi)
1104                                         lexer.fixXMLPI(document);
1105
1106                                 if (!configuration.Quiet && document.content != null) {
1107                                         Report.reportVersion(errout, lexer, inputStreamName, doctype);
1108                                         Report.reportNumWarnings(errout, lexer);
1109                                 }
1110                         }
1111
1112                         parseWarnings = lexer.warnings;
1113                         parseErrors = lexer.errors;
1114
1115                         // Try to close the InputStream but only if if we created it.
1116
1117                         if ((file != null) && (in != System.in)) {
1118                                 try {
1119                                         in.close();
1120                                 } catch (IOException e) {
1121                                 }
1122                         }
1123
1124                         if (lexer.errors > 0)
1125                                 Report.needsAuthorIntervention(errout);
1126
1127                         o.state = StreamIn.FSM_ASCII;
1128                         o.encoding = configuration.CharEncoding;
1129
1130                         if (!configuration.OnlyErrors && lexer.errors == 0) {
1131                                 if (configuration.BurstSlides) {
1132                                         Node body;
1133
1134                                         body = null;
1135                                         /*
1136                                            remove doctype to avoid potential clash with
1137                                            markup introduced when bursting into slides
1138                                         */
1139                                         /* discard the document type */
1140                                         doctype = document.findDocType();
1141
1142                                         if (doctype != null)
1143                                                 Node.discardElement(doctype);
1144
1145                                         /* slides use transitional features */
1146                                         lexer.versions |= Dict.VERS_HTML40_LOOSE;
1147
1148                                         /* and patch up doctype to match */
1149                                         if (configuration.xHTML)
1150                                                 lexer.setXHTMLDocType(document);
1151                                         else
1152                                                 lexer.fixDocType(document);
1153
1154                                         /* find the body element which may be implicit */
1155                                         body = document.findBody(configuration.tt);
1156
1157                                         if (body != null) {
1158                                                 pprint = new PPrint(configuration);
1159                                                 Report.reportNumberOfSlides(errout, pprint.countSlides(body));
1160                                                 pprint.createSlides(lexer, document);
1161                                         } else
1162                                                 Report.missingBody(errout);
1163                                 } else if (configuration.writeback && (file != null)) {
1164                                         try {
1165                                                 pprint = new PPrint(configuration);
1166                                                 o.out = new FileOutputStream(file);
1167
1168                                                 if (configuration.XmlTags)
1169                                                         pprint.printXMLTree(o, (short) 0, 0, lexer, document);
1170                                                 else
1171                                                         pprint.printTree(o, (short) 0, 0, lexer, document);
1172
1173                                                 pprint.flushLine(o, 0);
1174                                                 o.out.close();
1175                                         } catch (IOException e) {
1176                                                 errout.println(file + e.toString());
1177                                         }
1178                                 } else if (out != null) {
1179                                         pprint = new PPrint(configuration);
1180                                         o.out = out;
1181
1182                                         if (configuration.XmlTags)
1183                                                 pprint.printXMLTree(o, (short) 0, 0, lexer, document);
1184                                         else
1185                                                 pprint.printTree(o, (short) 0, 0, lexer, document);
1186
1187                                         pprint.flushLine(o, 0);
1188                                 }
1189
1190                         }
1191
1192                         Report.errorSummary(lexer);
1193                 }
1194                 return document;
1195         }
1196
1197         /**
1198          * Parses InputStream in and returns a DOM Document node.
1199          * If out is non-null, pretty prints to OutputStream out.
1200          */
1201
1202         public org.w3c.dom.Document parseDOM(IFile file, InputStream in, OutputStream out) {
1203                 Node document = parse(file, in, out);
1204                 if (document != null)
1205                         return (org.w3c.dom.Document) document.getAdapter();
1206                 else
1207                         return null;
1208         }
1209
1210         /**
1211          * Creates an empty DOM Document.
1212          */
1213
1214         public static org.w3c.dom.Document createEmptyDocument() {
1215                 Node document = new Node(Node.RootNode, new byte[0], 0, 0);
1216                 Node node = new Node(Node.StartTag, new byte[0], 0, 0, "html", new TagTable());
1217                 if (document != null && node != null) {
1218                         Node.insertNodeAtStart(document, node);
1219                         return (org.w3c.dom.Document) document.getAdapter();
1220                 } else {
1221                         return null;
1222                 }
1223         }
1224
1225         /**
1226          * Pretty-prints a DOM Document.
1227          */
1228
1229         public void pprint(org.w3c.dom.Document doc, OutputStream out) {
1230                 Out o = new OutImpl();
1231                 PPrint pprint;
1232                 Node document;
1233
1234                 if (!(doc instanceof DOMDocumentImpl)) {
1235                         return;
1236                 }
1237                 document = ((DOMDocumentImpl) doc).adaptee;
1238
1239                 o.state = StreamIn.FSM_ASCII;
1240                 o.encoding = configuration.CharEncoding;
1241
1242                 if (out != null) {
1243                         pprint = new PPrint(configuration);
1244                         o.out = out;
1245
1246                         if (configuration.XmlTags)
1247                                 pprint.printXMLTree(o, (short) 0, 0, null, document);
1248                         else
1249                                 pprint.printTree(o, (short) 0, 0, null, document);
1250
1251                         pprint.flushLine(o, 0);
1252                 }
1253         }
1254
1255         /**
1256          * Command line interface to parser and pretty printer.
1257          */
1258
1259         public static void main(String[] argv) {
1260                 int totalerrors = 0;
1261                 int totalwarnings = 0;
1262                 String file;
1263                 InputStream in;
1264                 String prog = "Tidy";
1265                 Node document;
1266                 Node doctype;
1267                 Lexer lexer;
1268                 String s;
1269                 Out out = new OutImpl(); /* normal output stream */
1270                 PPrint pprint;
1271                 int argc = argv.length + 1;
1272                 int argIndex = 0;
1273                 Tidy tidy;
1274                 Configuration configuration;
1275                 String arg;
1276                 String current_errorfile = "stderr";
1277
1278                 tidy = new Tidy();
1279                 configuration = tidy.getConfiguration();
1280
1281                 /* read command line */
1282
1283                 while (argc > 0) {
1284                         if (argc > 1 && argv[argIndex].startsWith("-")) {
1285                                 /* support -foo and --foo */
1286                                 arg = argv[argIndex].substring(1);
1287
1288                                 if (arg.length() > 0 && arg.charAt(0) == '-')
1289                                         arg = arg.substring(1);
1290
1291                                 if (arg.equals("xml"))
1292                                         configuration.XmlTags = true;
1293                                 else if (arg.equals("asxml") || arg.equals("asxhtml"))
1294                                         configuration.xHTML = true;
1295                                 else if (arg.equals("indent")) {
1296                                         configuration.IndentContent = true;
1297                                         configuration.SmartIndent = true;
1298                                 } else if (arg.equals("omit"))
1299                                         configuration.HideEndTags = true;
1300                                 else if (arg.equals("upper"))
1301                                         configuration.UpperCaseTags = true;
1302                                 else if (arg.equals("clean"))
1303                                         configuration.MakeClean = true;
1304                                 else if (arg.equals("raw"))
1305                                         configuration.CharEncoding = Configuration.RAW;
1306                                 else if (arg.equals("ascii"))
1307                                         configuration.CharEncoding = Configuration.ASCII;
1308                                 else if (arg.equals("latin1"))
1309                                         configuration.CharEncoding = Configuration.LATIN1;
1310                                 else if (arg.equals("utf8"))
1311                                         configuration.CharEncoding = Configuration.UTF8;
1312                                 else if (arg.equals("iso2022"))
1313                                         configuration.CharEncoding = Configuration.ISO2022;
1314                                 else if (arg.equals("mac"))
1315                                         configuration.CharEncoding = Configuration.MACROMAN;
1316                                 else if (arg.equals("numeric"))
1317                                         configuration.NumEntities = true;
1318                                 else if (arg.equals("modify"))
1319                                         configuration.writeback = true;
1320                                 else if (arg.equals("change")) /* obsolete */
1321                                         configuration.writeback = true;
1322                                 else if (arg.equals("update")) /* obsolete */
1323                                         configuration.writeback = true;
1324                                 else if (arg.equals("errors"))
1325                                         configuration.OnlyErrors = true;
1326                                 else if (arg.equals("quiet"))
1327                                         configuration.Quiet = true;
1328                                 else if (arg.equals("slides"))
1329                                         configuration.BurstSlides = true;
1330                                 else if (arg.equals("help") || argv[argIndex].charAt(1) == '?' || argv[argIndex].charAt(1) == 'h') {
1331                                         Report.helpText(new PrintWriter(System.out, true), prog);
1332                                         System.exit(1);
1333                                 } else if (arg.equals("config")) {
1334                                         if (argc >= 3) {
1335                                                 configuration.parseFile(argv[argIndex + 1]);
1336                                                 --argc;
1337                                                 ++argIndex;
1338                                         }
1339                                 } else if (
1340                                         argv[argIndex].equals("-file") || argv[argIndex].equals("--file") || argv[argIndex].equals("-f")) {
1341                                         if (argc >= 3) {
1342                                                 configuration.errfile = argv[argIndex + 1];
1343                                                 --argc;
1344                                                 ++argIndex;
1345                                         }
1346                                 } else if (
1347                                         argv[argIndex].equals("-wrap") || argv[argIndex].equals("--wrap") || argv[argIndex].equals("-w")) {
1348                                         if (argc >= 3) {
1349                                                 configuration.wraplen = Integer.parseInt(argv[argIndex + 1]);
1350                                                 --argc;
1351                                                 ++argIndex;
1352                                         }
1353                                 } else if (
1354                                         argv[argIndex].equals("-version")
1355                                                 || argv[argIndex].equals("--version")
1356                                                 || argv[argIndex].equals("-v")) {
1357                                         Report.showVersion(tidy.getErrout());
1358                                         System.exit(0);
1359                                 } else {
1360                                         s = argv[argIndex];
1361
1362                                         for (int i = 1; i < s.length(); i++) {
1363                                                 if (s.charAt(i) == 'i') {
1364                                                         configuration.IndentContent = true;
1365                                                         configuration.SmartIndent = true;
1366                                                 } else if (s.charAt(i) == 'o')
1367                                                         configuration.HideEndTags = true;
1368                                                 else if (s.charAt(i) == 'u')
1369                                                         configuration.UpperCaseTags = true;
1370                                                 else if (s.charAt(i) == 'c')
1371                                                         configuration.MakeClean = true;
1372                                                 else if (s.charAt(i) == 'n')
1373                                                         configuration.NumEntities = true;
1374                                                 else if (s.charAt(i) == 'm')
1375                                                         configuration.writeback = true;
1376                                                 else if (s.charAt(i) == 'e')
1377                                                         configuration.OnlyErrors = true;
1378                                                 else if (s.charAt(i) == 'q')
1379                                                         configuration.Quiet = true;
1380                                                 else
1381                                                         Report.unknownOption(tidy.getErrout(), s.charAt(i));
1382                                         }
1383                                 }
1384
1385                                 --argc;
1386                                 ++argIndex;
1387                                 continue;
1388                         }
1389
1390                         /* ensure config is self-consistent */
1391                         configuration.adjust();
1392
1393                         /* user specified error file */
1394                         if (configuration.errfile != null) {
1395                                 /* is it same as the currently opened file? */
1396                                 if (!configuration.errfile.equals(current_errorfile)) {
1397                                         /* no so close previous error file */
1398
1399                                         if (tidy.getErrout() != tidy.getStderr())
1400                                                 tidy.getErrout().close();
1401
1402                                         /* and try to open the new error file */
1403                                         try {
1404                                                 tidy.setErrout(new PrintWriter(new FileWriter(configuration.errfile), true));
1405                                                 current_errorfile = configuration.errfile;
1406                                         } catch (IOException e) {
1407                                                 /* can't be opened so fall back to stderr */
1408                                                 current_errorfile = "stderr";
1409                                                 tidy.setErrout(tidy.getStderr());
1410                                         }
1411                                 }
1412                         }
1413
1414                         if (argc > 1) {
1415                                 file = argv[argIndex];
1416                         } else {
1417                                 file = "stdin";
1418                         }
1419
1420                         try {
1421                                 document = tidy.parse(null, null, file, System.out);
1422                                 totalwarnings += tidy.parseWarnings;
1423                                 totalerrors += tidy.parseErrors;
1424                         } catch (FileNotFoundException fnfe) {
1425                                 Report.unknownFile(tidy.getErrout(), prog, file);
1426                         } catch (IOException ioe) {
1427                                 Report.unknownFile(tidy.getErrout(), prog, file);
1428                         }
1429
1430                         --argc;
1431                         ++argIndex;
1432
1433                         if (argc <= 1)
1434                                 break;
1435                 }
1436
1437                 if (totalerrors + totalwarnings > 0)
1438                         Report.generalInfo(tidy.getErrout());
1439
1440                 if (tidy.getErrout() != tidy.getStderr())
1441                         tidy.getErrout().close();
1442
1443                 /* return status can be used by scripts */
1444
1445                 if (totalerrors > 0)
1446                         System.exit(2);
1447
1448                 if (totalwarnings > 0)
1449                         System.exit(1);
1450
1451                 /* 0 signifies all is ok */
1452                 System.exit(0);
1453         }
1454 }