create a block, a compiler for it, comile the bock and add the compiler(code)
 to the method compiler for further processing
162786
def to_mom( compiler )
      parfait_block = self.parfait_block(compiler)
      block_compiler = Risc::BlockCompiler.new( parfait_block , compiler.get_method )
      head = body.to_mom( block_compiler )
      block_compiler.add_mom(head)
      block_compiler
    end
1217840
def _compile(cls, lines):
        ''''''
        m = cls.RE_EXTEND.match(lines.current)
        if m is None:
            raise DefineBlockError('''Incorrect block definition at line {}, {}
Should be something like: #extend path/foo.html:'''.format(
                lines.pos, lines.current))
        return m.group(1)
1218735
function compiler(parsed, opts) {
  options = opts;
  const compiled = compile(parsed);

  return t.functionDeclaration(c.COMPILED, c.runtimeParams, t.blockStatement([
    t.returnStatement(ConcatStringList(compiled)),
  ]));
}
1308350
private Block allocateBlock(String src, INode[] inodes) throws IOException {
    Block b = new Block(generateBlockId(), 0, 0);
    while (isValidBlock(b)) {
      b.setBlockId(generateBlockId());
    }
    b.setGenerationStamp(getGenerationStamp());
    b = dir.addBlock(src, inodes, b);
    return b;
  }
971183
void compileBatch(String []files, boolean isMake)
    throws ClassNotFoundException
  {
    try {
      JavaCompilerUtil compiler = JavaCompilerUtil.create(getClassLoader());
      compiler.setClassDir(_classDir);
      compiler.setSourceDir(_sourceDir);
      if (_encoding != null)
        compiler.setEncoding(_encoding);
      compiler.setArgs(_args);
      compiler.setCompileParent(! isMake);
      compiler.setSourceExtension(_sourceExt);
      if (_compiler != null)
        compiler.setCompiler(_compiler);

      //LineMap lineMap = new LineMap(javaFile.getNativePath());
      // The context path is obvious from the browser url
      //lineMap.add(name.replace('.', '/') + _sourceExt, 1, 1);
          
      compiler.compileBatch(files);
    } catch (Exception e) {
      getClassLoader().addDependency(AlwaysModified.create());

      // Compile errors are wrapped in a special ClassNotFound class
      // so the server can give a nice error message
      throw new CompileClassNotFound(e);
    }
  }
690724
function compileCallback(callback, method) {
    var client = this.client;

    // Build the callback
    var builder = client.queryBuilder();
    callback.call(builder, builder);

    // Compile the callback, using the current formatter (to track all bindings).
    var compiler = client.queryCompiler(builder);
    compiler.formatter = this;

    // Return the compiled & parameterized sql.
    return compiler.toSQL(method || 'select');
  }
583629
function compile(config, cb) {
  let compiler;
  try {
    compiler = webpack(config);
  } catch (e) {
    printErrors('Failed to compile.', [e]);
    process.exit(1);
  }
  compiler.run((err, stats) => {
    cb(err, stats);
  });
}
648896
def add_definition(option, name, type, block, **opts)
      opts = {
        parent: extended_class,
        option: option,
        null:   null,
        source: name,
        type:   type,
        block:  block,
        **opts,
      }

      options = Dispatchers.call(opts)
      definition = Definition.new(options)
      definitions[definition.source] = definition
      finalize
      mixin.class_eval definition.code
    end
122882
public function compile(): void
	{
		// Get teplate contents

		$contents = $this->fileSystem->get($this->template);

		// Compile template

		foreach($this->compileOrder as $method)
		{
			$contents = $this->$method($contents);
		}

		// Store compiled template

		$this->fileSystem->put($this->cachePath . '/' . md5($this->template) . '.php', trim($contents));
	}
