Lines Matching defs:names
44 * It consists of a series of names.
45 * The first N (N=arity) names are parameters,
46 * while any remaining names are temporary values.
49 * constant values and local names.
50 * The result of the lambda is defined as one of the names, often the last one.
123 final Name[] names;
134 int arity, Name[] names, int result) {
135 assert(namesOK(arity, names));
137 this.result = fixResult(result, names);
138 this.names = names.clone();
144 int arity, Name[] names) {
146 arity, names, LAST_RESULT);
158 Name[] names = Arrays.copyOf(formals, length);
159 System.arraycopy(temps, 0, names, arity, temps.length);
161 names[length - 1] = result;
162 return names;
172 this.names = buildEmptyNames(arity, sig);
185 Name[] names = arguments(numRes, basicTypeSignature.substring(0, arity));
187 names[arity + i] = constantZero(arity + i, basicTypeSignature.charAt(resultPos + i));
189 return names;
192 private static int fixResult(int result, Name[] names) {
194 if (names[result].type == 'V')
197 return names.length - 1;
202 private static boolean namesOK(int arity, Name[] names) {
203 for (int i = 0; i < names.length; i++) {
204 Name n = names[i];
218 for (int i = 0; i < names.length; i++) {
219 Name n = names[i];
222 oldNames = names.clone();
225 names[i] = n.cloneWithIndex(i);
232 for (int i = startFixing; i < names.length; i++) {
233 Name fixed = names[i].replaceNames(oldNames, names, changesStart, i);
234 names[i] = fixed.newIndex(i);
241 Name n = names[i], n2 = internArgument(n);
243 names[i] = n2;
248 for (int i = arity; i < names.length; i++) {
249 names[i].internArguments();
265 assert(arity >= 0 && arity <= names.length);
266 assert(result >= -1 && result < names.length);
267 // Do all names possess an index consistent with their local definition order?
269 Name n = names[i];
274 for (int i = arity; i < names.length; i++) {
275 Name n = names[i];
281 assert(0 <= i2 && i2 < names.length) : n.debugString() + ": 0 <= i2 && i2 < names.length: 0 <= " + i2 + " < " + names.length;
282 assert(names[i2] == n2) : Arrays.asList("-1-", i, "-2-", n.debugString(), "-3-", i2, "-4-", n2.debugString(), "-5-", names[i2].debugString(), "-6-", this);
299 Name n = names[result];
306 return names[n].type;
602 Object[] values = Arrays.copyOf(argumentValues, names.length);
604 values[i] = interpretName(names[i], values);
620 assert(names[i2] == a);
650 Object[] values = Arrays.copyOf(argumentValues, names.length);
652 values[i] = interpretName(names[i], values);
703 return (names.length == arity);
704 else if (result == arity && names.length == arity + 1)
705 return names[arity].isConstantZero();
712 for (int i = 0; i < names.length; i++) {
714 Name n = names[i];
724 buf.append(result < 0 ? "void" : names[result]).append("}");
740 assert pos > 0 && pos < arity && names[pos].type == basicType && Name.typesMatch(basicType, value);
743 Name[] names2 = new Name[names.length - 1];
744 for (int r = 0, w = 0; r < names.length; ++r, ++w) { // (r)ead from names, (w)rite to names2
745 Name n = names[r];
783 Name name = names[namePos];
785 return bind(name, newData.getterName(names[0], oldData.fieldCount()), oldData, newData);
794 assert(0 <= pos && pos < arity && names[pos] == name);
808 Name[] names2 = names.clone();
815 Name n = names[i];
832 // Walk over the new list of names once, in forward order.
839 names2[i] = names2[i].replaceNames(names, names2, pos, i);
867 return pos < names.length && name.equals(names[pos]);
869 for (int i = arity; i < names.length; i++) {
870 if (name.equals(names[i]))
878 int length = names.length;
880 Name[] names2 = Arrays.copyOf(names, length + inTypes);
885 // names array has MH in slot 0; skip it.
889 System.arraycopy(names, argpos, names2, argpos + inTypes, length - argpos);
906 int length = names.length;
910 assert(permutedTypesMatch(reorder, types, names, skip));
915 System.arraycopy(names, 0, names2, 0, skip+pos);
918 System.arraycopy(names, skip+outArgs, names2, skip+inTypes, bodyLength);
929 // rework names in the body:
931 Name n = names[skip+j];
933 // replace names[skip+j] by names2[skip+i]
943 // some names are unused, but must be filled in
948 for (int j = arity; j < names.length; j++) {
950 // replace names2[i] by names[j]
951 Name n = names[j];
962 static boolean permutedTypesMatch(int[] reorder, char[] types, Name[] names, int skip) {
966 assert(names[skip+i].isParam());
967 assert(names[skip+i].type == types[reorder[i]]);
1238 for (Name n : names) n.resolve();
1491 Name[] names = new Name[length + extra];
1493 names[i] = argument(i, types.charAt(i));
1494 return names;
1498 Name[] names = new Name[length + extra];
1500 names[i] = argument(i, types[i]);
1501 return names;
1505 Name[] names = new Name[length + extra];
1507 names[i] = argument(i, basicType(types.get(i)));
1508 return names;
1512 Name[] names = new Name[length + extra];
1514 names[i] = argument(i, basicType(types[i]));
1515 return names;
1519 Name[] names = new Name[length + extra];
1521 names[i] = argument(i, basicType(types.parameterType(i)));
1522 return names;