Generates the `riot.tag2` call with the processed parts.
544730
function mktag(name, html, css, attrs, js, pcex) {
  var
    c = ', ',
    s = '}' + (pcex.length ? ', ' + q(pcex._bp[8]) : '') + ');'

  // give more consistency to the output
  if (js && js.slice(-1) !== '\n') s = '\n' + s

  return 'riot.tag2(\'' + name + "'" + c + q(html) + c + q(css) + c + q(attrs) +
         ', function(opts) {\n' + js + s
}
58537
def do_tagg(self, arglist: List[str]):
        """"""
        if len(arglist) >= 2:
            tag = arglist[0]
            content = arglist[1:]
            self.poutput('<{0}>{1}</{0}>'.format(tag, ' '.join(content)))
        else:
            self.perror("tagg requires at least 2 arguments")
517379
private void compile2() {
        try {
            switch (compilePolicy) {
            case ATTR_ONLY:
                attribute(todo);
                break;

            case CHECK_ONLY:
                flow(attribute(todo));
                break;

            case SIMPLE:
                generate(desugar(flow(attribute(todo))));
                break;

            case BY_FILE: {
                    Queue<Queue<Env<AttrContext>>> q = todo.groupByFile();
                    while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) {
                        generate(desugar(flow(attribute(q.remove()))));
                    }
                }
                break;

            case BY_TODO:
                while (!todo.isEmpty())
                    generate(desugar(flow(attribute(todo.remove()))));
                break;

            default:
                Assert.error("unknown compile policy");
            }
        } catch (Abort ex) {
            if (devVerbose)
                ex.printStackTrace(System.err);
        }

        if (verbose) {
            elapsed_msec = elapsed(start_msec);
            log.printVerbose("total", Long.toString(elapsed_msec));
        }

        reportDeferredDiagnostics();

        if (!log.hasDiagnosticListener()) {
            printCount("error", errorCount());
            printCount("warn", warningCount());
        }
    }
1233570
def tagMap(self):
        "
        if self.tagSet:
            return Set.tagMap.fget(self)
        else:
            return self.componentType.tagMapUnique
1044200
def render(self, name, value, attrs=None, renderer=None):
        
        output = [super(TagAutoComplete, self).render(name, value, attrs)]
        output.append('<script type="text/javascript">')
        output.append('(function($) {')
        output.append('  $(document).ready(function() {')
        output.append('    $("#id_%s").select2({' % name)
        output.append('       width: "element",')
        output.append('       maximumInputLength: 50,')
        output.append('       tokenSeparators: [",", " "],')
        output.append('       tags: %s' % json.dumps(self.get_tags()))
        output.append('     });')
        output.append('    });')
        output.append('}(django.jQuery));')
        output.append('</script>')
        return mark_safe('\n'.join(output))
