コード例 #1
0
  /**
   * Generate instructions for field initializers or static initialization statements.
   *
   * @param node - the AST at the root of the statement.
   * @param isStatic - true if the code should be generated in a static context.
   */
  private void generateInstructions(IASNode node, final boolean isStatic) {
    //  Do we need to create new information for the class'
    //  static initialization method?  Note that this may
    //  be undone if the codgen fails or doesn't produce
    //  any instructions.
    final boolean createNewCinit = isStatic && this.cinfo.cInit == null;

    if (createNewCinit) {
      //  Speculatively initialize the class' cinit
      //  (static class initializer routine)'s data
      //  structures; the code generator may need to
      //  store information in them.
      this.cinfo.cInit = new MethodInfo();
      MethodBodyInfo cinit_info = new MethodBodyInfo();
      cinit_info.setMethodInfo(this.cinfo.cInit);

      this.classStaticScope.setMethodInfo(this.cinfo.cInit);
      this.classStaticScope.methodVisitor = emitter.visitMethod(this.cinfo.cInit);
      this.classStaticScope.methodVisitor.visit();
      this.classStaticScope.methodBodyVisitor =
          this.classStaticScope.methodVisitor.visitBody(cinit_info);
      this.classStaticScope.methodBodyVisitor.visit();
    }

    InstructionList cgResult = null;

    LexicalScope ls = isStatic ? this.classStaticScope : this.classScope;

    ls.resetDebugInfo();
    cgResult = ls.getGenerator().generateInstructions(node, CmcEmitter.__statement_NT, ls);

    //  If nothing came back, revert any change made to the cinit information.
    if ((cgResult == null || cgResult.isEmpty()) && createNewCinit) {
      this.cinfo.cInit = null;
      this.classStaticScope.resetMethodInfo();
      this.classStaticScope.methodVisitor = null;
      this.classStaticScope.methodBodyVisitor = null;
    }

    //  Save the generated instructions, if present.
    if (cgResult != null) {
      if (isStatic) this.cinitInsns.addAll(cgResult);
      else this.iinitInsns.addAll(cgResult);
    }
  }
コード例 #2
0
  /** Finish the class' definition. */
  void finishClassDefinition() {
    // the generation of instructions for variable initialization is delayed
    // until now, so we can add that initialization to the front of
    // the cinit instruction list.
    if (!staticVariableInitializers.isEmpty()) {
      InstructionList exisitingCinitInsns = null;
      if (!this.cinitInsns.isEmpty()) {
        exisitingCinitInsns = new InstructionList();
        exisitingCinitInsns.addAll(this.cinitInsns);
        this.cinitInsns = new InstructionList();
      }

      for (VariableNode var : staticVariableInitializers) generateInstructions(var, true);

      if (exisitingCinitInsns != null) this.cinitInsns.addAll(exisitingCinitInsns);
    }

    // add "goto_definition_help" metadata to user defined metadata.
    ITraitVisitor tv =
        classScope.getGlobalScope().traitsVisitor.visitClassTrait(TRAIT_Class, className, 0, cinfo);
    IMetaInfo[] metaTags = getAllMetaTags(classDefinition);

    // Add "goto definition help" metadata for the constructor.
    if (this.ctorFunction != null) {
      FunctionDefinition ctorDef = this.ctorFunction.getDefinition();
      MetaTag metaTag =
          MetaTag.createGotoDefinitionHelp(
              classDefinition,
              classDefinition.getContainingFilePath(),
              Integer.toString(ctorDef.getNameStart()),
              true);
      if (metaTag != null) metaTags = MetaTag.addMetaTag(metaTags, metaTag);
    }

    this.classScope.processMetadata(tv, metaTags);
    tv.visitEnd();

    // Need to do this before generating the CTOR as the generated code may result in insns that
    // need to be added to the ctor.
    generateBindableImpl();

    generateRequiredContingentDefinitions();

    addAnyEmbeddedAsset();

    // Make any vistEnd method calls
    // that were deferred.
    // callVisitEnds must be called on the same thread
    // that started code generation.  Since we don't generate
    // classes in parallel yet, we know that we are on the thread
    // that started code generation here.
    classScope.callVisitEnds();
    classStaticScope.callVisitEnds();

    //  Create the class' constructor function.
    if (this.ctorFunction != null) {
      MethodInfo mi =
          classScope
              .getGenerator()
              .generateFunction(this.ctorFunction, classScope, this.iinitInsns);

      if (mi != null) this.iinfo.iInit = mi;
    } else if (!this.iinitInsns.isEmpty()) {
      //  Synthesize a constructor.

      this.iinfo.iInit = new MethodInfo();
      MethodBodyInfo iinit = new MethodBodyInfo();
      iinit.setMethodInfo(this.iinfo.iInit);

      IMethodVisitor mv = emitter.visitMethod(this.iinfo.iInit);
      mv.visit();
      IMethodBodyVisitor mbv = mv.visitBody(iinit);
      InstructionList ctor_insns = new InstructionList();
      ctor_insns.addInstruction(OP_getlocal0);
      ctor_insns.addInstruction(OP_pushscope);

      ctor_insns.addAll(this.iinitInsns);

      //  Call the superclass' constructor after the instance
      //  init instructions; this doesn't seem like an abstractly
      //  correct sequence, but it's what ASC does.
      ctor_insns.addInstruction(OP_getlocal0);
      ctor_insns.addInstruction(OP_constructsuper, 0);

      ctor_insns.addInstruction(OP_returnvoid);
      mbv.visit();
      mbv.visitInstructionList(ctor_insns);
      mbv.visitEnd();
      mv.visitEnd();
    }

    //  If the class has static initialization
    //  logic, emit a cinit routine.
    if (!this.cinitInsns.isEmpty()) {
      InstructionList cinit_insns = new InstructionList();
      cinit_insns.addInstruction(OP_getlocal0);
      cinit_insns.addInstruction(OP_pushscope);

      //  TODO: Examine other end-of-function processing
      //  and ensure it's completed.
      this.classStaticScope.finishClassStaticInitializer(this.cinitInsns);
      cinit_insns.addAll(this.cinitInsns);

      cinit_insns.addInstruction(OP_returnvoid);

      this.classStaticScope.methodBodyVisitor.visitInstructionList(cinit_insns);
      this.classStaticScope.methodBodyVisitor.visitEnd();
      this.classStaticScope.methodVisitor.visitEnd();
    } else {
      //  Ensure nothing got dropped.
      assert (this.classStaticScope.methodBodyVisitor == null);
    }

    itraits.visitEnd();
    ctraits.visitEnd();

    cv.visitEnd();
  }