Eclipse3M7 version
[phpeclipse.git] / archive / net.sourceforge.phpeclipse.jtidy / src / net / sourceforge / phpdt / tidy / w3c / Node.java
1 /*
2  * @(#)Node.java   1.11 2000/08/16
3  *
4  */
5
6 package net.sourceforge.phpdt.tidy.w3c;
7
8
9 /**
10  *
11  * Node
12  *
13  * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
14  * See Tidy.java for the copyright notice.
15  * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
16  * HTML Tidy Release 4 Aug 2000</a>
17  *
18  * @author  Dave Raggett <dsr@w3.org>
19  * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
20  * @version 1.0, 1999/05/22
21  * @version 1.0.1, 1999/05/29
22  * @version 1.1, 1999/06/18 Java Bean
23  * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
24  * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
25  * @version 1.4, 1999/09/04 DOM support
26  * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
27  * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
28  * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
29  * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
30  * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
31  * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
32  * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
33  */
34
35 /*
36   Used for elements and text nodes
37   element name is null for text nodes
38   start and end are offsets into lexbuf
39   which contains the textual content of
40   all elements in the parse tree.
41
42   parent and content allow traversal
43   of the parse tree in any direction.
44   attributes are represented as a linked
45   list of AttVal nodes which hold the
46   strings for attribute/value pairs.
47 */
48
49 public class Node {
50
51     public static final short RootNode        = 0;
52     public static final short DocTypeTag      = 1;
53     public static final short CommentTag      = 2;
54     public static final short ProcInsTag      = 3;
55     public static final short TextNode        = 4;
56     public static final short StartTag        = 5;
57     public static final short EndTag          = 6;
58     public static final short StartEndTag     = 7;
59     public static final short CDATATag        = 8;
60     public static final short SectionTag      = 9;
61     public static final short AspTag          = 10;
62     public static final short JsteTag         = 11;
63     public static final short PhpTag          = 12;
64
65     protected Node parent;
66     protected Node prev;
67     protected Node next;
68     protected Node last;
69     protected int start;             /* start of span onto text array */
70     protected int end;               /* end of span onto text array */
71     protected byte[] textarray;      /* the text array */
72     protected short type;              /* TextNode, StartTag, EndTag etc. */
73     protected boolean closed;            /* true if closed by explicit end tag */
74     protected boolean implicit;          /* true if inferred */
75     protected boolean linebreak;         /* true if followed by a line break */
76     protected Dict was;   /* old tag when it was changed */
77     protected Dict tag;   /* tag's dictionary definition */
78     protected String element;          /* name (null for text nodes) */
79     protected AttVal attributes;
80     protected Node content;
81
82     public Node()
83     {
84         this(TextNode, null, 0, 0);
85     }
86
87     public Node(short type, byte[] textarray, int start, int end)
88     {
89         this.parent = null;
90         this.prev = null;
91         this.next = null;
92         this.last = null;
93         this.start = start;
94         this.end = end;
95         this.textarray = textarray;
96         this.type = type;
97         this.closed = false;
98         this.implicit = false;
99         this.linebreak = false;
100         this.was = null;
101         this.tag = null;
102         this.element = null;
103         this.attributes = null;
104         this.content = null;
105     }
106
107     public Node(short type, byte[] textarray, int start, int end, String element, TagTable tt)
108     {
109         this.parent = null;
110         this.prev = null;
111         this.next = null;
112         this.last = null;
113         this.start = start;
114         this.end = end;
115         this.textarray = textarray;
116         this.type = type;
117         this.closed = false;
118         this.implicit = false;
119         this.linebreak = false;
120         this.was = null;
121         this.tag = null;
122         this.element = element;
123         this.attributes = null;
124         this.content = null;
125         if (type == StartTag || type == StartEndTag || type == EndTag)
126             tt.findTag(this);
127     }
128
129     /* used to clone heading nodes when split by an <HR> */
130     protected Object clone()
131     {
132         Node node = new Node();
133
134         node.parent = this.parent;
135         if (this.textarray != null)
136         {
137             node.textarray = new byte[this.end - this.start];
138             node.start = 0;
139             node.end = this.end - this.start;
140             if (node.end > 0)
141                 System.arraycopy(this.textarray, this.start,
142                                  node.textarray, node.start, node.end);
143         }
144         node.type = this.type;
145         node.closed = this.closed;
146         node.implicit = this.implicit;
147         node.linebreak = this.linebreak;
148         node.was = this.was;
149         node.tag = this.tag;
150         if (this.element != null)
151             node.element = this.element;
152         if (this.attributes != null)
153             node.attributes = (AttVal)this.attributes.clone();
154         return node;
155     }
156
157     public AttVal getAttrByName(String name)
158     {
159         AttVal attr;
160
161         for (attr = this.attributes; attr != null; attr = attr.next)
162         {
163             if (name != null &&
164                 attr.attribute != null &&
165                 attr.attribute.equals(name))
166                 break;
167         }
168
169         return attr;
170     }
171
172     /* default method for checking an element's attributes */
173     public void checkAttributes( Lexer lexer )
174     {
175         AttVal attval;
176
177         for (attval = this.attributes; attval != null; attval = attval.next)
178             attval.checkAttribute( lexer, this );
179     }
180
181     public void checkUniqueAttributes(Lexer lexer)
182     {
183         AttVal attval;
184
185         for (attval = this.attributes; attval != null; attval = attval.next) {
186             if (attval.asp == null && attval.php == null)
187                 attval.checkUniqueAttribute(lexer, this);
188         }
189     }
190
191     public void addAttribute(String name, String value)
192     {
193         AttVal av = new AttVal(null, null, null, null,
194                                '"', name, value);
195         av.dict =
196           AttributeTable.getDefaultAttributeTable().findAttribute(av);
197
198         if (this.attributes == null)
199             this.attributes = av;
200         else /* append to end of attributes */
201         {
202             AttVal here = this.attributes;
203
204             while (here.next != null)
205                 here = here.next;
206
207             here.next = av;
208         }
209     }
210
211     /* remove attribute from node then free it */
212     public void removeAttribute(AttVal attr)
213     {
214         AttVal av;
215         AttVal prev = null;
216         AttVal next;
217
218         for (av = this.attributes; av != null; av = next)
219         {
220             next = av.next;
221
222             if (av == attr)
223             {
224                 if (prev != null)
225                     prev.next = next;
226                 else
227                     this.attributes = next;
228             }
229             else
230                 prev = av;
231         }
232     }
233
234     /* find doctype element */
235     public Node findDocType()
236     {
237         Node node;
238
239         for (node = this.content; 
240             node != null && node.type != DocTypeTag; node = node.next);
241
242         return node;
243     }
244
245     public void discardDocType()
246     {
247         Node node;
248
249         node = findDocType();
250         if (node != null)
251         {
252             if (node.prev != null)
253                 node.prev.next = node.next;
254             else
255                 node.parent.content = node.next;
256
257             if (node.next != null)
258                 node.next.prev = node.prev;
259
260             node.next = null;
261         }
262     }
263
264     /* remove node from markup tree and discard it */
265     public static Node discardElement(Node element)
266     {
267         Node next = null;
268
269         if (element != null)
270         {
271             next = element.next;
272             removeNode(element);
273         }
274
275         return next;
276     }
277
278     /* insert node into markup tree */
279     public static void insertNodeAtStart(Node element, Node node)
280     {
281         node.parent = element;
282
283         if (element.content == null)
284             element.last = node;
285         else
286             element.content.prev = node; // AQ added 13 Apr 2000
287
288         node.next = element.content;
289         node.prev = null;
290         element.content = node;
291     }
292
293     /* insert node into markup tree */
294     public static void insertNodeAtEnd(Node element, Node node)
295     {
296         node.parent = element;
297         node.prev = element.last;
298
299         if (element.last != null)
300             element.last.next = node;
301         else
302             element.content = node;
303
304         element.last = node;
305     }
306
307     /*
308      insert node into markup tree in pace of element
309      which is moved to become the child of the node
310     */
311     public static void insertNodeAsParent(Node element, Node node)
312     {
313         node.content = element;
314         node.last = element;
315         node.parent = element.parent;
316         element.parent = node;
317     
318         if (node.parent.content == element)
319             node.parent.content = node;
320
321         if (node.parent.last == element)
322             node.parent.last = node;
323
324         node.prev = element.prev;
325         element.prev = null;
326
327         if (node.prev != null)
328             node.prev.next = node;
329
330         node.next = element.next;
331         element.next = null;
332
333         if (node.next != null)
334             node.next.prev = node;
335     }
336
337     /* insert node into markup tree before element */
338     public static void insertNodeBeforeElement(Node element, Node node)
339     {
340         Node parent;
341
342         parent = element.parent;
343         node.parent = parent;
344         node.next = element;
345         node.prev = element.prev;
346         element.prev = node;
347
348         if (node.prev != null)
349             node.prev.next = node;
350
351         if (parent.content == element)
352             parent.content = node;
353     }
354
355     /* insert node into markup tree after element */
356     public static void insertNodeAfterElement(Node element, Node node)
357     {
358         Node parent;
359
360         parent = element.parent;
361         node.parent = parent;
362
363         // AQ - 13Jan2000 fix for parent == null
364         if (parent != null && parent.last == element)
365             parent.last = node;
366         else
367         {
368             node.next = element.next;
369             // AQ - 13Jan2000 fix for node.next == null
370             if (node.next != null)
371                 node.next.prev = node;
372         }
373
374         element.next = node;
375         node.prev = element;
376     }
377
378     public static void trimEmptyElement(Lexer lexer, Node element)
379     {
380         TagTable tt = lexer.configuration.tt;
381
382         if (lexer.canPrune(element))
383         {
384             if (element.type != TextNode)
385                 Report.warning(lexer, element, null, Report.TRIM_EMPTY_ELEMENT);
386
387             discardElement(element);
388         }
389         else if (element.tag == tt.tagP && element.content == null)
390         {
391             /* replace <p></p> by <br><br> to preserve formatting */
392             Node node = lexer.inferredTag("br");
393             Node.coerceNode(lexer, element, tt.tagBr);
394             Node.insertNodeAfterElement(element, node);
395         }
396     }
397
398     /*
399       This maps 
400            <em>hello </em><strong>world</strong>
401       to
402            <em>hello</em> <strong>world</strong>
403
404       If last child of element is a text node
405       then trim trailing white space character
406       moving it to after element's end tag.
407     */
408     public static void trimTrailingSpace(Lexer lexer, Node element, Node last)
409     {
410         byte c;
411         TagTable tt = lexer.configuration.tt;
412
413         if (last != null && last.type == Node.TextNode &&
414             last.end > last.start)
415         {
416             c = lexer.lexbuf[last.end - 1];
417
418             if (c == 160 || c == (byte)' ')
419             {
420                 /* take care with <td>&nbsp;</td> */
421                 if (element.tag == tt.tagTd ||
422                     element.tag == tt.tagTh)
423                 {
424                     if (last.end > last.start + 1)
425                         last.end -= 1;
426                 }
427                 else
428                 {
429                     last.end -= 1;
430
431                     if (((element.tag.model & Dict.CM_INLINE) != 0) &&
432                             !((element.tag.model & Dict.CM_FIELD) != 0))
433                         lexer.insertspace = true;
434
435                     /* if empty string then delete from parse tree */
436                     if (last.start == last.end)
437                         trimEmptyElement(lexer, last);
438                 }
439             }
440         }
441     }
442
443     /*
444       This maps 
445            <p>hello<em> world</em>
446       to
447            <p>hello <em>world</em>
448
449       Trims initial space, by moving it before the
450       start tag, or if this element is the first in
451       parent's content, then by discarding the space
452     */
453     public static void trimInitialSpace(Lexer lexer, Node element, Node text)
454     {
455         Node prev, node;
456
457         // GLP: Local fix to Bug 119789. Remove this comment when parser.c is updated.
458         //      31-Oct-00. 
459         if (text.type == TextNode && text.textarray[text.start] == (byte)' ' 
460                            && (text.start < text.end))
461         {
462             if (((element.tag.model & Dict.CM_INLINE) != 0) &&
463                 !((element.tag.model & Dict.CM_FIELD) != 0) &&
464                 element.parent.content != element)
465             {
466                 prev = element.prev;
467
468                 if (prev != null && prev.type == TextNode)
469                 {
470                     if (prev.textarray[prev.end - 1] != (byte)' ')
471                         prev.textarray[prev.end++] = (byte)' ';
472
473                     ++element.start;
474                 }
475                 else /* create new node */
476                 {
477                     node = lexer.newNode();
478                     // Local fix for bug 228486 (GLP).  This handles the case
479                     // where we need to create a preceeding text node but there are
480                     // no "slots" in textarray that we can steal from the current
481                     // element.  Therefore, we create a new textarray containing
482                     // just the blank.  When Tidy is fixed, this should be removed.
483                     if (element.start >= element.end)
484                     {
485                         node.start = 0;
486                         node.end = 1;
487                         node.textarray = new byte[1];
488                     }
489                     else
490                     {
491                         node.start = element.start++;
492                         node.end = element.start;
493                         node.textarray = element.textarray;
494                     }
495                     node.textarray[node.start] = (byte)' ';
496                     node.prev = prev;
497                     if (prev != null)
498                         prev.next = node;
499                     node.next = element;
500                     element.prev = node;
501                     node.parent = element.parent;
502                 }
503             }
504
505             /* discard the space  in current node */
506             ++text.start;
507         }
508     }
509
510     /* 
511       Move initial and trailing space out.
512       This routine maps:
513
514            hello<em> world</em>
515       to
516            hello <em>world</em>
517       and
518            <em>hello </em><strong>world</strong>
519       to
520            <em>hello</em> <strong>world</strong>
521     */
522     public static void trimSpaces(Lexer lexer, Node element)
523     {
524         Node text = element.content;
525         TagTable tt = lexer.configuration.tt;
526
527         if (text != null && text.type == Node.TextNode &&
528             element.tag != tt.tagPre)
529             trimInitialSpace(lexer, element, text);
530
531         text = element.last;
532
533         if (text != null && text.type == Node.TextNode)
534             trimTrailingSpace(lexer, element, text);
535     }
536
537     public boolean isDescendantOf(Dict tag)
538     {
539         Node parent;
540
541         for (parent = this.parent;
542                 parent != null; parent = parent.parent)
543         {
544             if (parent.tag == tag)
545                 return true;
546         }
547
548         return false;
549     }
550
551     /*
552      the doctype has been found after other tags,
553      and needs moving to before the html element
554     */
555     public static void insertDocType(Lexer lexer, Node element, Node doctype)
556     {
557         TagTable tt = lexer.configuration.tt;
558       
559         Report.warning(lexer, element, doctype, Report.DOCTYPE_AFTER_TAGS);
560
561         while (element.tag != tt.tagHtml)
562             element = element.parent;
563
564         insertNodeBeforeElement(element, doctype);
565     }
566
567     public Node findBody(TagTable tt)
568     {
569         Node node;
570
571         node = this.content;
572
573         while (node != null && node.tag != tt.tagHtml)
574             node = node.next;
575
576         if (node == null)
577             return null;
578
579         node = node.content;
580
581         while (node != null && node.tag != tt.tagBody)
582             node = node.next;
583
584         return node;
585     }
586
587     public boolean isElement()
588     {
589         return (this.type == StartTag || this.type == StartEndTag ? true : false);
590     }
591
592     /*
593      unexpected content in table row is moved to just before
594      the table in accordance with Netscape and IE. This code
595      assumes that node hasn't been inserted into the row.
596     */
597     public static void moveBeforeTable(Node row, Node node, TagTable tt)
598     {
599         Node table;
600
601         /* first find the table element */
602         for (table = row.parent; table != null; table = table.parent)
603         {
604             if (table.tag == tt.tagTable)
605             {
606                 if (table.parent.content == table)
607                     table.parent.content = node;
608
609                 node.prev = table.prev;
610                 node.next = table;
611                 table.prev = node;
612                 node.parent = table.parent;
613         
614                 if (node.prev != null)
615                     node.prev.next = node;
616
617                 break;
618             }
619         }
620     }
621
622     /*
623      if a table row is empty then insert an empty cell
624      this practice is consistent with browser behavior
625      and avoids potential problems with row spanning cells
626     */
627     public static void fixEmptyRow(Lexer lexer, Node row)
628     {
629         Node cell;
630
631         if (row.content == null)
632         {
633             cell = lexer.inferredTag("td");
634             insertNodeAtEnd(row, cell);
635             Report.warning(lexer, row, cell, Report.MISSING_STARTTAG);
636         }
637     }
638
639     public static void coerceNode(Lexer lexer, Node node, Dict tag)
640     {
641         Node tmp = lexer.inferredTag(tag.name);
642         Report.warning(lexer, node, tmp, Report.OBSOLETE_ELEMENT);
643         node.was = node.tag;
644         node.tag = tag;
645         node.type = StartTag;
646         node.implicit = true;
647         node.element = tag.name;
648     }
649
650     /* extract a node and its children from a markup tree */
651     public static void removeNode(Node node)
652     {
653         if (node.prev != null)
654             node.prev.next = node.next;
655
656         if (node.next != null)
657             node.next.prev = node.prev;
658
659         if (node.parent != null)
660         {
661             if (node.parent.content == node)
662                 node.parent.content = node.next;
663
664             if (node.parent.last == node)
665                 node.parent.last = node.prev;
666         }
667
668         node.parent = node.prev = node.next = null;
669     }
670
671     public static boolean insertMisc(Node element, Node node)
672     {
673         if (node.type == CommentTag ||
674             node.type == ProcInsTag ||
675             node.type == CDATATag ||
676             node.type == SectionTag ||
677             node.type == AspTag ||
678             node.type == JsteTag ||
679             node.type == PhpTag)
680         {
681             insertNodeAtEnd(element, node);
682             return true;
683         }
684
685         return false;
686     }
687
688     /*
689      used to determine how attributes
690      without values should be printed
691      this was introduced to deal with
692      user defined tags e.g. Cold Fusion
693     */
694     public static boolean isNewNode(Node node)
695     {
696         if (node != null && node.tag != null)
697         {
698             return ((node.tag.model & Dict.CM_NEW) != 0);
699         }
700
701         return true;
702     }
703
704     public boolean hasOneChild()
705     {
706         return (this.content != null && this.content.next == null);
707     }
708
709     /* find html element */
710     public Node findHTML(TagTable tt)
711     {
712         Node node;
713
714         for (node = this.content;
715                 node != null && node.tag != tt.tagHtml; node = node.next);
716
717         return node;
718     }
719
720     public Node findHEAD(TagTable tt)
721     {
722         Node node;
723
724         node = this.findHTML(tt);
725
726         if (node != null)
727         {
728             for (node = node.content;
729                 node != null && node.tag != tt.tagHead;
730                 node = node.next);
731         }
732
733         return node;
734     }
735
736     public boolean checkNodeIntegrity()
737     {
738         Node child;
739         boolean found = false;
740
741         if (this.prev != null)
742         {
743             if (this.prev.next != this)
744                 return false;
745         }
746
747         if (this.next != null)
748         {
749             if (this.next.prev != this)
750                 return false;
751         }
752
753         if (this.parent != null)
754         {
755             if (this.prev == null && this.parent.content != this)
756                 return false;
757
758             if (this.next == null && this.parent.last != this)
759                 return false;
760
761             for (child = this.parent.content; child != null; child = child.next)
762                 if (child == this)
763                 {
764                     found = true;
765                     break;
766                 }
767
768             if (!found)
769                 return false;
770         }
771
772         for (child = this.content; child != null; child = child.next)
773             if (!child.checkNodeIntegrity())
774                 return false;
775
776         return true;
777     }
778
779     /*
780      Add class="foo" to node
781     */
782     public static void addClass(Node node, String classname)
783     {
784         AttVal classattr = node.getAttrByName("class");
785
786             /*
787              if there already is a class attribute
788              then append class name after a space
789             */
790             if (classattr != null)
791             {
792                 classattr.value = classattr.value + " " + classname;
793             }
794             else /* create new class attribute */
795                 node.addAttribute("class", classname);
796     }
797
798     /* --------------------- DEBUG -------------------------- */
799
800     private static final String[] nodeTypeString =
801     {
802         "RootNode",
803         "DocTypeTag",
804         "CommentTag",
805         "ProcInsTag",
806         "TextNode",
807         "StartTag",
808         "EndTag",
809         "StartEndTag",
810         "SectionTag",
811         "AspTag",
812         "PhpTag"
813     };
814
815     public String toString()
816     {
817         String s = "";
818         Node n = this;
819
820         while (n != null) {
821             s += "[Node type=";
822             s += nodeTypeString[n.type];
823             s += ",element=";
824             if (n.element != null)
825                 s += n.element;
826             else
827                 s += "null";
828             if (n.type == TextNode ||
829                 n.type == CommentTag ||
830                 n.type == ProcInsTag) {
831                 s += ",text=";
832                 if (n.textarray != null && n.start <= n.end) {
833                     s += "\"";
834                     s += Lexer.getString(n.textarray, n.start, n.end - n.start);
835                     s += "\"";
836                 } else {
837                     s += "null";
838                 }
839             }
840             s += ",content=";
841             if (n.content != null)
842                 s += n.content.toString();
843             else
844                 s += "null";
845             s += "]";
846             if (n.next != null)
847                 s += ",";
848             n = n.next;
849         }
850         return s;
851     }
852     /* --------------------- END DEBUG ---------------------- */
853
854
855     /* --------------------- DOM ---------------------------- */
856
857     protected org.w3c.dom.Node adapter = null;
858
859     protected org.w3c.dom.Node getAdapter()
860     {
861         if (adapter == null)
862         {
863             switch (this.type)
864             {
865                 case RootNode:
866                     adapter = new DOMDocumentImpl(this);
867                     break;
868                 case StartTag:
869                 case StartEndTag:
870                     adapter = new DOMElementImpl(this);
871                     break;
872                 case DocTypeTag:
873                     adapter = new DOMDocumentTypeImpl(this);
874                     break;
875                 case CommentTag:
876                     adapter = new DOMCommentImpl(this);
877                     break;
878                 case TextNode:
879                     adapter = new DOMTextImpl(this);
880                     break;
881                 case CDATATag:
882                     adapter = new DOMCDATASectionImpl(this);
883                     break;
884                 case ProcInsTag:
885                     adapter = new DOMProcessingInstructionImpl(this);
886                     break;
887                 default:
888                     adapter = new DOMNodeImpl(this);
889             }
890         }
891         return adapter;
892     }
893
894     protected Node cloneNode(boolean deep)
895     {
896         Node node = (Node)this.clone();
897         if (deep)
898         {
899             Node child;
900             Node newChild;
901             for (child = this.content; child != null; child = child.next)
902             {
903                 newChild = child.cloneNode(deep);
904                 insertNodeAtEnd(node, newChild);
905             }
906         }
907         return node;
908     }
909
910
911     protected void setType(short newType)
912     {
913         this.type = newType;
914     }
915
916     /* --------------------- END DOM ------------------------ */
917
918 }