0ec3b3f0230f489a2ddc3880a729037e28a466b8
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / jdom / DOMType.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.core.jdom;
12
13 import java.util.Enumeration;
14
15 import net.sourceforge.phpdt.core.ICompilationUnit;
16 import net.sourceforge.phpdt.core.IJavaElement;
17 import net.sourceforge.phpdt.core.IType;
18 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
19 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
20 import net.sourceforge.phpdt.core.jdom.IDOMMethod;
21 import net.sourceforge.phpdt.core.jdom.IDOMNode;
22 import net.sourceforge.phpdt.core.jdom.IDOMType;
23 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
24 import net.sourceforge.phpdt.internal.compiler.util.Util;
25 import net.sourceforge.phpdt.internal.core.util.CharArrayBuffer;
26 import net.sourceforge.phpdt.internal.core.util.CharArrayOps;
27
28 /**
29  * DOMType provides an implementation of IDOMType.
30  *
31  * @see IDOMType
32  * @see DOMNode
33  */
34  
35 /* package */ class DOMType extends DOMMember implements IDOMType {
36
37         /**
38          * The 'class' or 'interface' keyword if altered
39          * from the documents contents, otherwise <code>null</code>.
40          */
41         protected String fTypeKeyword;
42
43         /**
44          * The original inclusive source range of the 'class'
45          * or 'interface' keyword in the document.
46          */
47         protected int[]  fTypeRange;
48
49         /**
50          * The superclass name for the class declaration
51          * if altered from the document's contents, otherwise
52          * <code>null</code>. Also <code>null</code> when this
53          * type represents an interface.
54          */
55         protected String fSuperclass;
56
57         /**
58          * The original inclusive source range of the superclass
59          * name in the document, or -1's of no superclass was
60          * specified in the document.
61          */
62         protected int[]  fSuperclassRange;
63
64
65         /**
66          * The original inclusive souce range of the 'extends' keyword
67          * in the document, including surrounding whitespace, or -1's if
68          * the keyword was not present in the document.
69          */
70         protected int[]  fExtendsRange;
71
72         /**
73          * The original inclusive souce range of the 'implements' keyword
74          * in the document, including surrounding whitespace, or -1's if
75          * the keyword was not present in the document.
76          */     
77         protected int[]  fImplementsRange;
78
79         /**
80          * The comma delimited list of interfaces this type implements
81          * or extends, if altered from the document's contents, otherwise
82          * <code>null</code>. Also <code>null</code> if this type does
83          * not implement or extend any interfaces.
84          */
85         protected char[] fInterfaces;
86
87         /**
88          * The original inclusive source range of the list of interfaces this
89          * type implements or extends, not including any surrouding whitespace.
90          * If the document did not specify interfaces, this array contains -1's.
91          */
92         protected int[]  fInterfacesRange;
93
94         
95
96         /** 
97          * The original source range of the first character following the
98          * type name superclass name, or interface list, up to and including
99          * the first character before the first type member.
100          */     
101         protected int[]  fOpenBodyRange;
102
103         /** 
104          * The original source range of the first new line or non whitespace
105          * character preceding the close brace of the type's body, up to the
106          * and including the first character before the next node (if there are
107          * no following nodes, the range ends at the position of the last
108          * character in the document).
109          */     
110         protected int[]  fCloseBodyRange;
111
112         /**
113          * A list of interfaces this type extends or implements.
114          * <code>null</code> when this type does not extend
115          * or implement any interfaces.
116          */
117         protected String[] fSuperInterfaces= new String[0];
118         
119         /**
120          * This position is the position of the end of the last line separator before the closing brace starting
121          * position of the receiver.
122          */
123 //      protected int fInsertionPosition;
124
125 /**
126  * Constructs an empty type node.
127  */
128 DOMType() {
129
130 }
131 /**
132  * Creates a new detailed TYPE document fragment on the given range of the document.
133  *
134  * @param document - the document containing this node's original contents
135  * @param sourceRange - a two element array of integers describing the
136  *              entire inclusive source range of this node within its document.
137  *              Contents start on and include the character at the first position.
138  *              Contents end on and include the character at the last position.
139  *              An array of -1's indicates this node's contents do not exist
140  *              in the document.
141  * @param name - the identifier portion of the name of this node, or
142  *              <code>null</code> if this node does not have a name
143  * @param nameRange - a two element array of integers describing the
144  *              entire inclusive source range of this node's name within its document,
145  *              including any array qualifiers that might immediately follow the name
146  *              or -1's if this node does not have a name.
147  * @param commentRange - a two element array describing the comments that precede
148  *              the member declaration. The first matches the start of this node's
149  *              sourceRange, and the second is the new-line or first non-whitespace
150  *              character following the last comment. If no comments are present,
151  *              this array contains two -1's.
152  * @param flags - an integer representing the modifiers for this member. The
153  *              integer can be analyzed with org.eclipse.jdt.core.Flags
154  * @param modifierRange - a two element array describing the location of
155  *              modifiers for this member within its source range. The first integer
156  *              is the first character of the first modifier for this member, and
157  *              the second integer is the last whitespace character preceeding the
158  *              next part of this member declaration. If there are no modifiers present
159  *              in this node's source code (that is, package default visibility), this array
160  *              contains two -1's.
161  * @param typeRange - a two element array describing the location of the 'class'
162  *              or 'interface' keyword in the type declaration - first and last character
163  *              positions.
164  * @param superclassRange - a two element array describing the location of the
165  *              superclass name in the type declaration - first and last character
166  *              positions or two -1's if a superclass is not present in the document.
167  * @param extendsRange - a two element array describing the location of the
168  *              'extends' keyword in the type declaration, including any surrounding
169  *              whitespace, or -1's if the 'extends' keyword is not present in the document.
170  * @param implementsList - an array of names of the interfaces this type implements
171  *              or extends, or <code>null</code> if this type does not implement or extend
172  *              any interfaces.
173  * @param implementsRange - a two element array describing the location of the
174  *              comment delimited list of interfaces this type implements or extends,
175  *              not including any surrounding whitespace, or -1's if no interface list
176  *              is present in the document.
177  * @param implementsKeywordRange - a two element array describing the location of the
178  *              'implements' keyword, including any surrounding whitespace, or -1's if no
179  *              'implements' keyword is present in the document.
180  * @param openBodyRange - a two element array describing the location of the
181  *      open brace of the type's body and whitespace following the type declaration
182  *              and preceeding the first member in the type.
183  * @param closeBodyRange - a two element array describing the source range of the
184  *              first new line or non whitespace character preceeding the close brace of the
185  *              type's body, up to the close brace
186  * @param isClass - true is the type is a class, false if it is an interface
187  */
188 DOMType(char[] document, int[] sourceRange, String name, int[] nameRange, int[] commentRange, int flags, int[] modifierRange, int[] typeRange, int[] superclassRange, int[] extendsRange, String[] implementsList, int[] implementsRange, int[] implementsKeywordRange, int[] openBodyRange, int[] closeBodyRange, boolean isClass) {
189         super(document, sourceRange, name, nameRange, commentRange, flags, modifierRange);
190
191         fTypeRange= typeRange;
192         setMask(MASK_TYPE_IS_CLASS, isClass);
193
194         fExtendsRange= extendsRange;
195         fImplementsRange= implementsKeywordRange;
196         fSuperclassRange= superclassRange;
197         fInterfacesRange= implementsRange;
198         fCloseBodyRange= closeBodyRange;
199         setMask(MASK_TYPE_HAS_SUPERCLASS, superclassRange[0] > 0);
200         setMask(MASK_TYPE_HAS_INTERFACES, implementsList != null);
201         fSuperInterfaces= implementsList;
202         fOpenBodyRange= openBodyRange;
203         fCloseBodyRange= closeBodyRange;
204         setMask(MASK_DETAILED_SOURCE_INDEXES, true);
205
206 }
207 /**
208  * Creates a new simple TYPE document fragment on the given range of the document.
209  *
210  * @param document - the document containing this node's original contents
211  * @param sourceRange - a two element array of integers describing the
212  *              entire inclusive source range of this node within its document.
213  *              Contents start on and include the character at the first position.
214  *              Contents end on and include the character at the last position.
215  *              An array of -1's indicates this node's contents do not exist
216  *              in the document.
217  * @param name - the identifier portion of the name of this node, or
218  *              <code>null</code> if this node does not have a name
219  * @param nameRange - a two element array of integers describing the
220  *              entire inclusive source range of this node's name within its document,
221  *              including any array qualifiers that might immediately follow the name
222  *              or -1's if this node does not have a name.
223  * @param flags - an integer representing the modifiers for this member. The
224  *              integer can be analyzed with org.eclipse.jdt.core.Flags
225  * @param implementsList - an array of names of the interfaces this type implements
226  *              or extends, or <code>null</code> if this type does not implement or extend
227  *              any interfaces.
228  * @param isClass - true is the type is a class, false if it is an interface
229  */
230 DOMType(char[] document, int[] sourceRange, String name, int[] nameRange, int flags, String[] implementsList, boolean isClass) {
231         this(document, sourceRange, name, nameRange, new int[] {-1, -1}, flags,
232                 new int[] {-1, -1}, new int[] {-1, -1}, new int[] {-1, -1}, new int[] {-1, -1},
233                 implementsList, new int[] {-1, -1}, new int[] {-1, -1}, new int[] {-1, -1}, new int[] {sourceRange[1], sourceRange[1]}, isClass);
234         setMask(MASK_DETAILED_SOURCE_INDEXES, false);
235 }
236 /**
237  * @see IDOMType#addSuperInterface(String)
238  */
239 public void addSuperInterface(String name) throws IllegalArgumentException {
240         if (name == null) {
241                 throw new IllegalArgumentException(Util.bind("dom.addNullInterface")); //$NON-NLS-1$
242         }
243         if (fSuperInterfaces == null) {
244                 fSuperInterfaces= new String[1];
245                 fSuperInterfaces[0]= name;
246         } else {
247                 fSuperInterfaces= appendString(fSuperInterfaces, name);
248         }
249         setSuperInterfaces(fSuperInterfaces);
250 }
251 /**
252  * @see DOMMember#appendMemberBodyContents(CharArrayBuffer)
253  */
254 protected void appendMemberBodyContents(CharArrayBuffer buffer) {
255         buffer.append(fDocument, fOpenBodyRange[0], fOpenBodyRange[1] + 1 - fOpenBodyRange[0]);
256         appendContentsOfChildren(buffer);
257         buffer.append(fDocument, fCloseBodyRange[0], fCloseBodyRange[1] + 1 - fCloseBodyRange[0]);
258         buffer.append(fDocument, fCloseBodyRange[1] + 1, fSourceRange[1] - fCloseBodyRange[1]);
259 }
260 /**
261  * @see DOMMember#appendMemberDeclarationContents(CharArrayBuffer )
262  */
263 protected void appendMemberDeclarationContents(CharArrayBuffer  buffer) {
264         
265         if (fTypeKeyword != null) {
266                 buffer.append(fTypeKeyword);
267                 buffer.append(fDocument, fTypeRange[1], fNameRange[0] - fTypeRange[1] );
268         } else {
269                 buffer.append(fDocument, fTypeRange[0], fTypeRange[1] + 1 - fTypeRange[0]);
270         }
271
272         buffer.append(getName());
273
274         if (isClass()) {
275                 boolean hasSuperclass = false, hasInterfaces = false;
276                 if (getMask(MASK_TYPE_HAS_SUPERCLASS)) {
277                         hasSuperclass = true;
278                         if (fExtendsRange[0] < 0) {
279                                 buffer.append(" extends "); //$NON-NLS-1$
280                         } else {
281                                 buffer.append(fDocument, fExtendsRange[0], fExtendsRange[1] + 1 - fExtendsRange[0]);
282                         }
283                         if (fSuperclass != null) {
284                                 buffer.append(fSuperclass);
285                         } else {
286                                 buffer.append(fDocument, fSuperclassRange[0], fSuperclassRange[1] + 1 - fSuperclassRange[0]);
287                         }
288                 }
289                 if (getMask(MASK_TYPE_HAS_INTERFACES)) {
290                         hasInterfaces = true;
291                         if (fImplementsRange[0] < 0) {
292                                 buffer.append(" implements "); //$NON-NLS-1$
293                         } else {
294                                 buffer.append(fDocument, fImplementsRange[0], fImplementsRange[1] + 1 - fImplementsRange[0]);
295                         }
296                         if (fInterfaces != null) {
297                                 buffer.append(fInterfaces);
298                         } else {
299                                 buffer.append(fDocument, fInterfacesRange[0], fInterfacesRange[1] + 1 - fInterfacesRange[0]);
300                         }
301                 }
302                 if (hasInterfaces) {
303                         if (fImplementsRange[0] < 0) {
304                                 buffer.append(' ');
305                         } else {
306                                 buffer.append(fDocument, fInterfacesRange[1] + 1, fOpenBodyRange[0] - fInterfacesRange[1] - 1);
307                         }
308                 } else {
309                         if (hasSuperclass) {
310                                 if (fSuperclassRange[0] < 0) {
311                                         buffer.append(' ');
312                                 } else {
313                                         buffer.append(fDocument, fSuperclassRange[1] + 1, fOpenBodyRange[0] - fSuperclassRange[1] - 1);
314                                 }
315                         } else {
316                                 buffer.append(fDocument, fNameRange[1] + 1, fOpenBodyRange[0] - fNameRange[1] - 1);
317                         }
318                 }
319         } else {
320                 if (getMask(MASK_TYPE_HAS_INTERFACES)) {
321                         if (fExtendsRange[0] < 0) {
322                                 buffer.append(" extends "); //$NON-NLS-1$
323                         } else {
324                                 buffer.append(fDocument, fExtendsRange[0], fExtendsRange[1] + 1 - fExtendsRange[0]);
325                         }
326                         if (fInterfaces != null) {
327                                 buffer.append(fInterfaces);
328                                 buffer.append(' ');
329                         } else {
330                                 buffer.append(fDocument, fInterfacesRange[0], fInterfacesRange[1] + 1 - fInterfacesRange[0]);
331                         }
332                 } else {
333                         buffer.append(fDocument, fNameRange[1] + 1, fOpenBodyRange[0] - fNameRange[1] - 1);
334                 }
335         }
336         
337 }
338 /**
339  * @see DOMNode#appendSimpleContents(CharArrayBuffer)
340  */
341 protected void appendSimpleContents(CharArrayBuffer buffer) {
342         // append eveything before my name
343         buffer.append(fDocument, fSourceRange[0], fNameRange[0] - fSourceRange[0]);
344         // append my name
345         buffer.append(fName);
346
347         
348         // append everything after my name and before my first child
349         buffer.append(fDocument, fNameRange[1] + 1, fOpenBodyRange[1] - fNameRange[1]);
350         // append my children
351         appendContentsOfChildren(buffer);
352         // append from my last child to my end
353         buffer.append(fDocument, fCloseBodyRange[0], fSourceRange[1] - fCloseBodyRange[0] + 1);
354
355
356 }
357 /**
358  * @see IDOMNode#canHaveChildren()
359  */
360 public boolean canHaveChildren() {
361         return true;
362 }
363 /**
364  * Returns the position of the closing brace for the body of this type.
365  * This value this method returns is only valid before the type has
366  * been normalized and is present only for normalization.
367  */
368 int getCloseBodyPosition() {
369         return fCloseBodyRange[0];
370 }
371 /**
372  * @see DOMNode#getDetailedNode()
373  */
374 //protected DOMNode getDetailedNode() {
375 //      return (DOMNode)getFactory().createType(getContents());
376 //}
377 /**
378  * @see DOMNode#getInsertionPosition()
379  */
380 public int getInsertionPosition() {
381         // this should return the position of the end of the last line separator before the closing brace of the type
382         // See PR 1GELSDQ: ITPJUI:WINNT - JDOM: IType.createMethod does not insert nicely for inner types
383         return fInsertionPosition;
384 }
385 /**
386  * @see IDOMNode#getJavaElement
387  */
388 public IJavaElement getJavaElement(IJavaElement parent) throws IllegalArgumentException {
389         if (parent.getElementType() == IJavaElement.TYPE) {
390                 return ((IType)parent).getType(getName());
391         } else if (parent.getElementType() == IJavaElement.COMPILATION_UNIT) {
392                 return ((ICompilationUnit)parent).getType(getName());
393         } else {
394                 throw new IllegalArgumentException(Util.bind("element.illegalParent")); //$NON-NLS-1$
395         }
396 }
397 /**
398  * @see DOMMember#getMemberDeclarationStartPosition()
399  */
400 protected int getMemberDeclarationStartPosition() {
401         return fTypeRange[0];
402 }
403 /**
404  * @see IDOMNode#getNodeType()
405  */
406 public int getNodeType() {
407         return IDOMNode.TYPE;
408 }
409 /**
410  * Answers the open body range end position.
411  */
412 int getOpenBodyEnd() {
413         return fOpenBodyRange[1];
414 }
415 /**
416  * @see IDOMType#getSuperclass()
417  */
418 public String getSuperclass() {
419         becomeDetailed();
420         if (getMask(MASK_TYPE_HAS_SUPERCLASS)) {
421                 if (fSuperclass != null) {
422                         return fSuperclass;
423                 } else {
424                         return CharArrayOps.substring(fDocument, fSuperclassRange[0], fSuperclassRange[1] + 1 - fSuperclassRange[0]);
425                 }
426         } else {
427                 return null;
428         }
429 }
430 /**
431  * @see IDOMType#getSuperInterfaces()
432  */
433 public String[] getSuperInterfaces() {
434         return fSuperInterfaces;
435 }
436 /**
437  * @see IDOMNode
438  */
439 public boolean isAllowableChild(IDOMNode node) {
440         if (node != null) {
441                 int type= node.getNodeType();
442                 return type == IDOMNode.TYPE || type == IDOMNode.FIELD|| type == IDOMNode.METHOD || 
443                         type == IDOMNode.INITIALIZER; 
444         } else {
445                 return false;
446         }
447         
448 }
449 /**
450  * @see IDOMType#isClass()
451  */
452 public boolean isClass() {
453         return getMask(MASK_TYPE_IS_CLASS);
454 }
455 /**
456  * @see DOMNode
457  */
458 protected DOMNode newDOMNode() {
459         return new DOMType();
460 }
461 /**
462  * Normalizes this <code>DOMNode</code>'s source positions to include whitespace preceeding
463  * the node on the line on which the node starts, and all whitespace after the node up to
464  * the next node's start
465  */
466 void normalize(ILineStartFinder finder) {
467         // perform final changes to the open and close body ranges
468         int openBodyEnd, openBodyStart, closeBodyStart, closeBodyEnd;
469         DOMNode first = (DOMNode) getFirstChild();
470         DOMNode lastNode = null;
471         // look for the open body
472         Scanner scanner = new Scanner();
473         scanner.setSource(fDocument);
474         scanner.resetTo(fNameRange[1] + 1, fDocument.length);
475         
476         try {
477                 int currentToken = scanner.getNextToken();
478                 while(currentToken != ITerminalSymbols.TokenNameLBRACE &&
479                                 currentToken != ITerminalSymbols.TokenNameEOF) {
480                         currentToken = scanner.getNextToken();
481                 }
482                 if(currentToken == ITerminalSymbols.TokenNameLBRACE) {          
483                         openBodyEnd = scanner.currentPosition - 1;
484                         openBodyStart = scanner.startPosition;
485                 } else {
486                         openBodyEnd = fDocument.length;
487                         openBodyStart = fDocument.length;
488                 }
489         } catch(InvalidInputException e) {
490                 openBodyEnd = fDocument.length;
491                 openBodyStart = fDocument.length;
492         }
493         if (first != null) {
494                 int lineStart = finder.getLineStart(first.getStartPosition());
495                 if (lineStart > openBodyEnd) {
496                         openBodyEnd = lineStart - 1;
497                 } else {
498                         openBodyEnd = first.getStartPosition() - 1;
499                 }               
500                 lastNode = (DOMNode) first.getNextNode();
501                 if (lastNode == null) {
502                         lastNode = first;
503                 } else {
504                         while (lastNode.getNextNode() != null) {
505                                 lastNode = (DOMNode) lastNode.getNextNode();
506                         }
507                 }
508                 scanner.setSource(fDocument);
509                 scanner.resetTo(lastNode.getEndPosition() + 1, fDocument.length);
510                 try {
511                         int currentToken = scanner.getNextToken();
512                         while(currentToken != ITerminalSymbols.TokenNameRBRACE &&
513                                         currentToken != ITerminalSymbols.TokenNameEOF) {
514                                 currentToken = scanner.getNextToken();
515                         }
516                         if(currentToken == ITerminalSymbols.TokenNameRBRACE) {          
517                                 closeBodyStart = scanner.startPosition;
518                                 closeBodyEnd = scanner.currentPosition - 1;
519                         } else {
520                                 closeBodyStart = fDocument.length;
521                                 closeBodyEnd = fDocument.length;
522                         }
523                 } catch(InvalidInputException e) {
524                         closeBodyStart = fDocument.length;
525                         closeBodyEnd = fDocument.length;
526                 }
527         } else {
528                 scanner.resetTo(openBodyEnd, fDocument.length);
529                 try {
530                         int currentToken = scanner.getNextToken();
531                         while(currentToken != ITerminalSymbols.TokenNameRBRACE &&
532                                         currentToken != ITerminalSymbols.TokenNameEOF) {
533                                 currentToken = scanner.getNextToken();
534                         }
535                         if(currentToken == ITerminalSymbols.TokenNameRBRACE) {          
536                                 closeBodyStart = scanner.startPosition;
537                                 closeBodyEnd = scanner.currentPosition - 1;
538                         } else {
539                                 closeBodyStart = fDocument.length;
540                                 closeBodyEnd = fDocument.length;
541                         }
542                 } catch(InvalidInputException e) {
543                         closeBodyStart = fDocument.length;
544                         closeBodyEnd = fDocument.length;
545                 }
546                 openBodyEnd = closeBodyEnd - 1;
547         }
548         setOpenBodyRangeEnd(openBodyEnd);
549         setOpenBodyRangeStart(openBodyStart);
550         setCloseBodyRangeStart(closeBodyStart);
551         setCloseBodyRangeEnd(closeBodyEnd);
552         fInsertionPosition = finder.getLineStart(closeBodyStart);
553         if (lastNode != null && fInsertionPosition < lastNode.getEndPosition()) {
554                 fInsertionPosition = getCloseBodyPosition();
555         }
556         if (fInsertionPosition <= openBodyEnd) {
557                 fInsertionPosition = getCloseBodyPosition();
558         }
559         super.normalize(finder);
560 }
561
562 /**
563  * Normalizes this <code>DOMNode</code>'s end position.
564  */
565 void normalizeEndPosition(ILineStartFinder finder, DOMNode next) {
566         if (next == null) {
567                 // this node's end position includes all of the characters up
568                 // to the end of the enclosing node
569                 DOMNode parent = (DOMNode) getParent();
570                 if (parent == null || parent instanceof DOMCompilationUnit) {
571                         setSourceRangeEnd(fDocument.length - 1);
572                 } else {
573                         // parent is a type
574                         setSourceRangeEnd(((DOMType)parent).getCloseBodyPosition() - 1);
575                 }
576         } else {
577                 // this node's end position is just before the start of the next node
578                 next.normalizeStartPosition(getEndPosition(), finder);
579                 setSourceRangeEnd(next.getStartPosition() - 1);
580         }
581 }
582
583 /**
584  * Offsets all the source indexes in this node by the given amount.
585  */
586 protected void offset(int offset) {
587         super.offset(offset);
588         offsetRange(fCloseBodyRange, offset);
589         offsetRange(fExtendsRange, offset);
590         offsetRange(fImplementsRange, offset);
591         offsetRange(fInterfacesRange, offset);
592         offsetRange(fOpenBodyRange, offset);
593         offsetRange(fSuperclassRange, offset);
594         offsetRange(fTypeRange, offset);
595 }
596 /**
597  * @see IDOMType#setClass(boolean)
598  */
599 public void setClass(boolean b) {
600         becomeDetailed();
601         fragment();
602         setMask(MASK_TYPE_IS_CLASS, b);
603         if (b) {
604                 fTypeKeyword= "class"; //$NON-NLS-1$
605         } else {
606                 fTypeKeyword= "interface"; //$NON-NLS-1$
607                 setSuperclass(null);
608         }
609 }
610 /**
611  * Sets the end of the close body range 
612  */
613 void setCloseBodyRangeEnd(int end) {
614         fCloseBodyRange[1] = end;
615 }
616 /**
617  * Sets the start of the close body range 
618  */
619 void setCloseBodyRangeStart(int start) {
620         fCloseBodyRange[0] = start;
621 }
622 /**
623  * Sets the name of this node.
624  *
625  * <p>When the name of a type is set, all of its constructors must be marked
626  * as fragmented, since the names of the constructors must reflect the name
627  * of this type.
628  *
629  * @see IDOMNode#setName(char[])
630  */
631 public void setName(String name) throws IllegalArgumentException {
632         if (name == null) {
633                 throw new IllegalArgumentException(Util.bind("element.nullName")); //$NON-NLS-1$
634         }
635         super.setName(name);
636         Enumeration children= getChildren();
637         while (children.hasMoreElements()) {
638                 IDOMNode child= (IDOMNode)children.nextElement();
639                 if (child.getNodeType() == IDOMNode.METHOD && ((IDOMMethod)child).isConstructor()) {
640                         ((DOMNode)child).fragment();
641                 }
642         }
643 }
644 /**
645  * Sets the end of the open body range 
646  */
647 void setOpenBodyRangeEnd(int end) {
648         fOpenBodyRange[1] = end;
649 }
650 /**
651  * Sets the start of the open body range 
652  */
653 void setOpenBodyRangeStart(int start) {
654         fOpenBodyRange[0] = start;
655 }
656 /**
657  * @see IDOMType#setSuperclass(char[])
658  */
659 public void setSuperclass(String superclassName) {
660         becomeDetailed();
661         fragment();
662         fSuperclass= superclassName;
663         setMask(MASK_TYPE_HAS_SUPERCLASS, superclassName != null);
664 }
665 /**
666  * @see IDOMType#setSuperInterfaces(String[])
667  */
668 public void setSuperInterfaces(String[] names) {
669         becomeDetailed();
670         if (names == null) {
671                 throw new IllegalArgumentException(Util.bind("dom.nullInterfaces")); //$NON-NLS-1$
672         }
673         fragment();
674         fSuperInterfaces= names;
675         if (names == null || names.length == 0) {
676                 fInterfaces= null;
677                 fSuperInterfaces= null;
678                 setMask(MASK_TYPE_HAS_INTERFACES, false);
679         } else {
680                 setMask(MASK_TYPE_HAS_INTERFACES, true);
681                 CharArrayBuffer buffer = new CharArrayBuffer();
682                 for (int i = 0; i < names.length; i++) {
683                         if (i > 0) {
684                                 buffer.append(", "); //$NON-NLS-1$
685                         }
686                         buffer.append(names[i]);
687                 }
688                 fInterfaces = buffer.getContents();
689         }
690 }
691 /**
692  * Sets the type keyword
693  */
694 void setTypeKeyword(String keyword) {
695         fTypeKeyword = keyword;
696 }
697 /**
698  * @see DOMNode#shareContents(DOMNode)
699  */
700 protected void shareContents(DOMNode node) {
701         super.shareContents(node);
702         DOMType type= (DOMType)node;
703         fCloseBodyRange= rangeCopy(type.fCloseBodyRange);
704         fExtendsRange= type.fExtendsRange;
705         fImplementsRange= rangeCopy(type.fImplementsRange);
706         fInterfaces= type.fInterfaces;
707         fInterfacesRange= rangeCopy(type.fInterfacesRange);
708         fOpenBodyRange= rangeCopy(type.fOpenBodyRange);
709         fSuperclass= type.fSuperclass;
710         fSuperclassRange= rangeCopy(type.fSuperclassRange);
711         fSuperInterfaces= type.fSuperInterfaces;
712         fTypeKeyword= type.fTypeKeyword;
713         fTypeRange= rangeCopy(type.fTypeRange);
714 }
715 /**
716  * @see IDOMNode#toString()
717  */
718 public String toString() {
719         return "TYPE: " + getName(); //$NON-NLS-1$
720 }
721 }