3459e754575be12fe9eef5c3d05ce905f79056b1
[phpeclipse.git] /
1 /*
2  * (c) Copyright IBM Corp. 2000, 2001.
3  * All Rights Reserved.
4  */
5 package net.sourceforge.phpdt.internal.corext.codemanipulation;
6
7 import java.util.Arrays;
8 //import java.util.Comparator;
9 import java.util.List;
10 import java.util.StringTokenizer;
11
12 import net.sourceforge.phpdt.core.Flags;
13 import net.sourceforge.phpdt.core.IBuffer;
14 import net.sourceforge.phpdt.core.ICodeFormatter;
15 import net.sourceforge.phpdt.core.ICompilationUnit;
16 import net.sourceforge.phpdt.core.IJavaElement;
17 import net.sourceforge.phpdt.core.IJavaProject;
18 import net.sourceforge.phpdt.core.IMethod;
19 import net.sourceforge.phpdt.core.IPackageFragment;
20 import net.sourceforge.phpdt.core.IType;
21 import net.sourceforge.phpdt.core.JavaCore;
22 import net.sourceforge.phpdt.core.JavaModelException;
23 import net.sourceforge.phpdt.core.Signature;
24 import net.sourceforge.phpdt.core.ToolFactory;
25 import net.sourceforge.phpdt.internal.corext.template.php.CodeTemplateContext;
26 import net.sourceforge.phpdt.internal.corext.template.php.CodeTemplateContextType;
27 import net.sourceforge.phpdt.internal.corext.util.JavaModelUtil;
28 import net.sourceforge.phpdt.internal.corext.util.Strings;
29 import net.sourceforge.phpdt.internal.corext.util.PHPUIStatus;
30 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
31 import net.sourceforge.phpeclipse.ui.WebUI;
32
33 import org.eclipse.core.runtime.CoreException;
34 import org.eclipse.core.runtime.IStatus;
35 import org.eclipse.core.runtime.Status;
36 import org.eclipse.jface.text.BadLocationException;
37 import org.eclipse.jface.text.Document;
38 import org.eclipse.jface.text.IDocument;
39 import org.eclipse.jface.text.IRegion;
40 import org.eclipse.jface.text.templates.Template;
41 import org.eclipse.jface.text.templates.TemplateBuffer;
42 import org.eclipse.jface.text.templates.TemplateException;
43 import org.eclipse.jface.text.templates.TemplateVariable;
44 import org.eclipse.swt.SWT;
45
46 public class StubUtility {
47
48         public static class GenStubSettings extends CodeGenerationSettings {
49
50                 public boolean callSuper;
51
52                 public boolean methodOverwrites;
53
54                 public boolean noBody;
55
56                 public int methodModifiers;
57
58                 public GenStubSettings(CodeGenerationSettings settings) {
59                         settings.setSettings(this);
60                         methodModifiers = -1;
61                 }
62
63         }
64
65         private static final String[] EMPTY = new String[0];
66
67         /**
68          * Generates a method stub including the method comment. Given a template
69          * method, a stub with the same signature will be constructed so it can be
70          * added to a type. The method body will be empty or contain a return or
71          * super call.
72          * 
73          * @param destTypeName
74          *            The name of the type to which the method will be added to
75          * @param method
76          *            A method template (method belongs to different type than the
77          *            parent)
78          * @param definingType
79          *            The type that defines the method.
80          * @param settings
81          *            Options as defined above (<code>GenStubSettings</code>)
82          * @param imports
83          *            Imports required by the stub are added to the imports
84          *            structure. If imports structure is <code>null</code> all
85          *            type names are qualified.
86          * @throws JavaModelException
87          */
88         public static String genStub(ICompilationUnit cu, String destTypeName,
89                         IMethod method, IType definingType, GenStubSettings settings)
90                         throws CoreException {
91                 // IImportsStructure imports) throws CoreException {
92                 String methName = method.getElementName();
93                 String[] paramNames = suggestArgumentNames(method.getJavaProject(),
94                                 method.getParameterNames());
95                 String returnType = method.isConstructor() ? null : method
96                                 .getReturnType();
97                 String lineDelimiter = String.valueOf('\n'); // reformatting required
98
99                 StringBuffer buf = new StringBuffer();
100                 // add method comment
101                 if (settings.createComments && cu != null) {
102                         IMethod overridden = null;
103                         if (settings.methodOverwrites && returnType != null) {
104                                 overridden = JavaModelUtil.findMethod(methName, method
105                                                 .getParameterTypes(), false, definingType.getMethods());
106                         }
107                         String comment = getMethodComment(cu, destTypeName, methName,
108                                         paramNames, method.getExceptionTypes(), returnType,
109                                         overridden, lineDelimiter);
110                         if (comment != null) {
111                                 buf.append(comment);
112                         } else {
113                                 buf.append("/**").append(lineDelimiter); //$NON-NLS-1$
114                                 buf.append(" *").append(lineDelimiter); //$NON-NLS-1$
115                                 buf.append(" */").append(lineDelimiter); //$NON-NLS-1$                                                  
116                         }
117                         buf.append(lineDelimiter);
118                 }
119                 // add method declaration
120                 String bodyContent = null;
121                 if (!settings.noBody) {
122                         String bodyStatement = getDefaultMethodBodyStatement(methName,
123                                         paramNames, returnType, settings.callSuper);
124                         bodyContent = getMethodBodyContent(returnType == null, method
125                                         .getJavaProject(), destTypeName, methName, bodyStatement,
126                                         lineDelimiter);
127                         if (bodyContent == null) {
128                                 bodyContent = ""; //$NON-NLS-1$
129                         }
130                 }
131                 int flags = settings.methodModifiers;
132                 if (flags == -1) {
133                         flags = method.getFlags();
134                 }
135
136                 genMethodDeclaration(destTypeName, method, flags, bodyContent, buf); // imports,
137                                                                                                                                                                 // buf);
138                 return buf.toString();
139         }
140
141         /**
142          * Generates a method stub not including the method comment. Given a
143          * template method and the body content, a stub with the same signature will
144          * be constructed so it can be added to a type.
145          * 
146          * @param destTypeName
147          *            The name of the type to which the method will be added to
148          * @param method
149          *            A method template (method belongs to different type than the
150          *            parent)
151          * @param bodyContent
152          *            Content of the body
153          * @param imports
154          *            Imports required by the stub are added to the imports
155          *            structure. If imports structure is <code>null</code> all
156          *            type names are qualified.
157          * @param buf
158          *            The buffer to append the gerenated code.
159          * @throws JavaModelException
160          */
161         public static void genMethodDeclaration(String destTypeName,
162                         IMethod method, String bodyContent, StringBuffer buf)
163                         throws CoreException { // IImportsStructure imports, StringBuffer
164                                                                         // buf) throws CoreException {
165                 genMethodDeclaration(destTypeName, method, method.getFlags(),
166                                 bodyContent, buf);
167         }
168
169         /**
170          * Generates a method stub not including the method comment. Given a
171          * template method and the body content, a stub with the same signature will
172          * be constructed so it can be added to a type.
173          * 
174          * @param destTypeName
175          *            The name of the type to which the method will be added to
176          * @param method
177          *            A method template (method belongs to different type than the
178          *            parent)
179          * @param bodyContent
180          *            Content of the body
181          * @param imports
182          *            Imports required by the stub are added to the imports
183          *            structure. If imports structure is <code>null</code> all
184          *            type names are qualified.
185          * @param buf
186          *            The buffer to append the gerenated code.
187          * @throws JavaModelException
188          */
189         public static void genMethodDeclaration(String destTypeName,
190                         IMethod method, int flags, String bodyContent, StringBuffer buf)
191                         throws CoreException {
192                 // IImportsStructure imports, StringBuffer buf) throws CoreException {
193                 IType parentType = method.getDeclaringType();
194                 String methodName = method.getElementName();
195                 String[] paramTypes = method.getParameterTypes();
196                 String[] paramNames = suggestArgumentNames(parentType.getJavaProject(),
197                                 method.getParameterNames());
198
199                 String[] excTypes = method.getExceptionTypes();
200
201                 boolean isConstructor = method.isConstructor();
202                 String retTypeSig = isConstructor ? null : method.getReturnType();
203
204                 int lastParam = paramTypes.length - 1;
205
206                 if (Flags.isPublic(flags)
207                                 || (parentType.isInterface() && bodyContent != null)) {
208                         buf.append("public "); //$NON-NLS-1$
209                 } else if (Flags.isProtected(flags)) {
210                         buf.append("protected "); //$NON-NLS-1$
211                 } else if (Flags.isPrivate(flags)) {
212                         buf.append("private "); //$NON-NLS-1$
213                 }
214                 // if (Flags.isSynchronized(flags)) {
215                 // buf.append("synchronized "); //$NON-NLS-1$
216                 // }
217                 // if (Flags.isVolatile(flags)) {
218                 // buf.append("volatile "); //$NON-NLS-1$
219                 // }
220                 // if (Flags.isStrictfp(flags)) {
221                 // buf.append("strictfp "); //$NON-NLS-1$
222                 // }
223                 if (Flags.isStatic(flags)) {
224                         buf.append("static "); //$NON-NLS-1$
225                 }
226
227                 if (isConstructor) {
228                         buf.append(destTypeName);
229                 } else {
230                         String retTypeFrm;
231                         if (!isPrimitiveType(retTypeSig)) {
232                                 retTypeFrm = resolveAndAdd(retTypeSig, parentType);
233                         } else {
234                                 retTypeFrm = Signature.toString(retTypeSig);
235                         }
236                         buf.append(retTypeFrm);
237                         buf.append(' ');
238                         buf.append(methodName);
239                 }
240                 buf.append('(');
241                 for (int i = 0; i <= lastParam; i++) {
242                         String paramTypeSig = paramTypes[i];
243                         String paramTypeFrm;
244
245                         if (!isPrimitiveType(paramTypeSig)) {
246                                 paramTypeFrm = resolveAndAdd(paramTypeSig, parentType);
247                         } else {
248                                 paramTypeFrm = Signature.toString(paramTypeSig);
249                         }
250                         buf.append(paramTypeFrm);
251                         buf.append(' ');
252                         buf.append(paramNames[i]);
253                         if (i < lastParam) {
254                                 buf.append(", "); //$NON-NLS-1$
255                         }
256                 }
257                 buf.append(')');
258
259                 int lastExc = excTypes.length - 1;
260                 if (lastExc >= 0) {
261                         buf.append(" throws "); //$NON-NLS-1$
262                         for (int i = 0; i <= lastExc; i++) {
263                                 String excTypeSig = excTypes[i];
264                                 String excTypeFrm = resolveAndAdd(excTypeSig, parentType);
265                                 buf.append(excTypeFrm);
266                                 if (i < lastExc) {
267                                         buf.append(", "); //$NON-NLS-1$
268                                 }
269                         }
270                 }
271                 if (bodyContent == null) {
272                         buf.append(";\n\n"); //$NON-NLS-1$
273                 } else {
274                         buf.append(" {\n\t"); //$NON-NLS-1$
275                         if ((bodyContent != null) && (bodyContent.length() > 0)) {
276                                 buf.append(bodyContent);
277                                 buf.append('\n');
278                         }
279                         buf.append("}\n"); //$NON-NLS-1$
280                 }
281         }
282
283         public static String getDefaultMethodBodyStatement(String methodName,
284                         String[] paramNames, String retTypeSig, boolean callSuper) {
285                 StringBuffer buf = new StringBuffer();
286                 if (callSuper) {
287                         if (retTypeSig != null) {
288                                 if (!Signature.SIG_VOID.equals(retTypeSig)) {
289                                         buf.append("return "); //$NON-NLS-1$
290                                 }
291                                 buf.append("super."); //$NON-NLS-1$
292                                 buf.append(methodName);
293                         } else {
294                                 buf.append("super"); //$NON-NLS-1$
295                         }
296                         buf.append('(');
297                         for (int i = 0; i < paramNames.length; i++) {
298                                 if (i > 0) {
299                                         buf.append(", "); //$NON-NLS-1$
300                                 }
301                                 buf.append(paramNames[i]);
302                         }
303                         buf.append(");"); //$NON-NLS-1$
304                 } else {
305                         if (retTypeSig != null && !retTypeSig.equals(Signature.SIG_VOID)) {
306                                 if (!isPrimitiveType(retTypeSig)
307                                                 || Signature.getArrayCount(retTypeSig) > 0) {
308                                         buf.append("return null;"); //$NON-NLS-1$
309                                 } else if (retTypeSig.equals(Signature.SIG_BOOLEAN)) {
310                                         buf.append("return false;"); //$NON-NLS-1$
311                                 } else {
312                                         buf.append("return 0;"); //$NON-NLS-1$
313                                 }
314                         }
315                 }
316                 return buf.toString();
317         }
318
319         public static String getMethodBodyContent(boolean isConstructor,
320                         IJavaProject project, String destTypeName, String methodName,
321                         String bodyStatement, String lineDelimiter) throws CoreException {
322                 String templateName = isConstructor ? CodeTemplateContextType.CONSTRUCTORSTUB
323                                 : CodeTemplateContextType.METHODSTUB;
324                 Template template = WebUI.getDefault()
325                                 .getCodeTemplateStore().findTemplate(templateName);
326                 if (template == null) {
327                         return bodyStatement;
328                 }
329                 CodeTemplateContext context = new CodeTemplateContext(template
330                                 .getContextTypeId(), project, lineDelimiter);
331                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
332                                 methodName);
333                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE,
334                                 destTypeName);
335                 context.setVariable(CodeTemplateContextType.BODY_STATEMENT,
336                                 bodyStatement);
337                 String str = evaluateTemplate(context, template);
338                 if (str == null && !Strings.containsOnlyWhitespaces(bodyStatement)) {
339                         return bodyStatement;
340                 }
341                 return str;
342         }
343
344         public static String getGetterMethodBodyContent(IJavaProject project,
345                         String destTypeName, String methodName, String fieldName,
346                         String lineDelimiter) throws CoreException {
347                 String templateName = CodeTemplateContextType.GETTERSTUB;
348                 Template template = WebUI.getDefault()
349                                 .getCodeTemplateStore().findTemplate(templateName);
350                 if (template == null) {
351                         return null;
352                 }
353                 CodeTemplateContext context = new CodeTemplateContext(template
354                                 .getContextTypeId(), project, lineDelimiter);
355                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
356                                 methodName);
357                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE,
358                                 destTypeName);
359                 context.setVariable(CodeTemplateContextType.FIELD, fieldName);
360
361                 return evaluateTemplate(context, template);
362         }
363
364         public static String getSetterMethodBodyContent(IJavaProject project,
365                         String destTypeName, String methodName, String fieldName,
366                         String paramName, String lineDelimiter) throws CoreException {
367                 String templateName = CodeTemplateContextType.SETTERSTUB;
368                 Template template = WebUI.getDefault()
369                                 .getCodeTemplateStore().findTemplate(templateName);
370                 if (template == null) {
371                         return null;
372                 }
373                 CodeTemplateContext context = new CodeTemplateContext(template
374                                 .getContextTypeId(), project, lineDelimiter);
375                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
376                                 methodName);
377                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE,
378                                 destTypeName);
379                 context.setVariable(CodeTemplateContextType.FIELD, fieldName);
380                 context.setVariable(CodeTemplateContextType.FIELD_TYPE, fieldName);
381                 context.setVariable(CodeTemplateContextType.PARAM, paramName);
382
383                 return evaluateTemplate(context, template);
384         }
385
386         public static String getCatchBodyContent(ICompilationUnit cu,
387                         String exceptionType, String variableName, String lineDelimiter)
388                         throws CoreException {
389                 Template template = WebUI.getDefault()
390                                 .getCodeTemplateStore().findTemplate(
391                                                 CodeTemplateContextType.CATCHBLOCK);
392                 if (template == null) {
393                         return null;
394                 }
395
396                 CodeTemplateContext context = new CodeTemplateContext(template
397                                 .getContextTypeId(), cu.getJavaProject(), lineDelimiter);
398                 context.setVariable(CodeTemplateContextType.EXCEPTION_TYPE,
399                                 exceptionType);
400                 context
401                                 .setVariable(CodeTemplateContextType.EXCEPTION_VAR,
402                                                 variableName); //$NON-NLS-1$
403                 return evaluateTemplate(context, template);
404         }
405
406         /**
407          * @see net.sourceforge.phpdt.ui.CodeGeneration#getTypeComment(ICompilationUnit,
408          *      String, String)
409          */
410         public static String getCompilationUnitContent(ICompilationUnit cu,
411                         String typeComment, String typeContent, String lineDelimiter)
412                         throws CoreException {
413                 IPackageFragment pack = (IPackageFragment) cu.getParent();
414                 String packDecl = pack.isDefaultPackage() ? "" : "package " + pack.getElementName() + ';'; //$NON-NLS-1$ //$NON-NLS-2$
415
416                 Template template = WebUI.getDefault()
417                                 .getCodeTemplateStore().findTemplate(
418                                                 CodeTemplateContextType.NEWTYPE);
419                 if (template == null) {
420                         return null;
421                 }
422
423                 IJavaProject project = cu.getJavaProject();
424                 CodeTemplateContext context = new CodeTemplateContext(template
425                                 .getContextTypeId(), project, lineDelimiter);
426                 context.setCompilationUnitVariables(cu);
427                 context.setVariable(CodeTemplateContextType.PACKAGE_DECLARATION,
428                                 packDecl);
429                 context.setVariable(CodeTemplateContextType.TYPE_COMMENT,
430                                 typeComment != null ? typeComment : ""); //$NON-NLS-1$
431                 context.setVariable(CodeTemplateContextType.TYPE_DECLARATION,
432                                 typeContent);
433                 context.setVariable(CodeTemplateContextType.TYPENAME, Signature
434                                 .getQualifier(cu.getElementName()));
435                 return evaluateTemplate(context, template);
436         }
437
438         /*
439          * @see net.sourceforge.phpdt.ui.CodeGeneration#getTypeComment(ICompilationUnit,
440          *      String, String)
441          */
442         public static String getTypeComment(ICompilationUnit cu,
443                         String typeQualifiedName, String lineDelim) throws CoreException {
444                 Template template = WebUI.getDefault()
445                                 .getCodeTemplateStore().findTemplate(
446                                                 CodeTemplateContextType.TYPECOMMENT);
447                 if (template == null) {
448                         return null;
449                 }
450                 CodeTemplateContext context = new CodeTemplateContext(template
451                                 .getContextTypeId(), cu.getJavaProject(), lineDelim);
452                 context.setCompilationUnitVariables(cu);
453                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE, Signature
454                                 .getQualifier(typeQualifiedName));
455                 context.setVariable(CodeTemplateContextType.TYPENAME, Signature
456                                 .getSimpleName(typeQualifiedName));
457                 return evaluateTemplate(context, template);
458         }
459
460         // private static String[] getParameterTypesQualifiedNames(IMethodBinding
461         // binding) {
462         // ITypeBinding[] typeBindings= binding.getParameterTypes();
463         // String[] result= new String[typeBindings.length];
464         // for (int i= 0; i < result.length; i++) {
465         // result[i]= typeBindings[i].getQualifiedName();
466         // }
467         // return result;
468         // }
469
470 //      private static String getSeeTag(String declaringClassQualifiedName,
471 //                      String methodName, String[] parameterTypesQualifiedNames) {
472 //              StringBuffer buf = new StringBuffer();
473 //              buf.append("@see "); //$NON-NLS-1$
474 //              buf.append(declaringClassQualifiedName);
475 //              buf.append('#');
476 //              buf.append(methodName);
477 //              buf.append('(');
478 //              for (int i = 0; i < parameterTypesQualifiedNames.length; i++) {
479 //                      if (i > 0) {
480 //                              buf.append(", "); //$NON-NLS-1$
481 //                      }
482 //                      buf.append(parameterTypesQualifiedNames[i]);
483 //              }
484 //              buf.append(')');
485 //              return buf.toString();
486 //      }
487
488         private static String getSeeTag(IMethod overridden)
489                         throws JavaModelException {
490                 IType declaringType = overridden.getDeclaringType();
491                 StringBuffer buf = new StringBuffer();
492                 buf.append("@see "); //$NON-NLS-1$
493                 buf.append(declaringType.getFullyQualifiedName('.'));
494                 buf.append('#');
495                 buf.append(overridden.getElementName());
496                 buf.append('(');
497                 String[] paramTypes = overridden.getParameterTypes();
498                 for (int i = 0; i < paramTypes.length; i++) {
499                         if (i > 0) {
500                                 buf.append(", "); //$NON-NLS-1$
501                         }
502                         String curr = paramTypes[i];
503                         buf.append(JavaModelUtil.getResolvedTypeName(curr, declaringType));
504                         int arrayCount = Signature.getArrayCount(curr);
505                         while (arrayCount > 0) {
506                                 buf.append("[]"); //$NON-NLS-1$
507                                 arrayCount--;
508                         }
509                 }
510                 buf.append(')');
511                 return buf.toString();
512         }
513
514         /**
515          * @see net.sourceforge.phpdt.ui.CodeGeneration#getMethodComment(IMethod,IMethod,String)
516          */
517         public static String getMethodComment(IMethod method, IMethod overridden,
518                         String lineDelimiter) throws CoreException {
519                 String retType = method.isConstructor() ? null : method.getReturnType();
520                 String[] paramNames = method.getParameterNames();
521
522                 return getMethodComment(method.getCompilationUnit(), method
523                                 .getDeclaringType().getElementName(), method.getElementName(),
524                                 paramNames, method.getExceptionTypes(), retType, overridden,
525                                 lineDelimiter);
526         }
527
528         /**
529          * @see net.sourceforge.phpdt.ui.CodeGeneration#getMethodComment(ICompilationUnit,
530          *      String, String, String[], String[], String, IMethod, String)
531          */
532         public static String getMethodComment(ICompilationUnit cu, String typeName,
533                         String methodName, String[] paramNames, String[] excTypeSig,
534                         String retTypeSig, IMethod overridden, String lineDelimiter)
535                         throws CoreException {
536                 String templateName = CodeTemplateContextType.METHODCOMMENT;
537                 if (retTypeSig == null) {
538                         templateName = CodeTemplateContextType.CONSTRUCTORCOMMENT;
539                 } else if (overridden != null) {
540                         templateName = CodeTemplateContextType.OVERRIDECOMMENT;
541                 }
542                 Template template = WebUI.getDefault()
543                                 .getCodeTemplateStore().findTemplate(templateName);
544                 if (template == null) {
545                         return null;
546                 }
547                 CodeTemplateContext context = new CodeTemplateContext(template
548                                 .getContextTypeId(), cu.getJavaProject(), lineDelimiter);
549                 context.setCompilationUnitVariables(cu);
550                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE, typeName);
551                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
552                                 methodName);
553
554                 if (retTypeSig != null) {
555                         context.setVariable(CodeTemplateContextType.RETURN_TYPE, Signature
556                                         .toString(retTypeSig));
557                 }
558                 if (overridden != null) {
559                         context.setVariable(CodeTemplateContextType.SEE_TAG,
560                                         getSeeTag(overridden));
561                 }
562                 TemplateBuffer buffer;
563                 try {
564                         buffer = context.evaluate(template);
565                 } catch (BadLocationException e) {
566                         throw new CoreException(Status.CANCEL_STATUS);
567                 } catch (TemplateException e) {
568                         throw new CoreException(Status.CANCEL_STATUS);
569                 }
570                 if (buffer == null) {
571                         return null;
572                 }
573
574                 String str = buffer.getString();
575                 if (Strings.containsOnlyWhitespaces(str)) {
576                         return null;
577                 }
578                 TemplateVariable position = findTagVariable(buffer); // look if
579                                                                                                                                 // Javadoc tags
580                                                                                                                                 // have to be
581                                                                                                                                 // added
582                 if (position == null) {
583                         return str;
584                 }
585
586                 IDocument textBuffer = new Document(str);
587                 String[] exceptionNames = new String[excTypeSig.length];
588                 for (int i = 0; i < excTypeSig.length; i++) {
589                         exceptionNames[i] = Signature.toString(excTypeSig[i]);
590                 }
591                 String returnType = retTypeSig != null ? Signature.toString(retTypeSig)
592                                 : null;
593                 int[] tagOffsets = position.getOffsets();
594                 for (int i = tagOffsets.length - 1; i >= 0; i--) { // from last to
595                                                                                                                         // first
596                         try {
597                                 insertTag(textBuffer, tagOffsets[i], position.getLength(),
598                                                 paramNames, exceptionNames, returnType, false,
599                                                 lineDelimiter);
600                         } catch (BadLocationException e) {
601                                 throw new CoreException(PHPUIStatus.createError(IStatus.ERROR,
602                                                 e));
603                         }
604                 }
605                 return textBuffer.get();
606         }
607
608         public static String getFieldComment(ICompilationUnit cu, String typeName,
609                         String fieldName, String lineDelimiter) throws CoreException {
610                 Template template = WebUI.getDefault()
611                                 .getCodeTemplateStore().findTemplate(
612                                                 CodeTemplateContextType.FIELDCOMMENT);
613                 if (template == null) {
614                         return null;
615                 }
616                 CodeTemplateContext context = new CodeTemplateContext(template
617                                 .getContextTypeId(), cu.getJavaProject(), lineDelimiter);
618                 context.setCompilationUnitVariables(cu);
619                 context.setVariable(CodeTemplateContextType.FIELD_TYPE, typeName);
620                 context.setVariable(CodeTemplateContextType.FIELD, fieldName);
621
622                 return evaluateTemplate(context, template);
623         }
624
625         /**
626          * @see net.sourceforge.phpdt.ui.CodeGeneration#getSetterComment(ICompilationUnit,
627          *      String, String, String, String, String, String, String)
628          */
629         public static String getSetterComment(ICompilationUnit cu, String typeName,
630                         String methodName, String fieldName, String fieldType,
631                         String paramName, String bareFieldName, String lineDelimiter)
632                         throws CoreException {
633                 String templateName = CodeTemplateContextType.SETTERCOMMENT;
634                 Template template = WebUI.getDefault()
635                                 .getCodeTemplateStore().findTemplate(templateName);
636                 if (template == null) {
637                         return null;
638                 }
639
640                 CodeTemplateContext context = new CodeTemplateContext(template
641                                 .getContextTypeId(), cu.getJavaProject(), lineDelimiter);
642                 context.setCompilationUnitVariables(cu);
643                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE, typeName);
644                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
645                                 methodName);
646                 context.setVariable(CodeTemplateContextType.FIELD, fieldName);
647                 context.setVariable(CodeTemplateContextType.FIELD_TYPE, fieldType);
648                 context.setVariable(CodeTemplateContextType.BARE_FIELD_NAME,
649                                 bareFieldName);
650                 context.setVariable(CodeTemplateContextType.PARAM, paramName);
651
652                 return evaluateTemplate(context, template);
653         }
654
655         /**
656          * @see net.sourceforge.phpdt.ui.CodeGeneration#getGetterComment(ICompilationUnit,
657          *      String, String, String, String, String, String)
658          */
659         public static String getGetterComment(ICompilationUnit cu, String typeName,
660                         String methodName, String fieldName, String fieldType,
661                         String bareFieldName, String lineDelimiter) throws CoreException {
662                 String templateName = CodeTemplateContextType.GETTERCOMMENT;
663                 Template template = WebUI.getDefault()
664                                 .getCodeTemplateStore().findTemplate(templateName);
665                 if (template == null) {
666                         return null;
667                 }
668                 CodeTemplateContext context = new CodeTemplateContext(template
669                                 .getContextTypeId(), cu.getJavaProject(), lineDelimiter);
670                 context.setCompilationUnitVariables(cu);
671                 context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE, typeName);
672                 context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
673                                 methodName);
674                 context.setVariable(CodeTemplateContextType.FIELD, fieldName);
675                 context.setVariable(CodeTemplateContextType.FIELD_TYPE, fieldType);
676                 context.setVariable(CodeTemplateContextType.BARE_FIELD_NAME,
677                                 bareFieldName);
678
679                 return evaluateTemplate(context, template);
680         }
681
682         public static String evaluateTemplate(CodeTemplateContext context,
683                         Template template) throws CoreException {
684                 TemplateBuffer buffer;
685                 try {
686                         buffer = context.evaluate(template);
687                 } catch (BadLocationException e) {
688                         throw new CoreException(Status.CANCEL_STATUS);
689                 } catch (TemplateException e) {
690                         throw new CoreException(Status.CANCEL_STATUS);
691                 }
692                 if (buffer == null)
693                         return null;
694                 String str = buffer.getString();
695                 if (Strings.containsOnlyWhitespaces(str)) {
696                         return null;
697                 }
698                 return str;
699         }
700
701         /**
702          * @see net.sourceforge.phpdt.ui.CodeGeneration#getMethodComment(ICompilationUnit,
703          *      String, MethodDeclaration, IMethodBinding, String)
704          */
705         // public static String getMethodComment(ICompilationUnit cu, String
706         // typeName, IMethodBinding overridden, String lineDelimiter) throws
707         // CoreException {
708         // if (overridden != null) {
709         // String declaringClassQualifiedName=
710         // overridden.getDeclaringClass().getQualifiedName();
711         // String[] parameterTypesQualifiedNames=
712         // getParameterTypesQualifiedNames(overridden);
713         // return getMethodComment(cu, typeName, decl, true,
714         // overridden.isDeprecated(), declaringClassQualifiedName,
715         // parameterTypesQualifiedNames, lineDelimiter);
716         // } else {
717         // return getMethodComment(cu, typeName, decl, false, false, null, null,
718         // lineDelimiter);
719         // }
720         // }
721         /**
722          * Returns the comment for a method using the comment code templates.
723          * <code>null</code> is returned if the template is empty.
724          * 
725          * @param cu
726          *            The compilation unit to which the method belongs
727          * @param typeName
728          *            Name of the type to which the method belongs.
729          * @param decl
730          *            The AST MethodDeclaration node that will be added as new
731          *            method.
732          * @param isOverridden
733          *            <code>true</code> iff decl overrides another method
734          * @param isDeprecated
735          *            <code>true</code> iff the method that decl overrides is
736          *            deprecated. Note: it must not be <code>true</code> if
737          *            isOverridden is <code>false</code>.
738          * @param declaringClassQualifiedName
739          *            Fully qualified name of the type in which the overriddden
740          *            method (if any exists) in declared. If isOverridden is
741          *            <code>false</code>, this is ignored.
742          * @param parameterTypesQualifiedNames
743          *            Fully qualified names of parameter types of the type in which
744          *            the overriddden method (if any exists) in declared. If
745          *            isOverridden is <code>false</code>, this is ignored.
746          * @return String Returns the method comment or <code>null</code> if the
747          *         configured template is empty. (formatting required)
748          * @throws CoreException
749          */
750         // public static String getMethodComment(ICompilationUnit cu, String
751         // typeName, MethodDeclaration decl, boolean isOverridden, boolean
752         // isDeprecated, String declaringClassQualifiedName, String[]
753         // parameterTypesQualifiedNames, String lineDelimiter) throws CoreException
754         // {
755         // String templateName= CodeTemplateContextType.METHODCOMMENT;
756         // if (decl.isConstructor()) {
757         // templateName= CodeTemplateContextType.CONSTRUCTORCOMMENT;
758         // } else if (isOverridden) {
759         // templateName= CodeTemplateContextType.OVERRIDECOMMENT;
760         // }
761         // Template template=
762         // PHPeclipsePlugin.getDefault().getCodeTemplateStore().findTemplate(templateName);
763         // if (template == null) {
764         // return null;
765         // }
766         // CodeTemplateContext context= new
767         // CodeTemplateContext(template.getContextTypeId(), cu.getJavaProject(),
768         // lineDelimiter);
769         // context.setCompilationUnitVariables(cu);
770         // context.setVariable(CodeTemplateContextType.ENCLOSING_TYPE, typeName);
771         // context.setVariable(CodeTemplateContextType.ENCLOSING_METHOD,
772         // decl.getName().getIdentifier());
773         // if (!decl.isConstructor()) {
774         // context.setVariable(CodeTemplateContextType.RETURN_TYPE,
775         // ASTNodes.asString(decl.getReturnType()));
776         // }
777         // if (isOverridden) {
778         // String methodName= decl.getName().getIdentifier();
779         // context.setVariable(CodeTemplateContextType.SEE_TAG,
780         // getSeeTag(declaringClassQualifiedName, methodName,
781         // parameterTypesQualifiedNames));
782         // }
783         //                      
784         // TemplateBuffer buffer;
785         // try {
786         // buffer= context.evaluate(template);
787         // } catch (BadLocationException e) {
788         // throw new CoreException(Status.CANCEL_STATUS);
789         // } catch (TemplateException e) {
790         // throw new CoreException(Status.CANCEL_STATUS);
791         // }
792         // if (buffer == null)
793         // return null;
794         // String str= buffer.getString();
795         // if (Strings.containsOnlyWhitespaces(str)) {
796         // return null;
797         // }
798         // TemplateVariable position= findTagVariable(buffer); // look if Javadoc
799         // tags have to be added
800         // if (position == null) {
801         // return str;
802         // }
803         //                              
804         // IDocument textBuffer= new Document(str);
805         // List params= decl.parameters();
806         // String[] paramNames= new String[params.size()];
807         // for (int i= 0; i < params.size(); i++) {
808         // SingleVariableDeclaration elem= (SingleVariableDeclaration)
809         // params.get(i);
810         // paramNames[i]= elem.getName().getIdentifier();
811         // }
812         // List exceptions= decl.thrownExceptions();
813         // String[] exceptionNames= new String[exceptions.size()];
814         // for (int i= 0; i < exceptions.size(); i++) {
815         // exceptionNames[i]= ASTNodes.getSimpleNameIdentifier((Name)
816         // exceptions.get(i));
817         // }
818         // String returnType= !decl.isConstructor() ?
819         // ASTNodes.asString(decl.getReturnType()) : null;
820         // int[] tagOffsets= position.getOffsets();
821         // for (int i= tagOffsets.length - 1; i >= 0; i--) { // from last to first
822         // try {
823         // insertTag(textBuffer, tagOffsets[i], position.getLength(), paramNames,
824         // exceptionNames, returnType, isDeprecated, lineDelimiter);
825         // } catch (BadLocationException e) {
826         // throw new CoreException(PHPUIStatus.createError(IStatus.ERROR, e));
827         // }
828         // }
829         // return textBuffer.get();
830         // }
831         private static TemplateVariable findTagVariable(TemplateBuffer buffer) {
832                 TemplateVariable[] positions = buffer.getVariables();
833                 for (int i = 0; i < positions.length; i++) {
834                         TemplateVariable curr = positions[i];
835                         if (CodeTemplateContextType.TAGS.equals(curr.getType())) {
836                                 return curr;
837                         }
838                 }
839                 return null;
840         }
841
842         private static void insertTag(IDocument textBuffer, int offset, int length,
843                         String[] paramNames, String[] exceptionNames, String returnType,
844                         boolean isDeprecated, String lineDelimiter)
845                         throws BadLocationException {
846                 IRegion region = textBuffer.getLineInformationOfOffset(offset);
847                 if (region == null) {
848                         return;
849                 }
850                 String lineStart = textBuffer.get(region.getOffset(), offset
851                                 - region.getOffset());
852
853                 StringBuffer buf = new StringBuffer();
854                 for (int i = 0; i < paramNames.length; i++) {
855                         if (buf.length() > 0) {
856                                 buf.append(lineDelimiter);
857                                 buf.append(lineStart);
858                         }
859                         buf.append("@param ");buf.append(paramNames[i]); //$NON-NLS-1$
860                 }
861                 if (returnType != null && !returnType.equals("void")) { //$NON-NLS-1$
862                         if (buf.length() > 0) {
863                                 buf.append(lineDelimiter);
864                                 buf.append(lineStart);
865                         }
866                         buf.append("@return"); //$NON-NLS-1$
867                 }
868                 if (exceptionNames != null) {
869                         for (int i = 0; i < exceptionNames.length; i++) {
870                                 if (buf.length() > 0) {
871                                         buf.append(lineDelimiter);
872                                         buf.append(lineStart);
873                                 }
874                                 buf.append("@throws ");buf.append(exceptionNames[i]); //$NON-NLS-1$
875                         }
876                 }
877                 if (isDeprecated) {
878                         if (buf.length() > 0) {
879                                 buf.append(lineDelimiter);
880                                 buf.append(lineStart);
881                         }
882                         buf.append("@deprecated"); //$NON-NLS-1$
883                 }
884                 textBuffer.replace(offset, length, buf.toString());
885         }
886
887         private static boolean isPrimitiveType(String typeName) {
888                 char first = Signature.getElementType(typeName).charAt(0);
889                 return (first != Signature.C_RESOLVED && first != Signature.C_UNRESOLVED);
890         }
891
892         private static String resolveAndAdd(String refTypeSig, IType declaringType)
893                         throws JavaModelException {// , IImportsStructure imports) throws
894                                                                                 // JavaModelException {
895                 String resolvedTypeName = JavaModelUtil.getResolvedTypeName(refTypeSig,
896                                 declaringType);
897                 if (resolvedTypeName != null) {
898                         StringBuffer buf = new StringBuffer();
899                         // if (imports != null) {
900                         // buf.append(imports.addImport(resolvedTypeName));
901                         // } else {
902                         buf.append(resolvedTypeName);
903                         // }
904                         int arrayCount = Signature.getArrayCount(refTypeSig);
905                         for (int i = 0; i < arrayCount; i++) {
906                                 buf.append("[]"); //$NON-NLS-1$
907                         }
908                         return buf.toString();
909                 }
910                 return Signature.toString(refTypeSig);
911         }
912
913         /**
914          * Finds a method in a list of methods.
915          * 
916          * @return The found method or null, if nothing found
917          */
918 //      private static IMethod findMethod(IMethod method, List allMethods)
919 //                      throws JavaModelException {
920 //              String name = method.getElementName();
921 //              String[] paramTypes = method.getParameterTypes();
922 //              boolean isConstructor = method.isConstructor();
923 //
924 //              for (int i = allMethods.size() - 1; i >= 0; i--) {
925 //                      IMethod curr = (IMethod) allMethods.get(i);
926 //                      if (JavaModelUtil.isSameMethodSignature(name, paramTypes,
927 //                                      isConstructor, curr)) {
928 //                              return curr;
929 //                      }
930 //              }
931 //              return null;
932 //      }
933
934         /**
935          * Creates needed constructors for a type.
936          * 
937          * @param type
938          *            The type to create constructors for
939          * @param supertype
940          *            The type's super type
941          * @param settings
942          *            Options for comment generation
943          * @param imports
944          *            Required imports are added to the import structure. Structure
945          *            can be <code>null</code>, types are qualified then.
946          * @return Returns the generated stubs or <code>null</code> if the
947          *         creation has been canceled
948          */
949         // public static String[] evalConstructors(IType type, IType supertype,
950         // IImportsStructure imports) throws CoreException {
951         // IMethod[] superMethods= supertype.getMethods();
952         // String typeName= type.getElementName();
953         // ICompilationUnit cu= type.getCompilationUnit();
954         // IMethod[] methods= type.getMethods();
955         // GenStubSettings genStubSettings= new GenStubSettings(settings);
956         // genStubSettings.callSuper= true;
957         //                      
958         // ArrayList newMethods= new ArrayList(superMethods.length);
959         // for (int i= 0; i < superMethods.length; i++) {
960         // IMethod curr= superMethods[i];
961         // if (curr.isConstructor() && (JavaModelUtil.isVisibleInHierarchy(curr,
962         // type.getPackageFragment()))) {
963         // if (JavaModelUtil.findMethod(typeName, curr.getParameterTypes(), true,
964         // methods) == null) {
965         // genStubSettings.methodModifiers= Flags.AccPublic |
966         // JdtFlags.clearAccessModifiers(curr.getFlags());
967         // String newStub= genStub(cu, typeName, curr, curr.getDeclaringType(),
968         // genStubSettings, imports);
969         // newMethods.add(newStub);
970         // }
971         // }
972         // }
973         // return (String[]) newMethods.toArray(new String[newMethods.size()]);
974         // }
975         /**
976          * Returns all unimplemented constructors of a type including root type
977          * default constructors if there are no other superclass constructors
978          * unimplemented.
979          * 
980          * @param type
981          *            The type to create constructors for
982          * @return Returns the generated stubs or <code>null</code> if the
983          *         creation has been canceled
984          */
985         // public static IMethod[] getOverridableConstructors(IType type) throws
986         // CoreException {
987         // List constructorMethods= new ArrayList();
988         // ITypeHierarchy hierarchy= type.newSupertypeHierarchy(null);
989         // IType supertype= hierarchy.getSuperclass(type);
990         // if (supertype == null)
991         // return (new IMethod[0]);
992         //
993         // IMethod[] superMethods= supertype.getMethods();
994         // boolean constuctorFound= false;
995         // String typeName= type.getElementName();
996         // IMethod[] methods= type.getMethods();
997         // for (int i= 0; i < superMethods.length; i++) {
998         // IMethod curr= superMethods[i];
999         // if (curr.isConstructor()) {
1000         // constuctorFound= true;
1001         // if (JavaModelUtil.isVisibleInHierarchy(curr, type.getPackageFragment()))
1002         // if (JavaModelUtil.findMethod(typeName, curr.getParameterTypes(), true,
1003         // methods) == null)
1004         // constructorMethods.add(curr);
1005         //                      
1006         // }
1007         // }
1008         //                      
1009         // // http://bugs.eclipse.org/bugs/show_bug.cgi?id=38487
1010         // if (!constuctorFound) {
1011         // IType objectType= type.getJavaProject().findType("java.lang.Object");
1012         // //$NON-NLS-1$
1013         // IMethod curr= objectType.getMethod("Object", EMPTY); //$NON-NLS-1$
1014         // if (JavaModelUtil.findMethod(typeName, curr.getParameterTypes(), true,
1015         // methods) == null) {
1016         // constructorMethods.add(curr);
1017         // }
1018         // }
1019         // return (IMethod[]) constructorMethods.toArray(new
1020         // IMethod[constructorMethods.size()]);
1021         // }
1022         /**
1023          * Returns all overridable methods of a type
1024          * 
1025          * @param type
1026          *            The type to search the overridable methods for
1027          * @param hierarchy
1028          *            The type hierarchy of the type
1029          * @param isSubType
1030          *            If set, the result can include methods of the passed type, if
1031          *            not only methods from super types are considered
1032          * @return Returns the all methods that can be overridden
1033          */
1034         // public static IMethod[] getOverridableMethods(IType type, ITypeHierarchy
1035         // hierarchy, boolean isSubType) throws JavaModelException {
1036         // List allMethods= new ArrayList();
1037         //
1038         // IMethod[] typeMethods= type.getMethods();
1039         // for (int i= 0; i < typeMethods.length; i++) {
1040         // IMethod curr= typeMethods[i];
1041         // if (!curr.isConstructor() && !Flags.isStatic(curr.getFlags()) &&
1042         // !Flags.isPrivate(curr.getFlags())) {
1043         // allMethods.add(curr);
1044         // }
1045         // }
1046         //
1047         // IType[] superTypes= hierarchy.getAllSuperclasses(type);
1048         // for (int i= 0; i < superTypes.length; i++) {
1049         // IMethod[] methods= superTypes[i].getMethods();
1050         // for (int k= 0; k < methods.length; k++) {
1051         // IMethod curr= methods[k];
1052         // if (!curr.isConstructor() && !Flags.isStatic(curr.getFlags()) &&
1053         // !Flags.isPrivate(curr.getFlags())) {
1054         // if (findMethod(curr, allMethods) == null) {
1055         // allMethods.add(curr);
1056         // }
1057         // }
1058         // }
1059         // }
1060         //
1061         // IType[] superInterfaces= hierarchy.getAllSuperInterfaces(type);
1062         // for (int i= 0; i < superInterfaces.length; i++) {
1063         // IMethod[] methods= superInterfaces[i].getMethods();
1064         // for (int k= 0; k < methods.length; k++) {
1065         // IMethod curr= methods[k];
1066         //
1067         // // binary interfaces can contain static initializers (variable
1068         // intializations)
1069         // // 1G4CKUS
1070         // if (!Flags.isStatic(curr.getFlags())) {
1071         // IMethod impl= findMethod(curr, allMethods);
1072         // if (impl == null || !JavaModelUtil.isVisibleInHierarchy(impl,
1073         // type.getPackageFragment()) || prefereInterfaceMethod(hierarchy, curr,
1074         // impl)) {
1075         // if (impl != null) {
1076         // allMethods.remove(impl);
1077         // }
1078         // // implement an interface method when it does not exist in the hierarchy
1079         // // or when it throws less exceptions that the implemented
1080         // allMethods.add(curr);
1081         // }
1082         // }
1083         // }
1084         // }
1085         // if (!isSubType) {
1086         // allMethods.removeAll(Arrays.asList(typeMethods));
1087         // }
1088         // // remove finals
1089         // for (int i= allMethods.size() - 1; i >= 0; i--) {
1090         // IMethod curr= (IMethod) allMethods.get(i);
1091         // if (Flags.isFinal(curr.getFlags())) {
1092         // allMethods.remove(i);
1093         // }
1094         // }
1095         // return (IMethod[]) allMethods.toArray(new IMethod[allMethods.size()]);
1096         // }
1097         // private static boolean prefereInterfaceMethod(ITypeHierarchy hierarchy,
1098         // IMethod interfaceMethod, IMethod curr) throws JavaModelException {
1099         // if (Flags.isFinal(curr.getFlags())) {
1100         // return false;
1101         // }
1102         // IType interfaceType= interfaceMethod.getDeclaringType();
1103         // IType[] interfaces=
1104         // hierarchy.getAllSuperInterfaces(curr.getDeclaringType());
1105         // for (int i= 0; i < interfaces.length; i++) {
1106         // if (interfaces[i] == interfaceType) {
1107         // return false;
1108         // }
1109         // }
1110         // return curr.getExceptionTypes().length >
1111         // interfaceMethod.getExceptionTypes().length;
1112         // }
1113         /**
1114          * Generate method stubs for methods to overrride
1115          * 
1116          * @param type
1117          *            The type to search the overridable methods for
1118          * @param hierarchy
1119          *            The type hierarchy of the type
1120          * @param methodsToImplement
1121          *            Methods to override or implement
1122          * @param settings
1123          *            Options for comment generation
1124          * @param imports
1125          *            Required imports are added to the import structure. Structure
1126          *            can be <code>null</code>, types are qualified then.
1127          * @return Returns the generated stubs
1128          */
1129         // public static String[] genOverrideStubs(IMethod[] methodsToImplement,
1130         // IType type, ITypeHierarchy hierarchy, CodeGenerationSettings settings,
1131         // IImportsStructure imports) throws CoreException {
1132         // GenStubSettings genStubSettings= new GenStubSettings(settings);
1133         // genStubSettings.methodOverwrites= true;
1134         // ICompilationUnit cu= type.getCompilationUnit();
1135         // String[] result= new String[methodsToImplement.length];
1136         // for (int i= 0; i < methodsToImplement.length; i++) {
1137         // IMethod curr= methodsToImplement[i];
1138         // IMethod overrides=
1139         // JavaModelUtil.findMethodImplementationInHierarchy(hierarchy, type,
1140         // curr.getElementName(), curr.getParameterTypes(), curr.isConstructor());
1141         // if (overrides != null) {
1142         // genStubSettings.callSuper= true;
1143         // curr= overrides;
1144         // }
1145         // genStubSettings.methodModifiers= curr.getFlags();
1146         // IMethod desc= JavaModelUtil.findMethodDeclarationInHierarchy(hierarchy,
1147         // type, curr.getElementName(), curr.getParameterTypes(),
1148         // curr.isConstructor());
1149         // if (desc == null) {
1150         // desc= curr;
1151         // }
1152         // result[i]= genStub(cu, type.getElementName(), curr,
1153         // desc.getDeclaringType(), genStubSettings, imports);
1154         // }
1155         // return result;
1156         // }
1157         /**
1158          * Searches for unimplemented methods of a type.
1159          * 
1160          * @param isSubType
1161          *            If set, the evaluation is for a subtype of the given type. If
1162          *            not set, the evaluation is for the type itself.
1163          * @param settings
1164          *            Options for comment generation
1165          * @param imports
1166          *            Required imports are added to the import structure. Structure
1167          *            can be <code>null</code>, types are qualified then.
1168          * @return Returns the generated stubs or <code>null</code> if the
1169          *         creation has been canceled
1170          */
1171         // public static String[] evalUnimplementedMethods(IType type,
1172         // ITypeHierarchy hierarchy, boolean isSubType, CodeGenerationSettings
1173         // settings,
1174         // IImportsStructure imports) throws CoreException {
1175         //                                              
1176         // IMethod[] inheritedMethods= getOverridableMethods(type, hierarchy,
1177         // isSubType);
1178         //                      
1179         // List toImplement= new ArrayList();
1180         // for (int i= 0; i < inheritedMethods.length; i++) {
1181         // IMethod curr= inheritedMethods[i];
1182         // if (JdtFlags.isAbstract(curr)) {
1183         // toImplement.add(curr);
1184         // }
1185         // }
1186         // IMethod[] toImplementArray= (IMethod[]) toImplement.toArray(new
1187         // IMethod[toImplement.size()]);
1188         // return genOverrideStubs(toImplementArray, type, hierarchy, settings,
1189         // imports);
1190         // }
1191         /**
1192          * Examines a string and returns the first line delimiter found.
1193          */
1194         public static String getLineDelimiterUsed(IJavaElement elem)
1195                         throws JavaModelException {
1196                 ICompilationUnit cu = (ICompilationUnit) elem
1197                                 .getAncestor(IJavaElement.COMPILATION_UNIT);
1198                 if (cu != null && cu.exists()) {
1199                         IBuffer buf = cu.getBuffer();
1200                         int length = buf.getLength();
1201                         for (int i = 0; i < length; i++) {
1202                                 char ch = buf.getChar(i);
1203                                 if (ch == SWT.CR) {
1204                                         if (i + 1 < length) {
1205                                                 if (buf.getChar(i + 1) == SWT.LF) {
1206                                                         return "\r\n"; //$NON-NLS-1$
1207                                                 }
1208                                         }
1209                                         return "\r"; //$NON-NLS-1$
1210                                 } else if (ch == SWT.LF) {
1211                                         return "\n"; //$NON-NLS-1$
1212                                 }
1213                         }
1214                 }
1215                 return System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
1216         }
1217
1218         /**
1219          * Embodies the policy which line delimiter to use when inserting into a
1220          * document.
1221          */
1222         public static String getLineDelimiterFor(IDocument doc) {
1223                 // new for: 1GF5UU0: ITPJUI:WIN2000 - "Organize Imports" in php editor
1224                 // inserts lines in wrong format
1225                 String lineDelim = null;
1226                 try {
1227                         lineDelim = doc.getLineDelimiter(0);
1228                 } catch (BadLocationException e) {
1229                 }
1230                 if (lineDelim == null) {
1231                         String systemDelimiter = System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
1232                         String[] lineDelims = doc.getLegalLineDelimiters();
1233                         for (int i = 0; i < lineDelims.length; i++) {
1234                                 if (lineDelims[i].equals(systemDelimiter)) {
1235                                         lineDelim = systemDelimiter;
1236                                         break;
1237                                 }
1238                         }
1239                         if (lineDelim == null) {
1240                                 lineDelim = lineDelims.length > 0 ? lineDelims[0]
1241                                                 : systemDelimiter;
1242                         }
1243                 }
1244                 return lineDelim;
1245         }
1246
1247         /**
1248          * Evaluates the indention used by a Java element. (in tabulators)
1249          */
1250         // public static int getIndentUsed(IJavaElement elem) throws
1251         // JavaModelException {
1252         // if (elem instanceof ISourceReference) {
1253         // ICompilationUnit cu= (ICompilationUnit)
1254         // elem.getAncestor(IJavaElement.COMPILATION_UNIT);
1255         // if (cu != null) {
1256         // IBuffer buf= cu.getBuffer();
1257         // int offset= ((ISourceReference)elem).getSourceRange().getOffset();
1258         // int i= offset;
1259         // // find beginning of line
1260         // while (i > 0 && !Strings.isLineDelimiterChar(buf.getChar(i - 1)) ){
1261         // i--;
1262         // }
1263         // return Strings.computeIndent(buf.getText(i, offset - i),
1264         // CodeFormatterUtil.getTabWidth());
1265         // }
1266         // }
1267         // return 0;
1268         // }
1269         public static String codeFormat(String sourceString,
1270                         int initialIndentationLevel, String lineDelim) {
1271                 ICodeFormatter formatter = ToolFactory.createDefaultCodeFormatter(null);
1272                 return formatter.format(sourceString, initialIndentationLevel, null,
1273                                 lineDelim);
1274         }
1275
1276         /**
1277          * Returns the element after the give element.
1278          */
1279         // public static IJavaElement findNextSibling(IJavaElement member) throws
1280         // JavaModelException {
1281         // IJavaElement parent= member.getParent();
1282         // if (parent instanceof IParent) {
1283         // IJavaElement[] elements= ((IParent)parent).getChildren();
1284         // for (int i= elements.length - 2; i >= 0 ; i--) {
1285         // if (member.equals(elements[i])) {
1286         // return elements[i+1];
1287         // }
1288         // }
1289         // }
1290         // return null;
1291         // }
1292         //      
1293         public static String getTodoTaskTag(IJavaProject project) {
1294                 String markers = null;
1295                 if (project == null) {
1296                         markers = JavaCore.getOption(JavaCore.COMPILER_TASK_TAGS);
1297                 } else {
1298                         markers = project.getOption(JavaCore.COMPILER_TASK_TAGS, true);
1299                 }
1300
1301                 if (markers != null && markers.length() > 0) {
1302                         int idx = markers.indexOf(',');
1303                         if (idx == -1) {
1304                                 return markers;
1305                         } else {
1306                                 return markers.substring(0, idx);
1307                         }
1308                 }
1309                 return null;
1310         }
1311
1312         /*
1313          * Workarounds for bug 38111
1314          */
1315         // public static String[] getArgumentNameSuggestions(IJavaProject project,
1316         // String baseName, int dimensions, String[] excluded) {
1317         // String name= workaround38111(baseName);
1318         // String[] res= NamingConventions.suggestArgumentNames(project, "", name,
1319         // dimensions, excluded); //$NON-NLS-1$
1320         // return sortByLength(res); // longest first
1321         // }
1322         //               
1323         // public static String[] getFieldNameSuggestions(IJavaProject project,
1324         // String baseName, int dimensions, int modifiers, String[] excluded) {
1325         // String name= workaround38111(baseName);
1326         // String[] res= NamingConventions.suggestFieldNames(project, "", name,
1327         // dimensions, modifiers, excluded); //$NON-NLS-1$
1328         // return sortByLength(res); // longest first
1329         // }
1330         //      
1331         // public static String[] getLocalNameSuggestions(IJavaProject project,
1332         // String baseName, int dimensions, String[] excluded) {
1333         // String name= workaround38111(baseName);
1334         // String[] res= NamingConventions.suggestLocalVariableNames(project, "",
1335         // name, dimensions, excluded); //$NON-NLS-1$
1336         // return sortByLength(res); // longest first
1337         // }
1338 //      private static String[] sortByLength(String[] proposals) {
1339 //              Arrays.sort(proposals, new Comparator() {
1340 //                      public int compare(Object o1, Object o2) {
1341 //                              return ((String) o2).length() - ((String) o1).length();
1342 //                      }
1343 //              });
1344 //              return proposals;
1345 //      }
1346
1347 /*      private static String workaround38111(String baseName) {
1348                 if (BASE_TYPES.contains(baseName))
1349                         return baseName;
1350                 return Character.toUpperCase(baseName.charAt(0))
1351                                 + baseName.substring(1);
1352         }
1353 */
1354         private static final List BASE_TYPES = Arrays
1355                         .asList(new String[] {
1356                                         "boolean", "byte", "char", "double", "float", "int", "long", "short" }); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
1357
1358         public static String suggestArgumentName(IJavaProject project,
1359                         String baseName, String[] excluded) {
1360                 // String[] argnames= getArgumentNameSuggestions(project, baseName, 0,
1361                 // excluded);
1362                 // if (argnames.length > 0) {
1363                 // return argnames[0];
1364                 // }
1365                 return baseName;
1366         }
1367
1368         public static String[] suggestArgumentNames(IJavaProject project,
1369                         String[] paramNames) {
1370                 String prefixes = project.getOption(
1371                                 JavaCore.CODEASSIST_ARGUMENT_PREFIXES, true);
1372                 String suffixes = project.getOption(
1373                                 JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, true);
1374                 if (prefixes.length() + suffixes.length() == 0) {
1375                         return paramNames;
1376                 }
1377
1378                 String[] newNames = new String[paramNames.length];
1379                 // Ensure that the codegeneration preferences are respected
1380                 for (int i = 0; i < paramNames.length; i++) {
1381                         String curr = paramNames[i];
1382                         if (!hasPrefixOrSuffix(prefixes, suffixes, curr)) {
1383                                 newNames[i] = suggestArgumentName(project, paramNames[i], null);
1384                         } else {
1385                                 newNames[i] = curr;
1386                         }
1387                 }
1388                 return newNames;
1389         }
1390
1391         public static boolean hasFieldName(IJavaProject project, String name) {
1392                 String prefixes = project.getOption(JavaCore.CODEASSIST_FIELD_PREFIXES,
1393                                 true);
1394                 String suffixes = project.getOption(JavaCore.CODEASSIST_FIELD_SUFFIXES,
1395                                 true);
1396                 String staticPrefixes = project.getOption(
1397                                 JavaCore.CODEASSIST_STATIC_FIELD_PREFIXES, true);
1398                 String staticSuffixes = project.getOption(
1399                                 JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, true);
1400
1401                 return hasPrefixOrSuffix(prefixes, suffixes, name)
1402                                 || hasPrefixOrSuffix(staticPrefixes, staticSuffixes, name);
1403         }
1404
1405         public static boolean hasParameterName(IJavaProject project, String name) {
1406                 String prefixes = project.getOption(
1407                                 JavaCore.CODEASSIST_ARGUMENT_PREFIXES, true);
1408                 String suffixes = project.getOption(
1409                                 JavaCore.CODEASSIST_ARGUMENT_SUFFIXES, true);
1410                 return hasPrefixOrSuffix(prefixes, suffixes, name);
1411         }
1412
1413         public static boolean hasLocalVariableName(IJavaProject project, String name) {
1414                 String prefixes = project.getOption(JavaCore.CODEASSIST_LOCAL_PREFIXES,
1415                                 true);
1416                 String suffixes = project.getOption(JavaCore.CODEASSIST_LOCAL_SUFFIXES,
1417                                 true);
1418                 return hasPrefixOrSuffix(prefixes, suffixes, name);
1419         }
1420
1421         public static boolean hasConstantName(String name) {
1422                 return Character.isUpperCase(name.charAt(0));
1423         }
1424
1425         private static boolean hasPrefixOrSuffix(String prefixes, String suffixes,
1426                         String name) {
1427                 final String listSeparartor = ","; //$NON-NLS-1$
1428
1429                 StringTokenizer tok = new StringTokenizer(prefixes, listSeparartor);
1430                 while (tok.hasMoreTokens()) {
1431                         String curr = tok.nextToken();
1432                         if (name.startsWith(curr)) {
1433                                 return true;
1434                         }
1435                 }
1436
1437                 tok = new StringTokenizer(suffixes, listSeparartor);
1438                 while (tok.hasMoreTokens()) {
1439                         String curr = tok.nextToken();
1440                         if (name.endsWith(curr)) {
1441                                 return true;
1442                         }
1443                 }
1444                 return false;
1445         }
1446 }