JSVariant whose choices are being set.
169590
private void setChoices(BigInteger multiChoice, BigInteger radix, JSchema schema, JSVariant[] vars) {
    for (int j = 0; j < vars.length; j++) {
      radix = radix.divide(vars[j].getMultiChoiceCount());
      BigInteger contrib = multiChoice.divide(radix);
      multiChoice = multiChoice.remainder(radix);
      setChoices(contrib, schema, vars[j]);
    }
  }
1021251
private int checkVariants(String variants, String sep) {
        StringTokenIterator itr = new StringTokenIterator(variants, sep);
        while (!itr.isDone()) {
            String s = itr.current();
            if (!LanguageTag.isVariant(s)) {
                return itr.currentStart();
            }
            itr.next();
        }
        return -1;
    }
139449
function (x, y, z) {
            y = (typeof (y) !== "undefined" ? y : x);
            z = (typeof (z) !== "undefined" ? z : x);
            return this._set(this.x * x, this.y * y, this.z * z);
        }
346154
public void checkInvariants(CallStack frame, Tuple<Expr> invariants) {
		for (int i = 0; i != invariants.size(); ++i) {
			RValue.Bool b = executeExpression(BOOL_T, invariants.get(i), frame);
			if (b == RValue.False) {
				// FIXME: need to do more here
				throw new AssertionError();
			}
		}
	}
47254
def match_const(self, tokens, item):
        """"""
        match, = tokens
        if match in const_vars:
            self.add_check(item + " is " + match)
        else:
            self.add_check(item + " == " + match)
737573
function setVars(origEnv, setVars) {
  var key;
  if (typeof setVars !== 'object')
    return;
  if (Array.isArray(setVars))
    return;
  for (key in setVars) {
    if (has(setVars, key)) {
      if (!has(origEnv, key)) {
        origEnv[key] = [
          !!has(process.env, key),
          process.env[key]
        ];
      }
      process.env[key] = setVars[key];
    }
  }
  return;
}
494369
@Override
	public void setVariants(Map<String, VariantSet> variantSets) {

		if (variantSets != null) {
			this.variants = new TreeMap<>(variantSets);
			variantKeys = VariantUtils.getAllVariantKeys(this.variants);
		}
	}
578106
function EnumSet(iter) {
    var p = {};
    priv.set(this, p);
    var newIter = iter;
    if (Array.isArray(iter)) {
      newIter = Array.prototype.map.call(iter, function(x) {
        return [x, x];
      });
    } else if(iter && typeof iter.entries === 'function') {
      if (iter instanceof EnumMap) {
        newIter = {
          entries: function() {
            var pi = priv.get(iter);
            return new Iterator(pi.sequence.sequence, undefined, function(x) {
              return [x, x];
            });
          }
        };
      }
    }
    p.sequence = new Sequence(newIter);
  }
701184
private void reusePreviouslyUsedVariableMap(SortedSet<Assignment> varsToRename) {
    // If prevUsedRenameMap had duplicate values then this pass would be
    // non-deterministic.
    // In such a case, the following will throw an IllegalArgumentException.
    checkNotNull(prevUsedRenameMap.getNewNameToOriginalNameMap());
    for (Assignment a : varsToRename) {
      String prevNewName = prevUsedRenameMap.lookupNewName(a.oldName);
      if (prevNewName == null || reservedNames.contains(prevNewName)) {
        continue;
      }

      if (a.isLocal
          || (!externNames.contains(a.oldName)
              && prevNewName.startsWith(prefix))) {
        reservedNames.add(prevNewName);
        finalizeNameAssignment(a, prevNewName);
      }
    }
  }
567938
function(k, v, a) {
      for (var n = 0; n < a.length; ++n) {
        if (v === a[n]) {
          this.set(k, v);
          break;
        }
      }
    }
598802
private boolean vForVariable(String loopVariablesDefinition, TemplateParserContext context) {
    Matcher matcher = VFOR_VARIABLE.matcher(loopVariablesDefinition);
    if (matcher.matches()) {
      initLoopVariable(matcher.group(1), matcher.group(2), context);
      indexVariableInfo = null;
      return true;
    }

    return false;
  }
134080
function UMLStateInvariantView() {
        NodeView.apply(this, arguments);
        this.movable = Core.MM_VERT;
        this.zIndex = 1;

        /** @member {LabelView} */
        this.invariantLabel = new LabelView();
        this.invariantLabel.horizontalAlignment = Graphics.AL_CENTER;
        this.invariantLabel.verticalAlignment = Graphics.AL_MIDDLE;
        this.addSubView(this.invariantLabel);
    }
1142934
function (options) {
			
			inputEx.SelectTwiceField.superclass.setOptions.call(this, options);
			
			this.options.choices = lang.isArray(options.choices) ? options.choices : [];
			
			this.options.valueSeparator = options.valueSeparator || "_";
			
		}
945382
public JSVariant[] getDominatedVariants() {
    if (dominated == null) {
      List dom = new ArrayList();
      getDominatedVariants(dom);
      dominated = (JSVariant[])dom.toArray(new JSVariant[0]);
    }
    return dominated;
  }
894563
function () {
                        //noinspection JSReferencingMutableVariableFromClosure
                        res.push({
                            combine: 1,
                            path: prefix + currentComboUrls.join(comboSep) + suffix,
                            mods: currentComboMods
                        });
                    }
23543
private boolean setDominatingCases(JSType field) {

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "setDominatingCases", new Object[]{field});

    field = findDominatingCase(field);

    JSVariant parent = (JSVariant) field.getParent();

    if (parent == null) {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "setDominatingCases", Boolean.FALSE);
      return false;
    }

    boolean result = setCaseChain(parent.getIndex(), field.getSiblingPosition());

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "setDominatingCases", Boolean.valueOf(result));
    return result;
  }
104257
function prop(v, w) { return {
  value: v, writable: w, enumerable: true, configurable: false
}}