| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.axis.tools.common; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| /** |
| * A parameter from a method signature. The parameter is the datatype plus its |
| * name but not its value. |
| */ |
| public class Parameter { |
| private ArrayList type = new ArrayList(); |
| private String name = null; |
| private boolean failed = false; |
| |
| /** |
| * Defaults to a parameter in a parameter list so it HAS a parameter name in it |
| */ |
| Parameter(List parts) { |
| this(parts, false); |
| } |
| |
| /** |
| * A parameter which is a return type does not have a parameter name. |
| * Parameters in a parameter list do have parameter names embedded in them |
| */ |
| Parameter(List parts, boolean isRetType) { |
| if (parts == null || parts.size() == 0) |
| return; |
| |
| if (!isRetType && parts.size() == 1) { |
| if ("...".equals(parts.get(0))) { |
| type.add("..."); |
| name = ""; |
| } else if (!"void".equals(parts.get(0))) |
| failed = true; // Seems like bad C++ code here |
| return; |
| } |
| |
| if (isRetType) { |
| Iterator it = parts.iterator(); |
| while (it.hasNext()) |
| type.add(it.next()); |
| |
| // Some methods return have void on their signature and others |
| // have nothing. So to make them both the same, if a method |
| // doesn't return anything make type null. |
| // TODO: This assumption is wrong - methods that return nothing default to returning an int! |
| if (1 == type.size() && "void".equals(type.get(0))) |
| type = new ArrayList(); |
| |
| } else { |
| // Cope with array subscripts [] after the name |
| int arrIdx = -1; |
| for (int i = 0; i < parts.size(); i++) { |
| String tok = (String) parts.get(i); |
| if ("[".equals(tok)) { |
| arrIdx = i; |
| break; |
| } |
| } |
| |
| // Find the name |
| int nameIdx = parts.size() - 1; |
| if (-1 != arrIdx) |
| nameIdx = arrIdx - 1; |
| |
| // Even in real method declarations, parameters may not have a name |
| boolean noName = false; |
| name = (String) parts.get(nameIdx); |
| if (Utils.cPrimitives.contains(name) || Utils.cTypeQualifiers.contains(name)) |
| noName = true; |
| |
| if (noName) { |
| name = null; |
| for (int i = 0; i < parts.size(); i++) |
| type.add(parts.get(i)); |
| } else { |
| // Construct the type |
| for (int i = 0; i < nameIdx; i++) |
| type.add(parts.get(i)); |
| |
| if (-1 != arrIdx) |
| for (int i = arrIdx; i < parts.size(); i++) |
| type.add(parts.get(i)); |
| } |
| } |
| } |
| |
| public boolean failed() { |
| return failed; |
| } |
| |
| public String getType() { |
| String s = null; |
| Iterator it = type.iterator(); |
| while (it.hasNext()) { |
| String next = (String) it.next(); |
| if (null == s) |
| s = next; |
| else if ("*".equals(next) || "&".equals(next)) |
| s += next; |
| else |
| s += " " + next; |
| } |
| return s; |
| } |
| |
| public String getTypeWithoutConst() { |
| String s = null; |
| Iterator it = type.iterator(); |
| while (it.hasNext()) { |
| String next = (String) it.next(); |
| if ("const".equals(next)) |
| continue; |
| else if (null == s) |
| s = next; |
| else if ("*".equals(next) || "&".equals(next)) |
| s += next; |
| else |
| s += " " + next; |
| } |
| return s; |
| } |
| |
| public String getName() { |
| return name; |
| } |
| |
| public boolean isVoid() { |
| return 0 == type.size(); |
| } |
| |
| public boolean isDotDotDot() { |
| return 1 == type.size() && "...".equals(type.get(0)); |
| } |
| |
| public boolean isVaListArg() |
| { |
| String s = null; |
| Iterator it = type.iterator(); |
| while (it.hasNext()) |
| { |
| String next = (String) it.next(); |
| if ("va_list".equals(next)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * For two parameters to match their types must match or both be null, |
| * but the parameters names don't have to match. Just because a parameter |
| * is called something different in a header file as in the the source file |
| * doesn't mean it's a different parameter. |
| */ |
| public boolean equals(Object o) { |
| if (null == o || !(o instanceof Parameter)) |
| return false; |
| Parameter that = (Parameter) o; |
| if (type.size() != that.type.size()) |
| return false; |
| for (int i = 0; i < type.size(); i++) { |
| String s1 = (String) type.get(i); |
| String s2 = (String) that.type.get(i); |
| if (!Utils.safeEquals(s1,s2)) |
| return false; |
| } |
| return true; |
| } |
| |
| public String toString() { |
| if (0 == type.size()) |
| return "void"; |
| if (null == name) |
| return getType(); |
| return getType() + " " + name; |
| } |
| |
| public Iterator iterator() { |
| if (null == type) |
| return null; |
| return type.iterator(); |
| } |
| } |