Matches starred assignment.
969105
def match_star(self, tokens, item):
        """"""
        head_matches, last_matches = None, None
        if len(tokens) == 1:
            middle = tokens[0]
        elif len(tokens) == 2:
            if isinstance(tokens[0], str):
                middle, last_matches = tokens
            else:
                head_matches, middle = tokens
        else:
            head_matches, middle, last_matches = tokens
        self.add_check("_coconut.isinstance(" + item + ", _coconut.abc.Iterable)")
        if head_matches is None and last_matches is None:
            if middle != wildcard:
                self.add_def(middle + " = _coconut.list(" + item + ")")
        else:
            itervar = self.get_temp_var()
            self.add_def(itervar + " = _coconut.list(" + item + ")")
            with self.down_a_level():
                req_length = (len(head_matches) if head_matches is not None else 0) + (len(last_matches) if last_matches is not None else 0)
                self.add_check("_coconut.len(" + itervar + ") >= " + str(req_length))
                if middle != wildcard:
                    head_splice = str(len(head_matches)) if head_matches is not None else ""
                    last_splice = "-" + str(len(last_matches)) if last_matches is not None else ""
                    self.add_def(middle + " = " + itervar + "[" + head_splice + ":" + last_splice + "]")
                if head_matches is not None:
                    self.match_all_in(head_matches, itervar)
                if last_matches is not None:
                    for x in range(1, len(last_matches) + 1):
                        self.match(last_matches[-x], itervar + "[-" + str(x) + "]")
1316657
def on_star(node, compiled_grammar)
      steps = lookup_identifiers(node, compiled_grammar)
      name  = "_ll_star#{node.source_line.line}#{node.source_line.column}"
      rule  = Rule.new(name, node.source_line)

      rule.add_branch(steps, node.source_line)

      rule.increment_references

      compiled_grammar.add_rule(rule)

      return Operator.new(:star, rule, node.source_line)
    end
512565
function(key){
			var wildCardMatch = key.match(PACKAGE_DOT_STAR);
			if (wildCardMatch){
				packages[wildCardMatch[1]].forEach(loadComponent);
			} else {
				if (key in registry) resolveDeps(registry[key]);
				else throw new Error('Missing key: ' + key);
			}
		}
171496
def select_star_cb(self, widget, res_dict):
        
        keys = list(res_dict.keys())
        if len(keys) == 0:
            self.selected = []
            self.replot_stars()
        else:
            idx = int(keys[0])
            star = self.starlist[idx]
            if not self._select_flag:
                self.mark_selection(star, fromtable=True)
        return True
1355660
function Star( x, y, starSize, ctx, fgCanvas, analyser, streamData ){
	this.x = x;
	this.y = y;
	this.angle = Math.atan( Math.abs(y) / Math.abs(x) );
	this.starSize = starSize;
	this.ctx = ctx;
	this.high = 0;
	this.fgCanvas = fgCanvas;
	this.analyser = analyser;
	this.streamData = streamData;
}
646894
function reportAssignment(assignmentExpression) {
            context.report({
                node: assignmentExpression,
                messageId: "nonAtomicUpdate",
                data: {
                    value: sourceCode.getText(assignmentExpression.left)
                }
            });
        }
776513
def Assign(target, source):
    """"""
    if not isinstance(target, list):
        target = [target]
    if not isinstance(source, list):
        source.prefix = u" "
        source = [source]

    return Node(syms.atom,
                target + [Leaf(token.EQUAL, u"=", prefix=u" ")] + source)
184313
def all_good_stars(self):
        

        stars = []
        for star in self.all_stars:
            if star._excluded_from_fit:
                continue
            else:
                stars.append(star)

        return stars
140258
def matches(self, a, b, **config):
        
        submitter_a = a['msg']['override']['submitter']['name']
        submitter_b = b['msg']['override']['submitter']['name']
        if submitter_a != submitter_b:
            return False
        return True
508391
def match(self, category, pattern):
        """"""

        return fnmatch.fnmatch(category, pattern, flags=self.FNMATCH_FLAGS)
405158
def assign_qualification(self, qualification_id, worker_id, score, notify=False):
        """"""
        return self._is_ok(
            self.mturk.associate_qualification_with_worker(
                QualificationTypeId=qualification_id,
                WorkerId=worker_id,
                IntegerValue=score,
                SendNotification=notify,
            )
        )
1047190
def starred_projects(self):
        
        response = self.requester.get(
            '/{endpoint}/{id}/starred', endpoint=self.endpoint,
            id=self.id
        )
        return Projects.parse(self.requester, response.json())
1342558
final boolean match(final Subject subject,
                        final SICoreConnection coreConnection) {

        boolean subjectsMatch = (_subject == null) ? (subject == null)
                        : (_subject.equals(subject));
        boolean coreConnectionsMatch = (coreConnection == null)
                                       || coreConnection.isEquivalentTo(_coreConnection);

        return subjectsMatch && coreConnectionsMatch && isValid();

    }
