← Back to branch summary

~ubuntu-branches/ubuntu/wily/aspectj/wily-proposed

« back to all changes in this revision

Viewing changes to org.aspectj/modules/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan
  • Date: 2011-03-15 23:54:31 UTC
  • mfrom: (1.2.5 upstream)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20110315235431-iq2gxbsx08kpwuiw
* New upstream release.
* Updated Standards-Version to 3.9.1 (no changes needed).
* Fix local Javadoc links:
  - d/patches/07_javadoc_links.diff: Use locally installed
   javadoc packages and hyperlink with them.
  - d/control: Add B-D on default-java-doc and libasm3-java-doc.
* d/control: Drop B-D on itself (our new bootstrap infrastructure doesn't need
  that anymore).
* Split packages into :
  - aspectj: only contains CLI tools.
  - libaspectj-java: JAR librairies for /usr/share/java.
  - libaspectj-java-doc: 4 API's Javadoc.
  - aspectj-doc: Programming Guides and SDK Documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
org.aspectj/modules/org.aspectj.matcher/src/org/aspectj/weaver/TypeFactory.java
69
69
         * Creates a sensible unresolvedtype from some signature, for example: signature = LIGuard<TT;>; bound = toString=IGuard<T>
70
70
         * sig=PIGuard<TT;>; sigErasure=LIGuard; kind=parameterized
71
71
         */
72
 
        private static UnresolvedType convertSigToType(String aSignature) {
 
72
        static UnresolvedType convertSigToType(String aSignature) {
73
73
                UnresolvedType bound = null;
74
74
                int startOfParams = aSignature.indexOf('<');
75
75
                if (startOfParams == -1) {
132
132
                                        endOfParams = locateMatchingEndAngleBracket(lastType, startOfParams);
133
133
                                        typeParams = createTypeParams(lastType.substring(startOfParams + 1, endOfParams));
134
134
                                }
 
135
                                StringBuilder s = new StringBuilder();
 
136
                                int firstAngleBracket = signature.indexOf('<');
 
137
                                s.append("P").append(signature.substring(1, firstAngleBracket));
 
138
                                s.append('<');
 
139
                                for (UnresolvedType typeParameter : typeParams) {
 
140
                                        s.append(typeParameter.getSignature());
 
141
                                }
 
142
                                s.append(">;");
 
143
                                signature = s.toString();//'P' + signature.substring(1);
135
144
                                return new UnresolvedType(signature, signatureErasure, typeParams);
136
145
                        }
137
146
                        // can't replace above with convertSigToType - leads to stackoverflow
185
194
                } else if (firstChar == '@') {
186
195
                        // missing type
187
196
                        return ResolvedType.MISSING;
 
197
                } else if (firstChar == 'L') {
 
198
                        // only an issue if there is also an angle bracket
 
199
                        int leftAngleBracket = signature.indexOf('<');
 
200
 
 
201
                        if (leftAngleBracket == -1) {
 
202
                                return new UnresolvedType(signature);
 
203
                        } else {
 
204
                                int endOfParams = locateMatchingEndAngleBracket(signature, leftAngleBracket);
 
205
                                StringBuffer erasureSig = new StringBuffer(signature);
 
206
                                erasureSig.setCharAt(0, 'L');
 
207
                                while (leftAngleBracket != -1) {
 
208
                                        erasureSig.delete(leftAngleBracket, endOfParams + 1);
 
209
                                        leftAngleBracket = locateFirstBracket(erasureSig);
 
210
                                        if (leftAngleBracket != -1) {
 
211
                                                endOfParams = locateMatchingEndAngleBracket(erasureSig, leftAngleBracket);
 
212
                                        }
 
213
                                }
 
214
 
 
215
                                String signatureErasure = erasureSig.toString();
 
216
 
 
217
                                // TODO should consider all the intermediate parameterizations as well!
 
218
                                // the type parameters of interest are only those that apply to the 'last type' in the signature
 
219
                                // if the signature is 'PMyInterface<String>$MyOtherType;' then there are none...
 
220
                                String lastType = null;
 
221
                                int nestedTypePosition = signature.indexOf("$", endOfParams); // don't look for $ INSIDE the parameters
 
222
                                if (nestedTypePosition != -1) {
 
223
                                        lastType = signature.substring(nestedTypePosition + 1);
 
224
                                } else {
 
225
                                        lastType = new String(signature);
 
226
                                }
 
227
                                leftAngleBracket = lastType.indexOf("<");
 
228
                                UnresolvedType[] typeParams = UnresolvedType.NONE;
 
229
                                if (leftAngleBracket != -1) {
 
230
                                        endOfParams = locateMatchingEndAngleBracket(lastType, leftAngleBracket);
 
231
                                        typeParams = createTypeParams(lastType.substring(leftAngleBracket + 1, endOfParams));
 
232
                                }
 
233
                                StringBuilder s = new StringBuilder();
 
234
                                int firstAngleBracket = signature.indexOf('<');
 
235
                                s.append("P").append(signature.substring(1, firstAngleBracket));
 
236
                                s.append('<');
 
237
                                for (UnresolvedType typeParameter : typeParams) {
 
238
                                        s.append(typeParameter.getSignature());
 
239
                                }
 
240
                                s.append(">;");
 
241
                                signature = s.toString();//'P' + signature.substring(1);
 
242
                                return new UnresolvedType(signature, signatureErasure, typeParams);
 
243
                        }
 
244
 
188
245
                }
189
246
                return new UnresolvedType(signature);
190
247
        }
224
281
 
225
282
        private static UnresolvedType[] createTypeParams(String typeParameterSpecification) {
226
283
                String remainingToProcess = typeParameterSpecification;
227
 
                List types = new ArrayList();
 
284
                List<UnresolvedType> types = new ArrayList<UnresolvedType>();
228
285
                while (remainingToProcess.length() != 0) {
229
286
                        int endOfSig = 0;
230
287
                        int anglies = 0;
 
288
                        boolean hadAnglies = false;
231
289
                        boolean sigFound = false; // OPTIMIZE can this be done better?
232
290
                        for (endOfSig = 0; (endOfSig < remainingToProcess.length()) && !sigFound; endOfSig++) {
233
291
                                char thisChar = remainingToProcess.charAt(endOfSig);
234
292
                                switch (thisChar) {
235
293
                                case '<':
236
294
                                        anglies++;
 
295
                                        hadAnglies = true;
237
296
                                        break;
238
297
                                case '>':
239
298
                                        anglies--;
260
319
                                        }
261
320
                                }
262
321
                        }
263
 
                        types.add(createTypeFromSignature(remainingToProcess.substring(0, endOfSig)));
 
322
                        String forProcessing = remainingToProcess.substring(0, endOfSig);
 
323
                        if (hadAnglies && forProcessing.charAt(0) == 'L') {
 
324
                                forProcessing = "P" + forProcessing.substring(1);
 
325
                        }
 
326
                        types.add(createTypeFromSignature(forProcessing));
264
327
                        remainingToProcess = remainingToProcess.substring(endOfSig);
265
328
                }
266
329
                UnresolvedType[] typeParams = new UnresolvedType[types.size()];