Compute current modifiers
505699
function _getModifiers() {
    var modifiers = '';
    if(_downKeys.length) {
      for(var i=_downKeys.length-1; i>=0; i--) {
        if(-1 !== _that.MODIFIERS.indexOf(_downKeys[i])) {
          modifiers += (modifiers ? ' ' : '') + _downKeys[i];
        }
      }
    }
    return modifiers;
  }
1183380
function modPlus(x, y){
        var low = (x & 0xFFFF) + (y & 0xFFFF),
            high = (x >> 16) + (y >> 16) + (low >> 16);

        return (high << 16) | (low & 0xFFFF);
    }
651727
function updateModifiers() {
  if (this.state.isDestroyed) {
    return;
  }
  // Deep merge modifiers options
  let options = this.defaultOptions;
  this.options.modifiers = {};
  const _this = this;
  Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
    _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
  });

  // Refactoring modifiers' list (Object => Array)
  this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
    return _extends({
      name: name
    }, _this.options.modifiers[name]);
  })
  // sort the modifiers by order
    .sort(function (a, b) {
      return a.order - b.order;
    });

  // modifiers have the ability to execute arbitrary code when Popper.js get inited
  // such code is executed in the same order of its modifier
  // they could add new properties to their options configuration
  // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
  this.modifiers.forEach(function (modifierOptions) {
    if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
      modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
    }
  });
}
1275989
public function getModifiers()
    {
        $modifiers = 0;

        if ($this->isFinal()) {
            $modifiers += \ReflectionClass::IS_FINAL;
        }

        if (PHP_VERSION_ID < 70000 && $this->isTrait()) {
            $modifiers += \ReflectionClass::IS_EXPLICIT_ABSTRACT;
        }

        if ($this->classLikeNode instanceof Class_ && $this->classLikeNode->isAbstract()) {
            $modifiers += \ReflectionClass::IS_EXPLICIT_ABSTRACT;
        }

        if ($this->isInterface()) {
            $abstractMethods = $this->getMethods();
        } else {
            $abstractMethods = $this->getMethods(\ReflectionMethod::IS_ABSTRACT);
        }
        if (!empty($abstractMethods)) {
            $modifiers += \ReflectionClass::IS_IMPLICIT_ABSTRACT;
        }

        return $modifiers;
    }
