docs: def do_classdesc(self, parent=None, ident=0):
          """
          Handles a TC_CLASSDESC opcode
  
          :param parent:
          :param ident: Log indentation level
          :return: A JavaClass object
          """
          # TC_CLASSDESC className serialVersionUID newHandle classDescInfo
          # classDescInfo:
          #   classDescFlags fields classAnnotation superClassDesc
          # classDescFlags:
          #   (byte)                 // Defined in Terminal Symbols and Constants
          # fields:
          #   (short)<count>  fieldDesc[count]
  
          # fieldDesc:
          #   primitiveDesc
          #   objectDesc
          # primitiveDesc:
          #   prim_typecode fieldName
          # objectDesc:
          #   obj_typecode fieldName className1
          clazz = JavaClass()
          log_debug("[classdesc]", ident)
          class_name = self._readString()
          clazz.name = class_name
          log_debug("Class name: %s" % class_name, ident)
  
          # serialVersionUID is a Java (signed) long => 8 bytes
          serialVersionUID, classDescFlags = self._readStruct(">qB")
          clazz.serialVersionUID = serialVersionUID
          clazz.flags = classDescFlags
  
          self._add_reference(clazz, ident)
  
          log_debug(
              "Serial: 0x{0:X} / {0:d} - classDescFlags: 0x{1:X} {2}".format(
                  serialVersionUID, classDescFlags, OpCodeDebug.flags(classDescFlags)
              ),
              ident,
          )
          (length,) = self._readStruct(">H")
          log_debug("Fields num: 0x{0:X}".format(length), ident)
  
          clazz.fields_names = []
          clazz.fields_types = []
          for fieldId in range(length):
              (typecode,) = self._readStruct(">B")
              field_name = self._readString()
              field_type = self._convert_char_to_type(typecode)
  
              log_debug("> Reading field {0}".format(field_name), ident)
  
              if field_type == self.TYPE_ARRAY:
                  _, field_type = self._read_and_exec_opcode(
                      ident=ident + 1, expect=(self.TC_STRING, self.TC_REFERENCE)
                  )
  
                  if type(field_type) is not JavaString:
                      raise AssertionError(
                          "Field type must be a JavaString, "
                          "not {0}".format(type(field_type))
                      )
  
              elif field_type == self.TYPE_OBJECT:
                  _, field_type = self._read_and_exec_opcode(
                      ident=ident + 1, expect=(self.TC_STRING, self.TC_REFERENCE)
                  )
  
                  if type(field_type) is JavaClass:
                      # FIXME: ugly trick
                      field_type = JavaString(field_type.name)
  
                  if type(field_type) is not JavaString:
                      raise AssertionError(
                          "Field type must be a JavaString, "
                          "not {0}".format(type(field_type))
                      )
  
              log_debug(
                  "< FieldName: 0x{0:X} Name:{1} Type:{2} ID:{3}".format(
                      typecode, field_name, field_type, fieldId
                  ),
                  ident,
              )
              assert field_name is not None
              assert field_type is not None
  
              clazz.fields_names.append(field_name)
              clazz.fields_types.append(field_type)
  
          if parent:
              parent.__fields = clazz.fields_names
              parent.__types = clazz.fields_types
  
          # classAnnotation
          (opid,) = self._readStruct(">B")
          log_debug(
              "OpCode: 0x{0:X} -- {1} (classAnnotation)".format(
                  opid, OpCodeDebug.op_id(opid)
              ),
              ident,
          )
          if opid != self.TC_ENDBLOCKDATA:
              raise NotImplementedError("classAnnotation isn't implemented yet")
  
          # superClassDesc
          log_debug("Reading Super Class of {0}".format(clazz.name), ident)
          _, superclassdesc = self._read_and_exec_opcode(
              ident=ident + 1, expect=(self.TC_CLASSDESC, self.TC_NULL, self.TC_REFERENCE)
          )
          log_debug(
              "Super Class for {0}: {1}".format(clazz.name, str(superclassdesc)), ident
          )
          clazz.superclass = superclassdesc
          return clazz