1031223
function match(re) {
    var m = re.exec(css);
    if (!m) return;
    var str = m[0];
    updatePosition(str);
    css = css.slice(str.length);
    return m;
  }
559184
function(actor, target, vars) {

		var a = {
			name: actor.get('definite'),
			gender: actor.gender
		};

		var t = {};
		if (target) {
			t.name = target.get('definite');
			t.gender = target.get('gender');
		} else {
			t.name = 'NULL';
			t.gender = 0;
		}

		var pronouns = {
			sub:  ['it', 'he', 'she'],
			obj:  ['it', 'him', 'her'],
			pos:  ['its', 'his', 'her'],
			ref:  ['itself', 'himself', 'herself'],
			hers: ['its', 'his', 'hers']
		};

		Object.each(pronouns, function(v,k) {
			a[k] = v[a.gender] || v[0];
			if (target) { t[k] = v[t.gender] || v[0]; }
		});

		//Replacements: what the actor sees and what the target sees.
		var actor_tags = {
			'You'      : ['You',      a.name],
			"yourself" : ["yourself", a.ref],
			"your"     : ["your",     a.pos],
			'you'      : ['you',      a.sub],
			'thee'     : ['you',      a.obj],
			"yours"    : ["yours",    a.hers],
			"Your"     : ["Your",     a.name+"'s"],
			'has'      : ['have',     'has'],
			'is'       : ['are',      'is']
		};

		var target_tags = {
			'Name'     : ['You',      t.name],
			'They'     : ['You',      t.name],
			'Name'     : ['you',      t.name],
			'they'     : ['you',      t.sub],
			'them'     : ['you',      t.obj],
			"theirs"   : ["yours",    t.hers],
			"their"    : ["your",     t.pos],
			"Their"    : ["your",     t.name+"'s"],
			"themself" : ["yourself", t.ref],
			'HAS'      : ['have',     'has'],
			'IS'       : ['are',      'is']
		};

		var actor_suffixes = {
			's'        : ['', 's'],
			'es'       : ['', 'es'],
			'ies'      : ['y', 'ies'],
			"'s"       : ["'re'", "'s"]
		};

		var target_suffixes = {
			'S'        : ['', 's'],
			'ES'       : ['', 'es'],
			'IES'      : ['y', 'ies'],
			"'S"       : ["'re", "'s"]
		};

		var str = this, str_actor = this, str_target=this, str_others=this;

		Object.each(actor_suffixes, function(replace, tag) {
			var tag = new RegExp('%'+tag+'(\\s?)', 'g');
			if (!str.match(tag)) { return; }
			str_actor  = str_actor.replace(tag, replace[0]+"$1");
			if (target) {
				str_target = str_target.replace(tag, replace[1]+"$1");
			}
			str_others = str_others.replace(tag, replace[1]+"$1");
		});

		Object.each(actor_tags, function(replace, tag) {
			var tag = new RegExp('%'+tag+'(\\s?)', 'g');
			if (!str.match(tag)) { return; }
			str_actor  = str_actor.replace(tag, replace[0]+"$1");
			if (target) {
				str_target = str_target.replace(tag, replace[1]+"$1");
			}
			str_others = str_others.replace(tag, replace[1]+"$1");
		});

		//No need to waste time processing target tags if there's no target.
		if (target) {

			Object.each(target_suffixes, function(replace, tag) {
				var tag = new RegExp('%'+tag+'(\\s?)', 'g');
				if (!str.match(tag)) { return; }
				str_actor  = str_actor.replace(tag, replace[1]+"$1");
				if (target) {
					str_target = str_target.replace(tag, replace[0]+"$1");
				}
				str_others = str_others.replace(tag, replace[1]+"$1");
			});

			Object.each(target_tags, function(replace, tag) {
				var tag = new RegExp('%'+tag+'(\\s?)', 'g');
				if (!str.match(tag)) { return; }
				str_actor  = str_actor.replace(tag, replace[1]+"$1");
				if (target) {
					str_target = str_target.replace(tag, replace[0]+"$1");
				}
				str_others = str_others.replace(tag, replace[1]+"$1");
			});

		} else {
			str_target = str_others;
		}

		strs = [str_actor, str_target, str_others];

		//Auto-capitaliztion
		strs.each(function(str, i) {
			var matches = str.match(/[\.\?!]\s+[a-z]/);
			if (!matches) { return; }
			matches.each(function(m) {
				strs[i] = str.replace(m, m.toUpperCase());
			});
		});
	
		return strs;

	}
1278171
def getFixedStars(self):
        
        IDs = const.LIST_FIXED_STARS
        return ephem.getFixedStarList(IDs, self.date)
644862
function replaceStars(comp, loose) {
  debug('replaceStars', comp, loose);
  // Looseness is ignored here.  star is always as loose as it gets!
  return comp.trim().replace(re[STAR], '');
}