< prev index next >

src/jdk.pack200/share/native/common-unpack/unpack.cpp

Print this page
rev 16271 : 8170663: Fix minor issues in corelib and servicabilty coding.
Reviewed-by: dsamersoff, dholmes
Contributed-by: David CARLIER <devnexen@gmail.com>, goetz.lindenmaier@sap.com


2276          return;
2277       }
2278       assert(dollar2 >= pkglen);
2279       if (isDigitString(n, dollar2+1, nlen)) {
2280         // n = (<pkg>/)*<outer>$<number>
2281         number = n.slice(dollar2+1, nlen);
2282         name.set(null,0);
2283         dollar1 = dollar2;
2284       } else if (pkglen < (dollar1
2285                            = lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, n, dollar2-1))
2286                  && isDigitString(n, dollar1+1, dollar2)) {
2287         // n = (<pkg>/)*<outer>$<number>$<name>
2288         number = n.slice(dollar1+1, dollar2);
2289         name = n.slice(dollar2+1, nlen);
2290       } else {
2291         // n = (<pkg>/)*<outer>$<name>
2292         dollar1 = dollar2;
2293         number.set(null,0);
2294         name = n.slice(dollar2+1, nlen);
2295       }
2296       if (number.ptr == null)




2297         pkgOuter = n.slice(0, dollar1);
2298       else
2299         pkgOuter.set(null,0);

2300       PRINTCR((5,"=> %s$ 0%s $%s",
2301               pkgOuter.string(), number.string(), name.string()));
2302 
2303       if (pkgOuter.ptr != null)
2304         ics[i].outer = cp.ensureClass(pkgOuter);
2305 
2306       if (name.ptr != null)
2307         ics[i].name = cp.ensureUtf8(name);
2308     }
2309 
2310     // update child/sibling list
2311     if (ics[i].outer != null) {
2312       uint outord = ics[i].outer->inord;
2313       if (outord != NO_INORD) {
2314         assert(outord < (uint)cp.tag_count[CONSTANT_Class]);
2315         ics[i].next_sibling = ic_child_index[outord];
2316         ic_child_index[outord] = &ics[i];
2317       }
2318     }
2319   }


4180       }
4181     case bc_ref_escape:
4182       {
4183         // Note that insnMap has one entry for this.
4184         --wp;  // not really part of the code
4185         int size = bc_escrefsize.getInt();
4186         entry* ref = bc_escref.getRefN();
4187         CHECK;
4188         switch (size) {
4189         case 1: putu1ref(ref); break;
4190         case 2: putref(ref);   break;
4191         default: assert(false);
4192         }
4193         continue;
4194       }
4195     case bc_byte_escape:
4196       {
4197         // Note that insnMap has one entry for all these bytes.
4198         --wp;  // not really part of the code
4199         int size = bc_escsize.getInt();

4200         ensure_put_space(size);
4201         for (int j = 0; j < size; j++)
4202           putu1_fast(bc_escbyte.getByte());
4203         continue;
4204       }
4205     default:
4206       if (is_invoke_init_op(bc)) {
4207         origBC = bc_invokespecial;
4208         entry* classRef;
4209         switch (bc - _invokeinit_op) {
4210         case _invokeinit_self_option:   classRef = thisClass;  break;
4211         case _invokeinit_super_option:  classRef = superClass; break;
4212         default: assert(bc == _invokeinit_op+_invokeinit_new_option);
4213         case _invokeinit_new_option:    classRef = newClass;   break;
4214         }
4215         wp[-1] = origBC;  // overwrite with origBC
4216         int coding = bc_initref.getInt();
4217         // Find the nth overloading of <init> in classRef.
4218         entry*   ref = null;
4219         cpindex* ix = cp.getMethodIndex(classRef);




2276          return;
2277       }
2278       assert(dollar2 >= pkglen);
2279       if (isDigitString(n, dollar2+1, nlen)) {
2280         // n = (<pkg>/)*<outer>$<number>
2281         number = n.slice(dollar2+1, nlen);
2282         name.set(null,0);
2283         dollar1 = dollar2;
2284       } else if (pkglen < (dollar1
2285                            = lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, n, dollar2-1))
2286                  && isDigitString(n, dollar1+1, dollar2)) {
2287         // n = (<pkg>/)*<outer>$<number>$<name>
2288         number = n.slice(dollar1+1, dollar2);
2289         name = n.slice(dollar2+1, nlen);
2290       } else {
2291         // n = (<pkg>/)*<outer>$<name>
2292         dollar1 = dollar2;
2293         number.set(null,0);
2294         name = n.slice(dollar2+1, nlen);
2295       }
2296       if (number.ptr == null) {
2297         if (dollar1 < 0) {
2298           abort();
2299           return;
2300         }
2301         pkgOuter = n.slice(0, dollar1);
2302       } else {
2303         pkgOuter.set(null,0);
2304       }
2305       PRINTCR((5,"=> %s$ 0%s $%s",
2306               pkgOuter.string(), number.string(), name.string()));
2307 
2308       if (pkgOuter.ptr != null)
2309         ics[i].outer = cp.ensureClass(pkgOuter);
2310 
2311       if (name.ptr != null)
2312         ics[i].name = cp.ensureUtf8(name);
2313     }
2314 
2315     // update child/sibling list
2316     if (ics[i].outer != null) {
2317       uint outord = ics[i].outer->inord;
2318       if (outord != NO_INORD) {
2319         assert(outord < (uint)cp.tag_count[CONSTANT_Class]);
2320         ics[i].next_sibling = ic_child_index[outord];
2321         ic_child_index[outord] = &ics[i];
2322       }
2323     }
2324   }


4185       }
4186     case bc_ref_escape:
4187       {
4188         // Note that insnMap has one entry for this.
4189         --wp;  // not really part of the code
4190         int size = bc_escrefsize.getInt();
4191         entry* ref = bc_escref.getRefN();
4192         CHECK;
4193         switch (size) {
4194         case 1: putu1ref(ref); break;
4195         case 2: putref(ref);   break;
4196         default: assert(false);
4197         }
4198         continue;
4199       }
4200     case bc_byte_escape:
4201       {
4202         // Note that insnMap has one entry for all these bytes.
4203         --wp;  // not really part of the code
4204         int size = bc_escsize.getInt();
4205         if (size < 0) { assert(false); continue; }
4206         ensure_put_space(size);
4207         for (int j = 0; j < size; j++)
4208           putu1_fast(bc_escbyte.getByte());
4209         continue;
4210       }
4211     default:
4212       if (is_invoke_init_op(bc)) {
4213         origBC = bc_invokespecial;
4214         entry* classRef;
4215         switch (bc - _invokeinit_op) {
4216         case _invokeinit_self_option:   classRef = thisClass;  break;
4217         case _invokeinit_super_option:  classRef = superClass; break;
4218         default: assert(bc == _invokeinit_op+_invokeinit_new_option);
4219         case _invokeinit_new_option:    classRef = newClass;   break;
4220         }
4221         wp[-1] = origBC;  // overwrite with origBC
4222         int coding = bc_initref.getInt();
4223         // Find the nth overloading of <init> in classRef.
4224         entry*   ref = null;
4225         cpindex* ix = cp.getMethodIndex(classRef);


< prev index next >