--- /dev/null
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+package net.sourceforge.phpdt.internal.corext.codemanipulation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.swt.SWT;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.IDocument;
+
+//import org.phpeclipse.phpdt.core.Flags;
+//import org.phpeclipse.phpdt.core.IBuffer;
+import net.sourceforge.phpdt.core.ICodeFormatter;
+//import org.phpeclipse.phpdt.core.ICompilationUnit;
+//import org.phpeclipse.phpdt.core.IJavaElement;
+//import org.phpeclipse.phpdt.core.IJavaProject;
+//import org.phpeclipse.phpdt.core.IMethod;
+//import org.phpeclipse.phpdt.core.IParent;
+//import org.phpeclipse.phpdt.core.ISourceReference;
+//import org.phpeclipse.phpdt.core.IType;
+//import org.phpeclipse.phpdt.core.ITypeHierarchy;
+import net.sourceforge.phpeclipse.PHPCore;
+//import org.phpeclipse.phpdt.core.JavaModelException;
+//import org.phpeclipse.phpdt.core.Signature;
+import net.sourceforge.phpdt.core.ToolFactory;
+
+//import net.sourceforge.phpdt.internal.corext.util.CodeFormatterUtil;
+//import net.sourceforge.phpdt.internal.corext.util.JavaModelUtil;
+import net.sourceforge.phpdt.internal.corext.util.Strings;
+
+public class StubUtility {
+
+
+// public static class GenStubSettings extends CodeGenerationSettings {
+//
+// public boolean callSuper;
+// public boolean methodOverwrites;
+// public boolean noBody;
+//
+// public GenStubSettings(CodeGenerationSettings settings) {
+// settings.setSettings(this);
+// }
+//
+// public GenStubSettings() {
+// }
+//
+// }
+//
+//
+// /**
+// * Generates a stub. Given a template method, a stub with the same signature
+// * will be constructed so it can be added to a type.
+// * @param destTypeName The name of the type to which the method will be added to (Used for the constructor)
+// * @param method A method template (method belongs to different type than the parent)
+// * @param options Options as defined above (<code>GenStubSettings</code>)
+// * @param imports Imports required by the stub are added to the imports structure. If imports structure is <code>null</code>
+// * all type names are qualified.
+// * @throws JavaModelException
+// */
+// public static String genStub(String destTypeName, IMethod method, GenStubSettings settings, IImportsStructure imports) throws JavaModelException {
+// IType declaringtype= method.getDeclaringType();
+// StringBuffer buf= new StringBuffer();
+// String methodName= method.getElementName();
+// String[] paramTypes= method.getParameterTypes();
+// String[] paramNames= method.getParameterNames();
+// String[] excTypes= method.getExceptionTypes();
+// String retTypeSig= method.getReturnType();
+// int flags= method.getFlags();
+// boolean isConstructor= method.isConstructor();
+//
+// int lastParam= paramTypes.length -1;
+//
+//
+// if (settings.createComments) {
+// if (isConstructor) {
+// String desc= "Constructor for " + destTypeName; //$NON-NLS-1$
+// genJavaDocStub(desc, paramNames, Signature.SIG_VOID, excTypes, buf);
+// } else {
+// // php doc
+// if (settings.methodOverwrites) {
+// boolean isDeprecated= Flags.isDeprecated(flags);
+// genJavaDocSeeTag(declaringtype, methodName, paramTypes, settings.createNonJavadocComments, isDeprecated, buf);
+// } else {
+// // generate a default php doc comment
+// String desc= "Method " + methodName; //$NON-NLS-1$
+// genJavaDocStub(desc, paramNames, retTypeSig, excTypes, buf);
+// }
+// }
+// buf.append('\n');
+// }
+//
+// if (Flags.isPublic(flags) || isConstructor || (declaringtype.isInterface() && !settings.noBody)) {
+// buf.append("public "); //$NON-NLS-1$
+// } else if (Flags.isProtected(flags)) {
+// buf.append("protected "); //$NON-NLS-1$
+// } else if (Flags.isPrivate(flags)) {
+// buf.append("private "); //$NON-NLS-1$
+// }
+// if (Flags.isSynchronized(flags)) {
+// buf.append("synchronized "); //$NON-NLS-1$
+// }
+// if (Flags.isVolatile(flags)) {
+// buf.append("volatile "); //$NON-NLS-1$
+// }
+// if (Flags.isStrictfp(flags)) {
+// buf.append("strictfp "); //$NON-NLS-1$
+// }
+// if (Flags.isStatic(flags)) {
+// buf.append("static "); //$NON-NLS-1$
+// }
+//
+// if (isConstructor) {
+// buf.append(destTypeName);
+// } else {
+// String retTypeFrm;
+// if (!isPrimitiveType(retTypeSig)) {
+// retTypeFrm= resolveAndAdd(retTypeSig, declaringtype, imports);
+// } else {
+// retTypeFrm= Signature.toString(retTypeSig);
+// }
+// buf.append(retTypeFrm);
+// buf.append(' ');
+// buf.append(methodName);
+// }
+// buf.append('(');
+// for (int i= 0; i <= lastParam; i++) {
+// String paramTypeSig= paramTypes[i];
+// String paramTypeFrm;
+//
+// if (!isPrimitiveType(paramTypeSig)) {
+// paramTypeFrm= resolveAndAdd(paramTypeSig, declaringtype, imports);
+// } else {
+// paramTypeFrm= Signature.toString(paramTypeSig);
+// }
+// buf.append(paramTypeFrm);
+// buf.append(' ');
+// buf.append(paramNames[i]);
+// if (i < lastParam) {
+// buf.append(", "); //$NON-NLS-1$
+// }
+// }
+// buf.append(')');
+//
+// int lastExc= excTypes.length - 1;
+// if (lastExc >= 0) {
+// buf.append(" throws "); //$NON-NLS-1$
+// for (int i= 0; i <= lastExc; i++) {
+// String excTypeSig= excTypes[i];
+// String excTypeFrm= resolveAndAdd(excTypeSig, declaringtype, imports);
+// buf.append(excTypeFrm);
+// if (i < lastExc) {
+// buf.append(", "); //$NON-NLS-1$
+// }
+// }
+// }
+// if (settings.noBody) {
+// buf.append(";\n\n"); //$NON-NLS-1$
+// } else {
+// buf.append(" {\n\t"); //$NON-NLS-1$
+// if (!settings.callSuper) {
+// if (retTypeSig != null && !retTypeSig.equals(Signature.SIG_VOID)) {
+// buf.append('\t');
+// if (!isPrimitiveType(retTypeSig) || Signature.getArrayCount(retTypeSig) > 0) {
+// buf.append("return null;\n\t"); //$NON-NLS-1$
+// } else if (retTypeSig.equals(Signature.SIG_BOOLEAN)) {
+// buf.append("return false;\n\t"); //$NON-NLS-1$
+// } else {
+// buf.append("return 0;\n\t"); //$NON-NLS-1$
+// }
+// }
+// } else {
+// buf.append('\t');
+// if (!isConstructor) {
+// if (!Signature.SIG_VOID.equals(retTypeSig)) {
+// buf.append("return "); //$NON-NLS-1$
+// }
+// buf.append("super."); //$NON-NLS-1$
+// buf.append(methodName);
+// } else {
+// buf.append("super"); //$NON-NLS-1$
+// }
+// buf.append('(');
+// for (int i= 0; i <= lastParam; i++) {
+// buf.append(paramNames[i]);
+// if (i < lastParam) {
+// buf.append(", "); //$NON-NLS-1$
+// }
+// }
+// buf.append(");\n\t"); //$NON-NLS-1$
+// }
+// buf.append("}\n"); //$NON-NLS-1$
+// }
+// return buf.toString();
+// }
+//
+// private static boolean isSet(int options, int flag) {
+// return (options & flag) != 0;
+// }
+//
+// private static boolean isPrimitiveType(String typeName) {
+// char first= Signature.getElementType(typeName).charAt(0);
+// return (first != Signature.C_RESOLVED && first != Signature.C_UNRESOLVED);
+// }
+//
+// private static String resolveAndAdd(String refTypeSig, IType declaringType, IImportsStructure imports) throws JavaModelException {
+// String resolvedTypeName= JavaModelUtil.getResolvedTypeName(refTypeSig, declaringType);
+// if (resolvedTypeName != null) {
+// StringBuffer buf= new StringBuffer();
+// if (imports != null) {
+// buf.append(imports.addImport(resolvedTypeName));
+// } else {
+// buf.append(resolvedTypeName);
+// }
+// int arrayCount= Signature.getArrayCount(refTypeSig);
+// for (int i= 0; i < arrayCount; i++) {
+// buf.append("[]"); //$NON-NLS-1$
+// }
+// return buf.toString();
+// }
+// return Signature.toString(refTypeSig);
+// }
+//
+// /**
+// * Generates a default JavaDoc comment stub for a method.
+// */
+// public static void genJavaDocStub(String descr, String[] paramNames, String retTypeSig, String[] excTypeSigs, StringBuffer buf) {
+// buf.append("/**\n"); //$NON-NLS-1$
+// buf.append(" * "); buf.append(descr); buf.append(".\n"); //$NON-NLS-2$ //$NON-NLS-1$
+// for (int i= 0; i < paramNames.length; i++) {
+// buf.append(" * @param "); buf.append(paramNames[i]); buf.append('\n'); //$NON-NLS-1$
+// }
+// if (retTypeSig != null && !retTypeSig.equals(Signature.SIG_VOID)) {
+// String simpleName= Signature.getSimpleName(Signature.toString(retTypeSig));
+// buf.append(" * @return "); buf.append(simpleName); buf.append('\n'); //$NON-NLS-1$
+// }
+// if (excTypeSigs != null) {
+// for (int i= 0; i < excTypeSigs.length; i++) {
+// String simpleName= Signature.getSimpleName(Signature.toString(excTypeSigs[i]));
+// buf.append(" * @throws "); buf.append(simpleName); buf.append('\n'); //$NON-NLS-1$
+// }
+// }
+// buf.append(" */"); //$NON-NLS-1$
+// }
+//
+// /**
+// * Generates a '@see' tag to the defined method.
+// */
+// public static void genJavaDocSeeTag(IType declaringType, String methodName, String[] paramTypes, boolean nonJavaDocComment, boolean isDeprecated, StringBuffer buf) throws JavaModelException {
+// String[] fullParamNames= new String[paramTypes.length];
+// for (int i= 0; i < paramTypes.length; i++) {
+// fullParamNames[i]= JavaModelUtil.getResolvedTypeName(paramTypes[i], declaringType);
+// }
+// String fullTypeName= JavaModelUtil.getFullyQualifiedName(declaringType);
+//
+// genJavaDocSeeTag(fullTypeName, methodName, fullParamNames, nonJavaDocComment, isDeprecated, buf);
+// }
+//
+// /**
+// * Generates a '@see' tag to the defined method.
+// */
+// public static void genJavaDocSeeTag(String fullyQualifiedTypeName, String methodName, String[] fullParamTypeNames, boolean nonJavaDocComment, boolean isDeprecated, StringBuffer buf) throws JavaModelException {
+// // create a @see link
+// buf.append("/*"); //$NON-NLS-1$
+// if (!nonJavaDocComment) {
+// buf.append('*');
+// } else {
+// buf.append(" (non-Javadoc)"); //$NON-NLS-1$
+// }
+// buf.append("\n * @see "); //$NON-NLS-1$
+// buf.append(fullyQualifiedTypeName);
+// buf.append('#');
+// buf.append(methodName);
+// buf.append('(');
+// for (int i= 0; i < fullParamTypeNames.length; i++) {
+// if (i > 0) {
+// buf.append(", "); //$NON-NLS-1$
+// }
+// buf.append(fullParamTypeNames[i]);
+// }
+// buf.append(")\n"); //$NON-NLS-1$
+// if (isDeprecated) {
+// buf.append(" * @deprecated\n"); //$NON-NLS-1$
+// }
+// buf.append(" */"); //$NON-NLS-1$
+// }
+//
+//
+//
+// /**
+// * Finds a method in a list of methods.
+// * @return The found method or null, if nothing found
+// */
+// private static IMethod findMethod(IMethod method, List allMethods) throws JavaModelException {
+// String name= method.getElementName();
+// String[] paramTypes= method.getParameterTypes();
+// boolean isConstructor= method.isConstructor();
+//
+// for (int i= allMethods.size() - 1; i >= 0; i--) {
+// IMethod curr= (IMethod) allMethods.get(i);
+// if (JavaModelUtil.isSameMethodSignature(name, paramTypes, isConstructor, curr)) {
+// return curr;
+// }
+// }
+// return null;
+// }
+
+
+ /**
+ * Creates needed constructors for a type.
+ * @param type The type to create constructors for
+ * @param supertype The type's super type
+ * @param settings Options for comment generation
+ * @param imports Required imports are added to the import structure. Structure can be <code>null</code>, types are qualified then.
+ * @return Returns the generated stubs or <code>null</code> if the creation has been canceled
+ */
+// public static String[] evalConstructors(IType type, IType supertype, CodeGenerationSettings settings, IImportsStructure imports) throws JavaModelException {
+// IMethod[] superMethods= supertype.getMethods();
+// String typeName= type.getElementName();
+// IMethod[] methods= type.getMethods();
+// GenStubSettings genStubSettings= new GenStubSettings(settings);
+// genStubSettings.callSuper= true;
+// ArrayList newMethods= new ArrayList(superMethods.length);
+// for (int i= 0; i < superMethods.length; i++) {
+// IMethod curr= superMethods[i];
+// if (curr.isConstructor() && (JavaModelUtil.isVisible(curr, type.getPackageFragment()) || Flags.isProtected(curr.getFlags()))) {
+// if (JavaModelUtil.findMethod(typeName, curr.getParameterTypes(), true, methods) == null) {
+// String newStub= genStub(typeName, superMethods[i], genStubSettings, imports);
+// newMethods.add(newStub);
+// }
+// }
+// }
+// return (String[]) newMethods.toArray(new String[newMethods.size()]);
+// }
+//
+// /**
+// * Searches for unimplemented methods of a type.
+// * @param isSubType If set, the evaluation is for a subtype of the given type. If not set, the
+// * evaluation is for the type itself.
+// * @param settings Options for comment generation
+// * @param selectionQuery If not null will select the methods to implement.
+// * @param imports Required imports are added to the import structure. Structure can be <code>null</code>, types are qualified then.
+// * @return Returns the generated stubs or <code>null</code> if the creation has been canceled
+// */
+// public static String[] evalUnimplementedMethods(IType type, ITypeHierarchy hierarchy, boolean isSubType, CodeGenerationSettings settings,
+// IOverrideMethodQuery selectionQuery, IImportsStructure imports) throws JavaModelException {
+// List allMethods= new ArrayList();
+// List toImplement= new ArrayList();
+//
+// IMethod[] typeMethods= type.getMethods();
+// for (int i= 0; i < typeMethods.length; i++) {
+// IMethod curr= typeMethods[i];
+// if (!curr.isConstructor() && !Flags.isStatic(curr.getFlags()) && !Flags.isPrivate(curr.getFlags())) {
+// allMethods.add(curr);
+// }
+// }
+//
+// IType[] superTypes= hierarchy.getAllSuperclasses(type);
+// for (int i= 0; i < superTypes.length; i++) {
+// IMethod[] methods= superTypes[i].getMethods();
+// for (int k= 0; k < methods.length; k++) {
+// IMethod curr= methods[k];
+// if (!curr.isConstructor() && !Flags.isStatic(curr.getFlags()) && !Flags.isPrivate(curr.getFlags())) {
+// if (findMethod(curr, allMethods) == null) {
+// allMethods.add(curr);
+// }
+// }
+// }
+// }
+//
+// // do not call super
+// for (int i= 0; i < allMethods.size(); i++) {
+// IMethod curr= (IMethod) allMethods.get(i);
+// if ((Flags.isAbstract(curr.getFlags()) || curr.getDeclaringType().isInterface()) && (isSubType || !type.equals(curr.getDeclaringType()))) {
+// // implement all abstract methods
+// toImplement.add(curr);
+// }
+// }
+//
+// IType[] superInterfaces= hierarchy.getAllSuperInterfaces(type);
+// for (int i= 0; i < superInterfaces.length; i++) {
+// IMethod[] methods= superInterfaces[i].getMethods();
+// for (int k= 0; k < methods.length; k++) {
+// IMethod curr= methods[k];
+//
+// // binary interfaces can contain static initializers (variable intializations)
+// // 1G4CKUS
+// if (!Flags.isStatic(curr.getFlags())) {
+// IMethod impl= findMethod(curr, allMethods);
+// if (impl == null || ((curr.getExceptionTypes().length < impl.getExceptionTypes().length) && !Flags.isFinal(impl.getFlags()))) {
+// if (impl != null) {
+// allMethods.remove(impl);
+// }
+// // implement an interface method when it does not exist in the hierarchy
+// // or when it throws less exceptions that the implemented
+// toImplement.add(curr);
+// allMethods.add(curr);
+// }
+// }
+// }
+// }
+// IMethod[] toImplementArray= (IMethod[]) toImplement.toArray(new IMethod[toImplement.size()]);
+// if (selectionQuery != null) {
+// if (!isSubType) {
+// allMethods.removeAll(Arrays.asList(typeMethods));
+// }
+// // remove finals
+// for (int i= allMethods.size() - 1; i >= 0; i--) {
+// IMethod curr= (IMethod) allMethods.get(i);
+// if (Flags.isFinal(curr.getFlags())) {
+// allMethods.remove(i);
+// }
+// }
+// IMethod[] choice= (IMethod[]) allMethods.toArray(new IMethod[allMethods.size()]);
+// toImplementArray= selectionQuery.select(choice, toImplementArray, hierarchy);
+// if (toImplementArray == null) {
+// //cancel pressed
+// return null;
+// }
+// }
+// GenStubSettings genStubSettings= new GenStubSettings(settings);
+// genStubSettings.methodOverwrites= true;
+// String[] result= new String[toImplementArray.length];
+// for (int i= 0; i < toImplementArray.length; i++) {
+// IMethod curr= toImplementArray[i];
+// IMethod overrides= JavaModelUtil.findMethodImplementationInHierarchy(hierarchy, type, curr.getElementName(), curr.getParameterTypes(), curr.isConstructor());
+// genStubSettings.callSuper= (overrides != null);
+//
+// IMethod desc= JavaModelUtil.findMethodDeclarationInHierarchy(hierarchy, type, curr.getElementName(), curr.getParameterTypes(), curr.isConstructor());
+// if (desc != null) {
+// curr= desc;
+// }
+// result[i]= genStub(type.getElementName(), curr, genStubSettings, imports);
+// }
+// return result;
+// }
+
+ /**
+ * Examines a string and returns the first line delimiter found.
+ */
+// public static String getLineDelimiterUsed(IJavaElement elem) throws JavaModelException {
+// ICompilationUnit cu= (ICompilationUnit) elem.getAncestor(IJavaElement.COMPILATION_UNIT);
+// if (cu != null && cu.exists()) {
+// IBuffer buf= cu.getBuffer();
+// int length= buf.getLength();
+// for (int i= 0; i < length; i++) {
+// char ch= buf.getChar(i);
+// if (ch == SWT.CR) {
+// if (i + 1 < length) {
+// if (buf.getChar(i + 1) == SWT.LF) {
+// return "\r\n"; //$NON-NLS-1$
+// }
+// }
+// return "\r"; //$NON-NLS-1$
+// } else if (ch == SWT.LF) {
+// return "\n"; //$NON-NLS-1$
+// }
+// }
+// }
+// return System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+// }
+
+ /**
+ * Embodies the policy which line delimiter to use when inserting into
+ * a document.
+ */
+ public static String getLineDelimiterFor(IDocument doc) {
+ // new for: 1GF5UU0: ITPJUI:WIN2000 - "Organize Imports" in php editor inserts lines in wrong format
+ String lineDelim= null;
+ try {
+ lineDelim= doc.getLineDelimiter(0);
+ } catch (BadLocationException e) {
+ }
+ if (lineDelim == null) {
+ String systemDelimiter= System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+ String[] lineDelims= doc.getLegalLineDelimiters();
+ for (int i= 0; i < lineDelims.length; i++) {
+ if (lineDelims[i].equals(systemDelimiter)) {
+ lineDelim= systemDelimiter;
+ break;
+ }
+ }
+ if (lineDelim == null) {
+ lineDelim= lineDelims.length > 0 ? lineDelims[0] : systemDelimiter;
+ }
+ }
+ return lineDelim;
+ }
+
+
+ /**
+ * Evaluates the indention used by a Java element. (in tabulators)
+ */
+// public static int getIndentUsed(IJavaElement elem) throws JavaModelException {
+// if (elem instanceof ISourceReference) {
+// ICompilationUnit cu= (ICompilationUnit) elem.getAncestor(IJavaElement.COMPILATION_UNIT);
+// if (cu != null) {
+// IBuffer buf= cu.getBuffer();
+// int offset= ((ISourceReference)elem).getSourceRange().getOffset();
+// int i= offset;
+// // find beginning of line
+// while (i > 0 && !Strings.isLineDelimiterChar(buf.getChar(i - 1)) ){
+// i--;
+// }
+// return Strings.computeIndent(buf.getText(i, offset - i), CodeFormatterUtil.getTabWidth());
+// }
+// }
+// return 0;
+// }
+
+ public static String codeFormat(String sourceString, int initialIndentationLevel, String lineDelim) {
+ ICodeFormatter formatter= ToolFactory.createDefaultCodeFormatter(null);
+ return formatter.format(sourceString, initialIndentationLevel, null, lineDelim);
+ }
+
+ /**
+ * Returns the element after the give element.
+ */
+// public static IJavaElement findNextSibling(IJavaElement member) throws JavaModelException {
+// IJavaElement parent= member.getParent();
+// if (parent instanceof IParent) {
+// IJavaElement[] elements= ((IParent)parent).getChildren();
+// for (int i= elements.length - 2; i >= 0 ; i--) {
+// if (member.equals(elements[i])) {
+// return elements[i+1];
+// }
+// }
+// }
+// return null;
+// }
+//
+// public static String getTodoTaskTag(IJavaProject project) {
+// String markers= null;
+// if (project == null) {
+// markers= JavaCore.getOption(JavaCore.COMPILER_TASK_TAGS);
+// } else {
+// markers= project.getOption(JavaCore.COMPILER_TASK_TAGS, true);
+// }
+//
+// if (markers != null && markers.length() > 0) {
+// int idx= markers.indexOf(',');
+// if (idx == -1) {
+// return markers;
+// } else {
+// return markers.substring(0, idx);
+// }
+// }
+// return null;
+// }
+
+}
git://git.phpeclipse.com / phpeclipse.git / blobdiff