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