triggered when a from statement is seen
494207
def visit_importfrom(self, node):
        ''''''
        if self.process_module:
            if not node.modname.startswith('salt'):
                return
            # Store salt imported modules
            for module, import_as in node.names:
                if import_as and import_as not in self.imported_salt_modules:
                    self.imported_salt_modules[import_as] = import_as
                    continue
                if module not in self.imported_salt_modules:
                    self.imported_salt_modules[module] = module
881981
public void out2in(Object from, String from_out, Object... tos) {
        for (Object co : tos) {
            out2in(from, from_out, co, from_out);
        }
    }
688122
def when_value_edited(self, *args, **kargs):
        
        if len(self.value) > self.instance_num:
            self.value.pop(-2)
            self.display()
59001
def _from(self, line):
        ''' 

        '''
        self.fromHeader = line
        bot.debug('FROM %s' %self.fromHeader)
427763
void feedback(Object from, String from_out, Object to, String to_in) {
        // add them to the set of commands
        if (from == to) {
            throw new ComponentException("src == dest.");
        }
        if (to_in == null || from_out == null) {
            throw new ComponentException("Some field arguments are null");
        }

        ComponentAccess ca_from = lookup(from);
        ComponentAccess ca_to = lookup(to);

        Access from_access = ca_from.output(from_out);
        checkFA(from_access, from, from_out);
        Access to_access = ca_to.input(to_in);
        checkFA(to_access, to, to_in);

        if (!canConnect(from_access, to_access)) {
            throw new ComponentException("Type/Access mismatch, Cannot connect: " + from + '.' + to_in + " -> " + to + '.' + from_out);
        }

        // src data object
        FieldContent data = from_access.getData();
        data.tagIn();
        data.tagOut();

        //      dataSet.add(data);
        to_access.setData(data);                       // connect the two

        ca_from.setOutput(from_out, new AsyncFieldAccess(from_access));
        ca_to.setInput(to_in, new AsyncFieldAccess(to_access));

        if (checkCircular) {
            //   val.addConnection(from, to);
//            val.checkCircular();
        }

        if (log.isLoggable(Level.CONFIG)) {
            log.config(String.format("feedback @Out(%s) -> @In(%s)", from_access.toString() , to_access.toString()));
        }
//        ens.fireConnect(from_access, to_access);
    }
660171
function lockedCheck(from, to) {
  from = fis.file.wrap(from).realpath;
  to = fis.file.wrap(to).realpath;
  if (from === to) {
    return true;
  } else if (lockedMap[to]) {
    var prev = from;
    var msg = [];

    do {
      msg.unshift(prev);
      prev = lockedMap[prev];
    } while (prev);

    prev && msg.unshift(prev);
    msg.push(to);
    return msg;
  }
  return false;
}
677470
public void markVisited(int from, int upTo) {
    if (checkBounds(from) && checkBounds(upTo - 1)) {
      for (int i = from; i < upTo; i++) {
        this.markVisited(i);
      }
    }
    else {
      throw new RuntimeException("The location " + from + "," + upTo + " out of bounds [0,"
          + (this.registry.length - 1) + "]");
    }
  }
630721
function onBeforeShow() {
    var trigger = self.hc_.getAnchorElement();
    var ch = self.getChar_(trigger);
    if (ch) {
      self.zoomEl_.innerHTML = self.displayChar_(ch);
      self.unicodeEl_.innerHTML = goog.i18n.uChar.toHexString(ch);
      // Clear the character name since we don't want to show old data because
      // it is retrieved asynchronously and the DOM object is re-used
      self.charNameEl_.innerHTML = '';
      self.charNameFetcher_.getName(ch, function(charName) {
        if (charName) {
          self.charNameEl_.innerHTML = charName;
        }
      });
    }
  }
1231584
def OnActivateReader(self, reader):
        """"""
        SimpleSCardAppEventObserver.OnActivateReader(self, reader)
        self.feedbacktext.SetLabel('Activated reader: ' + repr(reader))
280610
private function fromCheck($from, $quotes = null)
    {
        if ($from == "") {
            $from = $this->from;
        }
        if ($quotes === null) {
            $quotes = $this->quotes;
        }
        if ($quotes) {
            $from = "`" . $from . "`";
        }

        return $from;
    }
1331078
def trigger_show_by_id(self, id, **kwargs):
        ""
        api_path = "/api/v2/triggers/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1331778
protected function peek($regex, &$out, $from = null)
    {
        if (! isset($from)) {
            $from = $this->count;
        }

        $r = '/' . $regex . '/' . $this->patternModifiers;
        $result = preg_match($r, $this->buffer, $out, null, $from);

        return $result;
    }
1171188
def print_start_trigger(self, type):
        '''
        '''
        types = {'recieved': 1,
                 'filled': 2,
                 'num_recieved': 3}
        
        if type in types:
            self.send('^PT'+chr(types[type]))
        else:
            raise RuntimeError('Invalid type.')
609046
function getBearing(from, to) {

        if (from.x === to.x) return (from.y > to.y) ? 'N' : 'S';
        if (from.y === to.y) return (from.x > to.x) ? 'W' : 'E';
        return null;
    }
1349492
function(newStatement) {
    var oldStatement = !this.outputConnection;
    if (newStatement != oldStatement) {
      this.unplug(true, true);
      if (newStatement) {
        this.setOutput(false);
        this.setPreviousStatement(true);
        this.setNextStatement(true);
      } else {
        this.setPreviousStatement(false);
        this.setNextStatement(false);
        this.setOutput(true);
      }
    }
  }
17542
function handleNotifyNext(e) {
  if (notifyOfNextSubs[e.type].length === 0) return;
  e.persist = blankFunction;
  const reNotifyOfNext = [];
  const reNotifyOfNextIDs = {};
  notifyOfNextSubs[e.type].forEach(sub => {
    if (sub.callback(e) === 'reNotifyOfNext') {
      reNotifyOfNextIDs[sub.id] = reNotifyOfNext.push(sub) - 1;
    }
  });
  notifyOfNextSubs[e.type] = reNotifyOfNext;
  subsIDs[e.type] = reNotifyOfNextIDs;
}
1217657
@Override
    public void sawOpcode(int seen) {
        switch (state) {
            case IN_CLINIT:
                sawCLInitOpcode(seen);
            break;

            case IN_INIT:
                sawInitOpcode(seen);
            break;

            case IN_METHOD:
                sawMethodOpcode(seen);
            break;
        }
    }