/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * String constants to go along with enumerated values.  (Pity we don't
 * have enumerated constant reflection in C.)  These are only needed for
 * making the output human-readable.
 */
#include "jdwp/jdwp_constants.h"

#include <iostream>

namespace art {

namespace JDWP {

const char* ErrorStr(JdwpError error) {
  switch (error) {
  case ERR_NONE:
    return "NONE";
  case ERR_INVALID_THREAD:
    return "INVALID_THREAD";
  case ERR_INVALID_THREAD_GROUP:
    return "INVALID_THREAD_GROUP";
  case ERR_INVALID_PRIORITY:
    return "INVALID_PRIORITY";
  case ERR_THREAD_NOT_SUSPENDED:
    return "THREAD_NOT_SUSPENDED";
  case ERR_THREAD_SUSPENDED:
    return "THREAD_SUSPENDED";
  case ERR_INVALID_OBJECT:
    return "INVALID_OBJEC";
  case ERR_INVALID_CLASS:
    return "INVALID_CLASS";
  case ERR_CLASS_NOT_PREPARED:
    return "CLASS_NOT_PREPARED";
  case ERR_INVALID_METHODID:
    return "INVALID_METHODID";
  case ERR_INVALID_LOCATION:
    return "INVALID_LOCATION";
  case ERR_INVALID_FIELDID:
    return "INVALID_FIELDID";
  case ERR_INVALID_FRAMEID:
    return "INVALID_FRAMEID";
  case ERR_NO_MORE_FRAMES:
    return "NO_MORE_FRAMES";
  case ERR_OPAQUE_FRAME:
    return "OPAQUE_FRAME";
  case ERR_NOT_CURRENT_FRAME:
    return "NOT_CURRENT_FRAME";
  case ERR_TYPE_MISMATCH:
    return "TYPE_MISMATCH";
  case ERR_INVALID_SLOT:
    return "INVALID_SLOT";
  case ERR_DUPLICATE:
    return "DUPLICATE";
  case ERR_NOT_FOUND:
    return "NOT_FOUND";
  case ERR_INVALID_MONITOR:
    return "INVALID_MONITOR";
  case ERR_NOT_MONITOR_OWNER:
    return "NOT_MONITOR_OWNER";
  case ERR_INTERRUPT:
    return "INTERRUPT";
  case ERR_INVALID_CLASS_FORMAT:
    return "INVALID_CLASS_FORMAT";
  case ERR_CIRCULAR_CLASS_DEFINITION:
    return "CIRCULAR_CLASS_DEFINITION";
  case ERR_FAILS_VERIFICATION:
    return "FAILS_VERIFICATION";
  case ERR_ADD_METHOD_NOT_IMPLEMENTED:
    return "ADD_METHOD_NOT_IMPLEMENTED";
  case ERR_SCHEMA_CHANGE_NOT_IMPLEMENTED:
    return "SCHEMA_CHANGE_NOT_IMPLEMENTED";
  case ERR_INVALID_TYPESTATE:
    return "INVALID_TYPESTATE";
  case ERR_HIERARCHY_CHANGE_NOT_IMPLEMENTED:
    return "HIERARCHY_CHANGE_NOT_IMPLEMENTED";
  case ERR_DELETE_METHOD_NOT_IMPLEMENTED:
    return "DELETE_METHOD_NOT_IMPLEMENTED";
  case ERR_UNSUPPORTED_VERSION:
    return "UNSUPPORTED_VERSION";
  case ERR_NAMES_DONT_MATCH:
    return "NAMES_DONT_MATCH";
  case ERR_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED:
    return "CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED";
  case ERR_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED:
    return "METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED";
  case ERR_NOT_IMPLEMENTED:
    return "NOT_IMPLEMENTED";
  case ERR_NULL_POINTER:
    return "NULL_POINTER";
  case ERR_ABSENT_INFORMATION:
    return "ABSENT_INFORMATION";
  case ERR_INVALID_EVENT_TYPE:
    return "INVALID_EVENT_TYPE";
  case ERR_ILLEGAL_ARGUMENT:
    return "ILLEGAL_ARGUMENT";
  case ERR_OUT_OF_MEMORY:
    return "OUT_OF_MEMORY";
  case ERR_ACCESS_DENIED:
    return "ACCESS_DENIED";
  case ERR_VM_DEAD:
    return "VM_DEAD";
  case ERR_INTERNAL:
    return "INTERNAL";
  case ERR_UNATTACHED_THREAD:
    return "UNATTACHED_THREAD";
  case ERR_INVALID_TAG:
    return "INVALID_TAG";
  case ERR_ALREADY_INVOKING:
    return "ALREADY_INVOKING";
  case ERR_INVALID_INDEX:
    return "INVALID_INDEX";
  case ERR_INVALID_LENGTH:
    return "INVALID_LENGTH";
  case ERR_INVALID_STRING:
    return "INVALID_STRING";
  case ERR_INVALID_CLASS_LOADER:
    return "INVALID_CLASS_LOADER";
  case ERR_INVALID_ARRAY:
    return "INVALID_ARRAY";
  case ERR_TRANSPORT_LOAD:
    return "TRANSPORT_LOAD";
  case ERR_TRANSPORT_INIT:
    return "TRANSPORT_INIT";
  case ERR_NATIVE_METHOD:
    return "NATIVE_METHOD";
  case ERR_INVALID_COUNT:
    return "INVALID_COUNT";
  default:
    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpError& value) {
  os << ErrorStr(value);
  return os;
}

const char* EventKindStr(JdwpEventKind kind) {
  switch (kind) {
  case EK_SINGLE_STEP:        return "SINGLE_STEP";
  case EK_BREAKPOINT:         return "BREAKPOINT";
  case EK_FRAME_POP:          return "FRAME_POP";
  case EK_EXCEPTION:          return "EXCEPTION";
  case EK_USER_DEFINED:       return "USER_DEFINED";
  case EK_THREAD_START:       return "THREAD_START";
  /*case EK_THREAD_END:         return "THREAD_END";*/
  case EK_CLASS_PREPARE:      return "CLASS_PREPARE";
  case EK_CLASS_UNLOAD:       return "CLASS_UNLOAD";
  case EK_CLASS_LOAD:         return "CLASS_LOAD";
  case EK_FIELD_ACCESS:       return "FIELD_ACCESS";
  case EK_FIELD_MODIFICATION: return "FIELD_MODIFICATION";
  case EK_EXCEPTION_CATCH:    return "EXCEPTION_CATCH";
  case EK_METHOD_ENTRY:       return "METHOD_ENTRY";
  case EK_METHOD_EXIT:        return "METHOD_EXIT";
  case EK_VM_INIT:            return "VM_INIT";
  case EK_VM_DEATH:           return "VM_DEATH";
  case EK_VM_DISCONNECTED:    return "VM_DISCONNECTED";
  /*case EK_VM_START:           return "VM_START";*/
  case EK_THREAD_DEATH:       return "THREAD_DEATH";
  default:                    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpEventKind& value) {
  os << EventKindStr(value);
  return os;
}

const char* ModKindStr(JdwpModKind kind) {
  switch (kind) {
  case MK_COUNT:              return "COUNT";
  case MK_CONDITIONAL:        return "CONDITIONAL";
  case MK_THREAD_ONLY:        return "THREAD_ONLY";
  case MK_CLASS_ONLY:         return "CLASS_ONLY";
  case MK_CLASS_MATCH:        return "CLASS_MATCH";
  case MK_CLASS_EXCLUDE:      return "CLASS_EXCLUDE";
  case MK_LOCATION_ONLY:      return "LOCATION_ONLY";
  case MK_EXCEPTION_ONLY:     return "EXCEPTION_ONLY";
  case MK_FIELD_ONLY:         return "FIELD_ONLY";
  case MK_STEP:               return "STEP";
  case MK_INSTANCE_ONLY:      return "INSTANCE_ONLY";
  default:                    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpModKind& value) {
  os << ModKindStr(value);
  return os;
}

const char* StepDepthStr(JdwpStepDepth depth) {
  switch (depth) {
  case SD_INTO:               return "INTO";
  case SD_OVER:               return "OVER";
  case SD_OUT:                return "OUT";
  default:                    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpStepDepth& value) {
  os << StepDepthStr(value);
  return os;
}

const char* StepSizeStr(JdwpStepSize size) {
  switch (size) {
  case SS_MIN:                return "MIN";
  case SS_LINE:               return "LINE";
  default:                    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpStepSize& value) {
  os << StepSizeStr(value);
  return os;
}

const char* SuspendPolicyStr(JdwpSuspendPolicy policy) {
  switch (policy) {
  case SP_NONE:               return "NONE";
  case SP_EVENT_THREAD:       return "EVENT_THREAD";
  case SP_ALL:                return "ALL";
  default:                    return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpSuspendPolicy& value) {
  os << SuspendPolicyStr(value);
  return os;
}

const char* SuspendStatusStr(JdwpSuspendStatus status) {
  switch (status) {
  case SUSPEND_STATUS_NOT_SUSPENDED: return "Not SUSPENDED";
  case SUSPEND_STATUS_SUSPENDED:     return "SUSPENDED";
  default:                           return "?UNKNOWN?";
  }
}
std::ostream& operator<<(std::ostream& os, const JdwpSuspendStatus& value) {
  os << SuspendStatusStr(value);
  return os;
}

const char* ThreadStatusStr(JdwpThreadStatus status) {
  switch (status) {
  case TS_ZOMBIE:             return "ZOMBIE";
  case TS_RUNNING:            return "RUNNING";
  case TS_SLEEPING:           return "SLEEPING";
  case TS_MONITOR:            return "MONITOR";
  case TS_WAIT:               return "WAIT";
  default:                    return "?UNKNOWN?";
  }
};
std::ostream& operator<<(std::ostream& os, const JdwpThreadStatus& value) {
  os << ThreadStatusStr(value);
  return os;
}

}  // namespace JDWP

}  // namespace art