public static Stella_Class helpDefineClassFromParseTree(Cons parsetree, String stringifiedsource) {
    { Cons treedefinition = parsetree.rest;
      Cons thesupers = ((Cons)(treedefinition.rest.value));
      PropertyList theoptions = PropertyList.newPropertyList();
      Surrogate classtype = Stella_Object.typify(treedefinition.value);
      List directsupers = List.newList();
      List slots = List.newList();
      KeywordKeyValueList classoptions = KeywordKeyValueList.newKeywordKeyValueList();
      Keyword key = null;
      List parameters = null;
      Cons slottree = null;

      theoptions.thePlist = treedefinition.rest.rest;
      { Stella_Object s = null;
        Cons iter000 = thesupers;
        Cons collect000 = null;

        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
          s = iter000.value;
          if (collect000 == null) {
            {
              collect000 = Cons.cons(Stella_Object.typify(s), Stella.NIL);
              if (directsupers.theConsList == Stella.NIL) {
                directsupers.theConsList = collect000;
              }
              else {
                Cons.addConsToEndOfConsList(directsupers.theConsList, collect000);
              }
            }
          }
          else {
            {
              collect000.rest = Cons.cons(Stella_Object.typify(s), Stella.NIL);
              collect000 = collect000.rest;
            }
          }
        }
      }
      { Stella_Object thekey = null;
        Stella_Object thevalue = null;
        Cons iter001 = theoptions.thePlist;

        for (;!(iter001 == Stella.NIL); iter001 = iter001.rest.rest) {
          thekey = iter001.value;
          thevalue = iter001.rest.value;
          key = ((Keyword)(thekey.permanentify()));
          if ((key == Stella.KWD_PUBLIC_SLOTS) ||
              (key == Stella.KWD_SLOTS)) {
            { Slot localslot = null;

              { Stella_Object slotdef = null;
                Cons iter002 = ((Cons)(thevalue));
                Cons collect001 = null;

                loop002 : for (;!(iter002 == Stella.NIL); iter002 = iter002.rest) {
                  slotdef = iter002.value;
                  if (!Stella_Object.consP(slotdef)) {
                    { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

                      try {
                        Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                        Stella.signalTranslationNote();
                        if (!(Stella.suppressWarningsP())) {
                          Stella.printErrorContext(">> NOTE: ", Stella.STANDARD_OUTPUT);
                          {
                            System.out.println();
                            System.out.println(" Illegal slot definition:");
                            System.out.println("   `" + Stella_Object.deUglifyParseTree(slotdef) + "'");
                            System.out.println(".");
                          }
;
                        }

                      } finally {
                        Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                      }
                    }
                    continue loop002;
                  }
                  localslot = Cons.defineStorageSlotFromParseTree(((Cons)(slotdef)), classtype);
                  if (key == Stella.KWD_PUBLIC_SLOTS) {
                    localslot.slotPublicP = true;
                  }
                  if (collect001 == null) {
                    {
                      collect001 = Cons.cons(localslot, Stella.NIL);
                      if (slots.theConsList == Stella.NIL) {
                        slots.theConsList = collect001;
                      }
                      else {
                        Cons.addConsToEndOfConsList(slots.theConsList, collect001);
                      }
                    }
                  }
                  else {
                    {
                      collect001.rest = Cons.cons(localslot, Stella.NIL);
                      collect001 = collect001.rest;
                    }
                  }
                }
              }
            }
          }
          else if ((key == Stella.KWD_PUBLIC_METHODS) ||
              (key == Stella.KWD_METHODS)) {
            { Slot localslot = null;

              { Cons methoddef = null;
                Cons iter003 = ((Cons)(thevalue));
                Cons collect002 = null;

                loop003 : for (;!(iter003 == Stella.NIL); iter003 = iter003.rest) {
                  methoddef = ((Cons)(iter003.value));
                  if (!Stella_Object.consP(methoddef)) {
                    { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

                      try {
                        Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                        Stella.signalTranslationNote();
                        if (!(Stella.suppressWarningsP())) {
                          Stella.printErrorContext(">> NOTE: ", Stella.STANDARD_OUTPUT);
                          {
                            System.out.println();
                            System.out.println(" Illegal inline method definition:");
                            System.out.println("   `" + Stella_Object.deUglifyParseTree(methoddef) + "'");
                            System.out.println(".");
                          }
;
                        }

                      } finally {
                        Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                      }
                    }
                    continue loop003;
                  }
                  localslot = Symbol.defineInlineMethod(((Symbol)(methoddef.value)), methoddef.rest);
                  if (key == Stella.KWD_PUBLIC_METHODS) {
                    localslot.slotPublicP = true;
                  }
                  if (!(localslot.slotOwner == classtype)) {
                    { Object old$PrintreadablyP$002 = Stella.$PRINTREADABLYp$.get();

                      try {
                        Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                        Stella.signalTranslationError();
                        if (!(Stella.suppressWarningsP())) {
                          Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                          {
                            Stella.STANDARD_ERROR.nativeStream.println();
                            Stella.STANDARD_ERROR.nativeStream.println(" Defining a method for the class `" + localslot.slotOwner + "' inside of the class `" + Stella_Object.deUglifyParseTree(classtype) + "'.");
                          }
;
                        }

                      } finally {
                        Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                      }
                    }
                  }
                  if (collect002 == null) {
                    {
                      collect002 = Cons.cons(localslot, Stella.NIL);
                      if (slots.theConsList == Stella.NIL) {
                        slots.theConsList = collect002;
                      }
                      else {
                        Cons.addConsToEndOfConsList(slots.theConsList, collect002);
                      }
                    }
                  }
                  else {
                    {
                      collect002.rest = Cons.cons(localslot, Stella.NIL);
                      collect002 = collect002.rest;
                    }
                  }
                }
              }
            }
          }
          else if (key == Stella.KWD_PARAMETERS) {
            parameters = List.newList();
            { Stella_Object slotdef = null;
              Cons iter004 = ((Cons)(thevalue));
              Cons collect003 = null;

              for (;!(iter004 == Stella.NIL); iter004 = iter004.rest) {
                slotdef = iter004.value;
                if (collect003 == null) {
                  {
                    collect003 = Cons.cons(Cons.defineStorageSlotFromParseTree(((Cons)(slotdef)), classtype), Stella.NIL);
                    if (parameters.theConsList == Stella.NIL) {
                      parameters.theConsList = collect003;
                    }
                    else {
                      Cons.addConsToEndOfConsList(parameters.theConsList, collect003);
                    }
                  }
                }
                else {
                  {
                    collect003.rest = Cons.cons(Cons.defineStorageSlotFromParseTree(((Cons)(slotdef)), classtype), Stella.NIL);
                    collect003 = collect003.rest;
                  }
                }
              }
            }
            classoptions.insertAt(key, parameters);
          }
          else if (key == Stella.KWD_KEY) {
            if (!Stella_Object.consP(thevalue)) {
              thevalue = Cons.cons(thekey, Stella.NIL);
            }
            Cons.inPlaceObjectsToSymbols(((Cons)(thevalue)));
            classoptions.insertAt(key, ((Cons)(thevalue)));
          }
          else if (key == Stella.KWD_SYNONYMS) {
            if (!Stella_Object.consP(thevalue)) {
              thevalue = Cons.cons(thekey, Stella.NIL);
            }
            Cons.inPlaceObjectsToTypes(((Cons)(thevalue)));
            classoptions.insertAt(key, ((Cons)(thevalue)));
          }
          else if ((key == Stella.KWD_DOCUMENTATION) ||
              ((key == Stella.KWD_CL_NATIVE_TYPE) ||
               ((key == Stella.KWD_CPP_NATIVE_TYPE) ||
                ((key == Stella.KWD_JAVA_NATIVE_TYPE) ||
                 (key == Stella.KWD_IDL_NATIVE_TYPE))))) {
            classoptions.insertAt(key, thevalue);
          }
          else if ((key == Stella.KWD_ABSTRACTp) ||
              ((key == Stella.KWD_ACTIVEp) ||
               ((key == Stella.KWD_PUBLICp) ||
                ((key == Stella.KWD_CL_STRUCTp) ||
                 (key == Stella.KWD_MIXINp))))) {
            classoptions.insertAt(key, Stella_Object.coerceToBoolean(thevalue));
          }
          else if (key == Stella.KWD_RECYCLE_METHOD) {
            thevalue = thevalue.permanentify();
            classoptions.insertAt(key, thevalue);
            if (Stella.getQuotedTree("((:SWEEP-LIST :FREE-AND-SWEEP-LIST) \"/STELLA\")", "/STELLA").memberP(thevalue)) {
              slottree = Cons.list$(Cons.cons(Stella.SYM_STELLA_NEXT_SWEEP_LIST_OBJECT, Cons.cons(Stella.KWD_TYPE, Cons.cons(treedefinition.value, Cons.cons(Stella.NIL, Stella.NIL)))));
              slots.push(Cons.defineStorageSlotFromParseTree(slottree, classtype));
            }
          }
          else if ((key == Stella.KWD_EXTENSION) ||
              ((key == Stella.KWD_CREATOR) ||
               ((key == Stella.KWD_DESTRUCTOR) ||
                ((key == Stella.KWD_INITIALIZER) ||
                 ((key == Stella.KWD_TERMINATOR) ||
                  (key == Stella.KWD_EQUALITY_TEST)))))) {
            classoptions.insertAt(key, thevalue.permanentify());
          }
          else if ((key == Stella.KWD_INITIAL_VALUE) ||
              (key == Stella.KWD_PRINT_FORM)) {
            classoptions.insertAt(key, Stella_Object.permanentifyForm(thevalue));
          }
          else if (key == Stella.KWD_PROPERTIES) {
            classoptions.insertAt(key, Stella_Object.collectFeatureList(thevalue));
          }
          else if (key == Stella.KWD_META_ATTRIBUTES) {
            classoptions.insertAt(key, Stella_Object.collectKeyValueList(thevalue));
          }
          else if (key == Stella.KWD_CHILDREN) {
            if (Stella_Object.safePrimaryType(thevalue) == Stella.SGT_STELLA_CONS) {
              { Cons thevalue000 = ((Cons)(thevalue));

                { List children = List.newList();

                  { Stella_Object child = null;
                    Cons iter005 = thevalue000;
                    Cons collect004 = null;

                    for (;!(iter005 == Stella.NIL); iter005 = iter005.rest) {
                      child = iter005.value;
                      if (Stella_Object.symbolP(child)) {
                        if (collect004 == null) {
                          {
                            collect004 = Cons.cons(Stella_Object.typify(child), Stella.NIL);
                            if (children.theConsList == Stella.NIL) {
                              children.theConsList = collect004;
                            }
                            else {
                              Cons.addConsToEndOfConsList(children.theConsList, collect004);
                            }
                          }
                        }
                        else {
                          {
                            collect004.rest = Cons.cons(Stella_Object.typify(child), Stella.NIL);
                            collect004 = collect004.rest;
                          }
                        }
                      }
                    }
                  }
                  classoptions.insertAt(key, children);
                }
              }
            }
            else {
              { Object old$PrintreadablyP$003 = Stella.$PRINTREADABLYp$.get();

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  Stella.signalTranslationError();
                  if (!(Stella.suppressWarningsP())) {
                    Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                    {
                      Stella.STANDARD_ERROR.nativeStream.println();
                      Stella.STANDARD_ERROR.nativeStream.println(" Illegal :children specification: `" + Stella_Object.deUglifyParseTree(thevalue) + "'.");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                }
              }
            }
          }
          else {
            classoptions.insertAt(key, thevalue);
          }
        }
      }
      theoptions.thePlist = null;
      { Stella_Class renamed_Class = Surrogate.defineStellaClass(classtype, directsupers, slots, ((KeywordKeyValueList)(classoptions.reverse())));

        if (renamed_Class != null) {
          renamed_Class.classStringifiedSource = stringifiedsource;
        }
        return (renamed_Class);
      }
    }
  }