Tidy


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