562066
function createCompiled(bench, decompilable, deferred, body) {
        var fn = bench.fn,
            fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '';

        templateData.uid = uid + uidCounter++;

        _.assign(templateData, {
          'setup': decompilable ? getSource(bench.setup) : interpolate('m#.setup()'),
          'fn': decompilable ? getSource(fn) : interpolate('m#.fn(' + fnArg + ')'),
          'fnArg': fnArg,
          'teardown': decompilable ? getSource(bench.teardown) : interpolate('m#.teardown()')
        });

        // Use API of chosen timer.
        if (timer.unit == 'ns') {
          _.assign(templateData, {
            'begin': interpolate('s#=n#()'),
            'end': interpolate('r#=n#(s#);r#=r#[0]+(r#[1]/1e9)')
          });
        }
        else if (timer.unit == 'us') {
          if (timer.ns.stop) {
            _.assign(templateData, {
              'begin': interpolate('s#=n#.start()'),
              'end': interpolate('r#=n#.microseconds()/1e6')
            });
          } else {
            _.assign(templateData, {
              'begin': interpolate('s#=n#()'),
              'end': interpolate('r#=(n#()-s#)/1e6')
            });
          }
        }
        else if (timer.ns.now) {
          _.assign(templateData, {
            'begin': interpolate('s#=n#.now()'),
            'end': interpolate('r#=(n#.now()-s#)/1e3')
          });
        }
        else {
          _.assign(templateData, {
            'begin': interpolate('s#=new n#().getTime()'),
            'end': interpolate('r#=(new n#().getTime()-s#)/1e3')
          });
        }
        // Define `timer` methods.
        timer.start = createFunction(
          interpolate('o#'),
          interpolate('var n#=this.ns,${begin};o#.elapsed=0;o#.timeStamp=s#')
        );

        timer.stop = createFunction(
          interpolate('o#'),
          interpolate('var n#=this.ns,s#=o#.timeStamp,${end};o#.elapsed=r#')
        );

        // Create compiled test.
        return createFunction(
          interpolate('window,t#'),
          'var global = window, clearTimeout = global.clearTimeout, setTimeout = global.setTimeout;\n' +
          interpolate(body)
        );
      }
1290139
def extend_to_block_definition(block_definition)
      RuntimeContext.new(builder, block_definition, parent_runtime_context: self).tap do |rc|
        rc.runtime_args = self.runtime_args
      end
    end
1100956
def setup(self, *args, **kwargs):
        """"""
        if self.comp is None:
            self.comp = Compiler(*args, **kwargs)
        else:
            self.comp.setup(*args, **kwargs)
765257
def _compile(self, lines):
        '''
        '''
        m = self.__class__.RE_IF.match(lines.current)
        if m is None:
            raise DefineBlockError(
                'Incorrect block definition at line {}, {}\nShould be '
                'something like: #if @foo:'.format(lines.pos, lines.current))
        args = m.group(3)
        self._evaluate = m.group(2).replace('.', '-')
        self._isbool = args is None
        if not self._isbool:
            args = args.strip('() \t')
            self._args = [arg.strip('@ \t').replace('.', '-')
                          for arg in args.split(',')]
1275183
function mixin(compiler) {
  compiler._comment = compiler.comment;
  compiler.map = new SourceMap();
  compiler.position = { line: 1, column: 1 };
  compiler.files = {};
  for (var k in exports) compiler[k] = exports[k];
}
433451
def with_file_utils(&block)
      Module.new do
        include Mustermann::FileUtils
        define_method(:f, &block)
        private(:f)
        extend self
      end
    end
516519
private function compileClosureBlock(\Twig_Compiler $compiler, $parentName, $name)
    {
        $compiler
            ->addDebugInfo($this)
            ->write('$')->raw($name)->raw(' = ')
            ->raw('$this->env->getExtension(\'Fxp\Component\Block\Twig\Extension\BlockExtension\')->createNamed(')
            ->raw('\'Fxp\Component\Block\Extension\Core\Type\ClosureType\'')
            ->raw(', ')
            ->raw('array("data" => function ($blockView) use ($context, $blocks) { $this->block_')->raw($name)->raw('(array_merge($context, array(\'closure\' => $blockView)), $blocks); }')
            ->raw(', "block_name" => ')->string($name)->raw(', "label" => "")')
            ->raw(');')->raw("\n")
            ->write('$')->raw($parentName)->raw('Children[] = array(\'parent\' => $')->raw($parentName)->raw(', \'child\' => $')->raw($name)->raw(');')->raw("\n")
        ;
    }
769680
function(){
      var args= slice.call(arguments), block= args.pop();
      return blam.compile(block, ctx).apply(tagset, args);
    }