Returns the output of the main macro. It only actually calls the main macro the first time, and then only
returns a cached version.
@return {String}
547107
function () {
            if (this.__cachedOutput) {
                return this.__cachedOutput;
            }

            // Call the main macro to let the template engine evaluate the text
            this.$assert(156, this._out == null);
            this._out = [];
            this._callMacro(null, "main");
            var text = this._out.join("");
            if (ariaCoreAppEnvironment.applicationSettings.hasOwnProperty("imgUrlMapping") && ariaCoreAppEnvironment.applicationSettings.imgUrlMapping !== null) {
                text = this._prefixCSSImgUrl(text);
            }
            this._out = null;

            this.__cachedOutput = text;
            return text;
        }
58058
def macro_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/macros/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1033061
public function getCode() {
        $result = '';

        if ($this->options->getRenderContextDirective()) {
            $result .= $this->renderedCode->getContextDirective();
        }
        if ($this->options->getRenderDirectives()) {
            $result .= $this->renderedCode->getDirectives();
        }
        if ($this->options->getRenderGlobalCode()) {
            $result .= $this->renderedCode->getGlobalCode();
        }
        if ($this->options->getRenderMainFunction()) {
            $result .= $this->renderedCode->getMainFunction();
        }

        if ($this->options->getCompress()) {
            $result = $this->compress($result);
        }
        if ($this->options->getIncludeScriptTag()) {
            $result = $this->addScriptTag($result);
        }

        return $result;
    }
1141167
public function callMe()
    {
        $output = $this->dispatchStartEvent();

        /** @var \ReflectionClass $ref */
        $ref = $this->parameters[static::PARAM_REF];

        $doProtected = $this->pool->config->getSetting(Fallback::SETTING_ANALYSE_PROTECTED_METHODS) ||
            $this->pool->scope->isInScope();
        $doPrivate = $this->pool->config->getSetting(Fallback::SETTING_ANALYSE_PRIVATE_METHODS) ||
            $this->pool->scope->isInScope();
        $domId = $this->generateDomIdFromClassname($ref->getName(), $doProtected, $doPrivate);

        // We need to check, if we have a meta recursion here.
        if ($this->pool->recursionHandler->isInMetaHive($domId) === true) {
            // We have been here before.
            // We skip this one, and leave it to the js recursion handler!
            return $output .
                $this->pool->render->renderRecursion(
                    $this->dispatchEventWithModel(
                        'recursion',
                        $this->pool->createClass('Brainworxx\\Krexx\\Analyse\\Model')
                            ->setDomid($domId)
                            ->setNormal('Methods')
                            ->setName('Methods')
                            ->setType(static::TYPE_INTERNALS)
                    )
                );
        }

        return $output . $this->analyseMethods($ref, $domId, $doProtected, $doPrivate);
    }
1193672
public function generate_javascript_markup() {

        $svg = $this->assemble_grunticon_asset_path( $this->svg_filename );
        $png = $this->assemble_grunticon_asset_path( $this->png_filename );
        $fallback = $this->assemble_grunticon_asset_path( $this->fallback_filename );

        return 'grunticon(["' . $svg . '", "' . $png . '", "' . $fallback . '"]);';

    }
772660
function (macroName) {
            var res = this.macros[macroName];
            if (res == null) {
                res = {};
                this.macros[macroName] = res;
            }
            return res;
        }
1350986
function()
		{
			// Cache the lowercased name inside a closure.
			var nodeName = this.$.nodeName.toLowerCase();

			if ( CKEDITOR.env.ie && ! ( document.documentMode > 8 ) )
			{
				var scopeName = this.$.scopeName;
				if ( scopeName != 'HTML' )
					nodeName = scopeName.toLowerCase() + ':' + nodeName;
			}

			return (
			this.getName = function()
				{
					return nodeName;
				})();
		}
291891
StringBuilder getOutput() {
        if( output == null ) {
            CssFormatter block = copy( null );
            state.results.add( new CssPlainOutput( block.output ) );
            output = block.output;
        }
        return output;
    }
198178
def output!
      output  = "#{Time.now} | "
      output += "[#{@namespace.gsub('_', ' ')}] " unless @namespace.nil?
      output += @message
      puts output if defined?(Logg::ALWAYS_PUTS) && Logg::ALWAYS_PUTS
      return output
    end
415286
function outputModuleDefinitions (module, headWasOutput)
  {
    for (var i = 0, m = module.bodies.length; i < m; ++i) {
      var bodyPath = module.bodyPaths[i];
      if (!bodyPath)
        console.log (module.name, i, module.bodies.length, module.bodyPaths);
      // Skip bodies who's corresponding file was already output.
      if (context.outputtedFiles[bodyPath])
        continue;
      context.outputtedFiles[bodyPath] = true;

      var body = module.optimize ?
        optimize (module.bodies[i], bodyPath, module)
        : {status: STAT.INDENTED, data: module.bodies[i]};

      if (i || !headWasOutput)
        traceOutput.push (LINE, '// File: ' + bodyPath, LINE, '');
      traceOutput.push (conditionalIndent (body));
    }
  }
1340635
public String generateOutput() {
        if (blockDynTab[0].instances == 0) {
            addBlockByNo(0);
        } // add main block
        for (int blockNo = 0; blockNo < mtp.blockTabCnt; blockNo++) {
            BlockDynTabRec bdtr = blockDynTab[blockNo];
            bdtr.currBlockInstNo = bdtr.firstBlockInstNo;
        }
        StringBuilder out = new StringBuilder();
        writeBlockInstances(out, 0, -1);
        return out.toString();
    }