724442
synchronized void computeDominators() {
        boolean changed = true;
        boolean igonoreDirty;
        try {
            do {
                currentMultipleParents.rewind();
                igonoreDirty = !changed;
                changed = computeOneLevel(igonoreDirty);
                switchParents();
            } while (changed || !igonoreDirty);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        deleteBuffers();
        dirtySet = Collections.EMPTY_SET;
    }
868317
private static function modifierArray($modifiers = []): array {
        if (is_string($modifiers)) {
            return [$modifiers];
        }
        $array = [];
        if (is_array($modifiers)) {
            foreach ($modifiers as $key => $value) {
                if (!$value) {
                    continue;
                }
                if (is_array($value)) {
                    $array = array_merge($array, self::modifierArray($value));
                } else if (is_string($value)) {
                    $array[] = $value;
                } else if (is_string($key)) {
                    $array[] = $key;
                }
            }
        }
        return array_unique($array);
    }
76603
static void modifiersToString(final int modifiers, final StringBuilder buf) {
        if ((modifiers & Modifier.FINAL) != 0) {
            buf.append("final ");
        }
        if ((modifiers & 0x1000) != 0) {
            buf.append("synthetic ");
        }
        if ((modifiers & 0x8000) != 0) {
            buf.append("mandated ");
        }
    }
691753
function (modifierName, out) {
                var modifier = __modifiers[modifierName];
                if (modifier && modifier.init) {
                    modifier.init(out);
                }
            }
877653
def get_modifier_mapping(self):
        """"""
        r = request.GetModifierMapping(display = self.display)
        return r.keycodes
598917
def _compute(self):
        """"""
        tendencies = {}
        for name, value in self.state.items():
            tendencies[name] = value * 0.
        return tendencies
435268
def get_modifications(self):
        """"""
        # Get all the specific mod types
        mod_event_types = list(ont_to_mod_type.keys())
        # Add ONT::PTMs as a special case
        mod_event_types += ['ONT::PTM']
        mod_events = []
        for mod_event_type in mod_event_types:
            events = self.tree.findall("EVENT/[type='%s']" % mod_event_type)
            mod_extracted = self.extracted_events.get(mod_event_type, [])
            for event in events:
                event_id = event.attrib.get('id')
                if event_id not in mod_extracted:
                    mod_events.append(event)

        # Iterate over all modification events
        for event in mod_events:
            stmts = self._get_modification_event(event)
            if stmts:
                for stmt in stmts:
                    self.statements.append(stmt)
1198874
public static function getPcreModifierList () {
		return array(
			static::MODIFIER_CASELESS			=> static::MODIFIER_CASELESS,
			static::MODIFIER_MULTILINE			=> static::MODIFIER_MULTILINE,
			static::MODIFIER_DOTALL				=> static::MODIFIER_DOTALL,
			static::MODIFIER_EXTENDED			=> static::MODIFIER_EXTENDED,
			static::MODIFIER_REPLACE_EVAL		=> static::MODIFIER_REPLACE_EVAL,
			static::MODIFIER_ANCHORED			=> static::MODIFIER_ANCHORED,
			static::MODIFIER_DOLLAR_ENDONLY		=> static::MODIFIER_DOLLAR_ENDONLY,
			static::MODIFIER_EXTRA_ANALYSIS		=> static::MODIFIER_EXTRA_ANALYSIS,
			static::MODIFIER_UNGREEDY			=> static::MODIFIER_UNGREEDY,
			static::MODIFIER_EXTRA				=> static::MODIFIER_EXTRA,
			static::MODIFIER_INFO_JCHANGED		=> static::MODIFIER_INFO_JCHANGED,
			static::MODIFIER_PCRE8				=> static::MODIFIER_PCRE8,
		);
	}
287078
public static int toModifiers(final String modifiers) {
        if (modifiers == null) {
            return 0;
        }
        final String trimmedModifiers = modifiers.trim();
        int modifier = 0;
        final StringTokenizer tok = new StringTokenizer(trimmedModifiers, " ");
        while (tok.hasMoreTokens()) {
            final String mod = tok.nextToken();
            modifier = modifier | modifierValueForName(mod);
        }
        return modifier;
    }
359887
def _only_shifts(self, modifiers):
        """"""
        if not modifiers or len(modifiers) > 2:
            return False
        if len(modifiers) == 2:
            return 'left shift' in modifiers and 'right shift' in modifiers
        if len(modifiers) == 1:
            return 'left shift' in modifiers or 'right shift' in modifiers
1149242
def modifiers
      last_indent = nil
      modifiers = []

      return modifiers unless modifiers_comment

      modifiers_comment.split("\n").each do |line|
        next if line.strip.empty?
        indent = line.scan(/^\s*/)[0].to_s.size

        if last_indent && indent > last_indent
          modifiers.last.description += line.squeeze(" ")
        else
          modifier, desc = line.split(" - ")
          modifiers << Modifier.new(modifier.strip, desc.strip) if modifier && desc
        end

        last_indent = indent
      end

      modifiers
    end
1065510
function dayMatchesModifier(day, modifier) {
  if (!modifier) {
    return false;
  }
  var arr = Array.isArray(modifier) ? modifier : [modifier];
  return arr.some(function (mod) {
    if (!mod) {
      return false;
    }
    if (mod instanceof Date) {
      return (0, _DateUtils.isSameDay)(day, mod);
    }
    if ((0, _Helpers.isRangeOfDates)(mod)) {
      return (0, _DateUtils.isDayInRange)(day, mod);
    }
    if (mod.after && mod.before && (0, _DateUtils.isDayAfter)(mod.before, mod.after)) {
      return (0, _DateUtils.isDayAfter)(day, mod.after) && (0, _DateUtils.isDayBefore)(day, mod.before);
    }
    if (mod.after && mod.before && ((0, _DateUtils.isDayAfter)(mod.after, mod.before) || (0, _DateUtils.isSameDay)(mod.after, mod.before))) {
      return (0, _DateUtils.isDayAfter)(day, mod.after) || (0, _DateUtils.isDayBefore)(day, mod.before);
    }
    if (mod.after) {
      return (0, _DateUtils.isDayAfter)(day, mod.after);
    }
    if (mod.before) {
      return (0, _DateUtils.isDayBefore)(day, mod.before);
    }
    if (mod.daysOfWeek) {
      return mod.daysOfWeek.some(function (dayOfWeek) {
        return day.getDay() === dayOfWeek;
      });
    }
    if (typeof mod === 'function') {
      return mod(day);
    }
    return false;
  });
}
689091
def on_change(self, value):
        ''''''
        self._modifier(self.inst, self.prop, value)