679885
def build_tag(self, tag, text='', attrs=None):
        
        """
        return '%s%s%s' % (self.tag_start(tag, attrs), text, self.tag_end(tag))
526572
def _handle_tag_definesprite(self):
        """"""
        obj = _make_object("DefineSprite")
        obj.CharacterID = unpack_ui16(self._src)
        obj.FrameCount = unpack_ui16(self._src)
        tags = self._process_tags()
        obj.ControlTags = tags
        return obj
686581
def generate_tags_multiple_files(input_files, tag, ignore_tags, ns=None):
    
    return itertools.chain.from_iterable([generate_xmltags(
        fn, tag, ignore_tags, ns) for fn in input_files])
983838
function(context, descriptor, originalArgs) {
		var name = originalArgs[0],
			template = originalArgs[1];
		var newDescriptor = new SOD();
		template.toHTMLString(context, newDescriptor);
		tagOutput(descriptor, newDescriptor, name);
	}
810037
def ProduceEventTag(self, event_tag):
    
    self._storage_writer.AddEventTag(event_tag)

    self.number_of_produced_event_tags += 1

    self.last_activity_timestamp = time.time()
1178246
def render_tag_from_config(self):
        """"""
        phase = 'postbuild_plugins'
        plugin = 'tag_from_config'
        if not self.has_tag_suffixes_placeholder():
            return

        unique_tag = self.user_params.image_tag.value.split(':')[-1]
        tag_suffixes = {'unique': [unique_tag], 'primary': []}

        if self.user_params.build_type.value == BUILD_TYPE_ORCHESTRATOR:
            additional_tags = self.user_params.additional_tags.value or set()

            if self.user_params.scratch.value:
                pass
            elif self.user_params.isolated.value:
                tag_suffixes['primary'].extend(['{version}-{release}'])
            elif self.user_params.tags_from_yaml.value:
                tag_suffixes['primary'].extend(['{version}-{release}'])
                tag_suffixes['primary'].extend(additional_tags)
            else:
                tag_suffixes['primary'].extend(['latest', '{version}', '{version}-{release}'])
                tag_suffixes['primary'].extend(additional_tags)

        self.pt.set_plugin_arg(phase, plugin, 'tag_suffixes', tag_suffixes)
1245362
def emitCurrentToken(self):
        
        token = self.currentToken
        # Add token to the queue to be yielded
        if (token["type"] in tagTokenTypes):
            token["name"] = token["name"].translate(asciiUpper2Lower)
            if token["type"] == tokenTypes["EndTag"]:
                if token["data"]:
                    self.tokenQueue.append({"type": tokenTypes["ParseError"],
                                            "data": "attributes-in-end-tag"})
                if token["selfClosing"]:
                    self.tokenQueue.append({"type": tokenTypes["ParseError"],
                                            "data": "self-closing-flag-on-end-tag"})
        self.tokenQueue.append(token)
        self.state = self.dataState
959480
def fire_args(opts, jid, tag_data, prefix=''):
    '''
    
    '''
    try:
        tag_suffix = [jid, 'args']
    except NameError:
        pass
    else:
        tag = tagify(tag_suffix, prefix)
        try:
            _event = get_master_event(opts, opts['sock_dir'], listen=False)
            _event.fire_event(tag_data, tag=tag)
        except Exception as exc:
            # Don't let a problem here hold up the rest of the orchestration
            log.warning(
                'Failed to fire args event %s with data %s: %s',
                tag, tag_data, exc
            )
1147611
protected String generateTaglibInclusions(Collection<String> taglibs) {

        StringBuffer buffer = new StringBuffer();
        for (String taglib : taglibs) {
            String uri = m_taglibs.get(taglib);
            if (uri != null) {
                buffer.append("<%@ taglib prefix=\"" + taglib + "\" uri=\"" + uri + "\" %>");
            }
        }
        return buffer.toString();
    }
1305252
private static String tagify(Object thisObj, String tag,
                                 String attribute, Object[] args)
    {
        String str = ScriptRuntime.toString(thisObj);
        StringBuilder result = new StringBuilder();
        result.append('<');
        result.append(tag);
        if (attribute != null) {
            result.append(' ');
            result.append(attribute);
            result.append("=\"");
            result.append(ScriptRuntime.toString(args, 0));
            result.append('"');
        }
        result.append('>');
        result.append(str);
        result.append("</");
        result.append(tag);
        result.append('>');
        return result.toString();
    }
472538
def zotero_inline_tags(parser, token):
    
    
    args = token.split_contents()
    length = len(args)
    if length == 2:
        rendered_node = RenderedAllNode(args[1])
    elif length == 3 and args[2].lower() == u'all':
        rendered_node = RenderedAllNode(args[1])
    elif length == 3 and args[2].lower() == u'media':
        rendered_node = RenderedMediaNode(args[1])
    elif length == 3 and args[2].lower() == u'formset':
        rendered_node = RenderedFormsetNode(args[1])
    else:
        raise t.TemplateSyntaxError('Incorrect arguments in %s.' % args[0])
    
    return rendered_node
1161849
def _generate_consumer_tag(self):
        
        return "%s.%s%s" % (
                self.__class__.__module__,
                self.__class__.__name__,
                self._next_consumer_tag())