515231
function () {

        var $ = this.$;
        var contents = [];

        $('style').each(function () {
            var $this = $(this);
            var content = $this.text();
            contents.push(content);
        });

        if (this.options.debug) {
            console.log('');
            console.log('[DEBUG]', 'HtmlParser#getCssContents', this.file);
            console.log(contents);
        }

        return contents;
    }
843193
function() {
        var htmlState = htmlMode.startState();
        var rubyState = rubyMode.startState();
        return {
          htmlState: htmlState,
          rubyState: rubyState,
          indented: 0,
          previousToken: { style: null, indented: 0},
          tokenize: html
        };
      }
682484
function () {
            if (this.$subBinding) {
                this.$subBinding.invalidateValueCache();
                return this.$subBinding.getValue();
            } else {

                if (this.$cachedValue !== undefined && !this.$jsonObject) {
                    return this.$cachedValue;
                }

                this.$originalValue = undefined;
                if (this.$.fnc && !this.$jsonObject) {
                    this.$originalValue = this.$.fnc.apply(this.$.scope, this._getFncParameters());
                } else if (this.$.path.length === 1) {
                    this.$originalValue = this.$.scope.get(this.$.key.name);
                } else if (this.$jsonObject && !_.isString(this.$jsonObject)) {
                    this.$originalValue = this.$.scope.get(this.$jsonObject, this.$.path.slice(1));
                } else {
                    this.$originalValue = this.$.scope.get(this.$.path);
                }
                this.$cachedValue = this.transform.call(this.transformScope, this.$originalValue);
                return this.$cachedValue;
            }

        }
583985
function () {
        // Grab the first callback in the queue
        var c  = this.q[0],
            fn;

        // If there is no callback in the queue or the Chain is currently
        // in an execution mode, return
        if (!c) {
            this.fireEvent('end');
            return this;
        } else if (this.id) {
            return this;
        }

        fn = c.method || c;

        if (typeof fn === 'function') {
            var o    = c.scope || {},
                args = c.argument || [],
                ms   = c.timeout || 0,
                me   = this;
                
            if (!(args instanceof Array)) {
                args = [args];
            }

            // Execute immediately if the callback timeout is negative.
            if (ms < 0) {
                this.id = ms;
                if (c.until) {
                    for (;!c.until();) {
                        // Execute the callback from scope, with argument
                        fn.apply(o,args);
                    }
                } else if (c.iterations) {
                    for (;c.iterations-- > 0;) {
                        fn.apply(o,args);
                    }
                } else {
                    fn.apply(o,args);
                }
                this.q.shift();
                this.id = 0;
                return this.run();
            } else {
                // If the until condition is set, check if we're done
                if (c.until) {
                    if (c.until()) {
                        // Shift this callback from the queue and execute the next
                        // callback
                        this.q.shift();
                        return this.run();
                    }
                // Otherwise if either iterations is not set or we're
                // executing the last iteration, shift callback from the queue
                } else if (!c.iterations || !--c.iterations) {
                    this.q.shift();
                }

                // Otherwise set to execute after the configured timeout
                this.id = setTimeout(function () {
                    // Execute the callback from scope, with argument
                    fn.apply(o,args);
                    // Check if the Chain was not paused from inside the callback
                    if (me.id) {
                        // Indicate ready to run state
                        me.id = 0;
                        // Start the fun all over again
                        me.run();
                    }
                },ms);
            }
        }

        return this;
    }
719948
function() {
        if (process.platform !== 'darwin') {
            return;
        }

        // top is running in logging mode, spewing process info to stdout every second.
        this._topConsole = child_process.spawn('/usr/bin/top', ['-l', '0', '-stats', 'pid,cpu,mem,command']);
        this._topConsole.stdout.on('data', _.bind(function(stdout) {
            var id = $$persistence.processId();
            if (!id) {
                return;
            }

            // Find the line with the process id that matches what we're watching.
            stdout = stdout.toString();
            var lines = stdout.split('\n');
            var line = lines.filter(function(line) {
                return line.indexOf(id) === 0;
            })[0];
            if (!line) {
                return;
            }
            var parts = line.split(/\s+/g);

            // Add to the CPU history.
            var cpu = parseFloat(parts[1]);
            this._cpuFrame(cpu);

            // Add to the memory history.
            var memory = parts[2];
            var unit = 1;
            if (memory.indexOf('K') !== -1) {
                unit = 1024;
            } else if (memory.indexOf('M') !== -1) {
                unit = 1024 * 1024;
            } else if (memory.indexOf('G') !== -1) {
                unit = 1024 * 1024 * 1024;
            }
            memory = memory.replace(/[\D]/g, '');
            memory = parseInt(memory) * unit;
            this._memoryFrame(memory);

        }, this));
    }
594099
function() {
            var d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
            var m0 = this.m[3] * d;
            var m1 = -this.m[1] * d;
            var m2 = -this.m[2] * d;
            var m3 = this.m[0] * d;
            var m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
            var m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
            this.m[0] = m0;
            this.m[1] = m1;
            this.m[2] = m2;
            this.m[3] = m3;
            this.m[4] = m4;
            this.m[5] = m5;
            return this;
        }