// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "tools/fidlcat/lib/type_decoder.h"

#include <zircon/features.h>
#include <zircon/rights.h>
#include <zircon/syscalls/exception.h>
#include <zircon/syscalls/iommu.h>
#include <zircon/syscalls/object.h>
#include <zircon/syscalls/pci.h>
#include <zircon/syscalls/policy.h>
#include <zircon/syscalls/port.h>
#include <zircon/syscalls/profile.h>
#include <zircon/syscalls/system.h>
#include <zircon/types.h>

#include <cstdint>
#include <iomanip>
#include <ostream>
#include <sstream>

#include "src/lib/fidl_codec/status.h"

namespace fidlcat {

#define ExceptionChannelTypeNameCase(name) \
  case name:                               \
    printer << #name;                      \
    return

void ExceptionChannelTypeName(uint32_t type, fidl_codec::PrettyPrinter& printer) {
  switch (type) {
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_NONE);
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_DEBUGGER);
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_THREAD);
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_PROCESS);
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_JOB);
    ExceptionChannelTypeNameCase(ZX_EXCEPTION_CHANNEL_TYPE_JOB_DEBUGGER);
    default:
      printer << static_cast<uint32_t>(type);
      return;
  }
}

#define FeatureKindNameCase(name) \
  case name:                      \
    printer << #name;             \
    return

void FeatureKindName(uint32_t feature_kind, fidl_codec::PrettyPrinter& printer) {
  switch (feature_kind) {
    FeatureKindNameCase(ZX_FEATURE_KIND_CPU);
    FeatureKindNameCase(ZX_FEATURE_KIND_HW_BREAKPOINT_COUNT);
    FeatureKindNameCase(ZX_FEATURE_KIND_HW_WATCHPOINT_COUNT);
    default:
      printer << feature_kind;
      return;
  }
}

#define GuestTrapNameCase(name) \
  case name:                    \
    printer << #name;           \
    return

void GuestTrapName(zx_guest_trap_t trap, fidl_codec::PrettyPrinter& printer) {
  switch (trap) {
    GuestTrapNameCase(ZX_GUEST_TRAP_BELL);
    GuestTrapNameCase(ZX_GUEST_TRAP_MEM);
    GuestTrapNameCase(ZX_GUEST_TRAP_IO);
    default:
      printer << trap;
      return;
  }
}

#define InfoMapsTypeCase(name) \
  case name:                   \
    printer << #name;          \
    return

void InfoMapsTypeName(zx_info_maps_type_t type, fidl_codec::PrettyPrinter& printer) {
  switch (type) {
    InfoMapsTypeCase(ZX_INFO_MAPS_TYPE_NONE);
    InfoMapsTypeCase(ZX_INFO_MAPS_TYPE_ASPACE);
    InfoMapsTypeCase(ZX_INFO_MAPS_TYPE_VMAR);
    InfoMapsTypeCase(ZX_INFO_MAPS_TYPE_MAPPING);
    default:
      printer << type;
      return;
  }
}

#define InterruptFlagsCase(name) \
  case name:                     \
    printer << #name;            \
    break

#define InterruptFlagsNameFlag(name) \
  if ((flags & (name)) == (name)) {  \
    printer << " | " << #name;       \
  }

void InterruptFlagsName(uint32_t flags, fidl_codec::PrettyPrinter& printer) {
  switch (flags & ZX_INTERRUPT_MODE_MASK) {
    InterruptFlagsCase(ZX_INTERRUPT_MODE_DEFAULT);
    InterruptFlagsCase(ZX_INTERRUPT_MODE_EDGE_LOW);
    InterruptFlagsCase(ZX_INTERRUPT_MODE_EDGE_HIGH);
    InterruptFlagsCase(ZX_INTERRUPT_MODE_LEVEL_LOW);
    InterruptFlagsCase(ZX_INTERRUPT_MODE_LEVEL_HIGH);
    InterruptFlagsCase(ZX_INTERRUPT_MODE_EDGE_BOTH);
    default:
      printer << (flags & ZX_INTERRUPT_MODE_MASK);
      break;
  }
  InterruptFlagsNameFlag(ZX_INTERRUPT_REMAP_IRQ);
  InterruptFlagsNameFlag(ZX_INTERRUPT_VIRTUAL);
}

#define IommuTypeNameCase(name) \
  case name:                    \
    printer << #name;           \
    return

void IommuTypeName(uint32_t type, fidl_codec::PrettyPrinter& printer) {
  switch (type) {
    IommuTypeNameCase(ZX_IOMMU_TYPE_DUMMY);
    IommuTypeNameCase(ZX_IOMMU_TYPE_INTEL);
    default:
      printer << type;
      return;
  }
}

#define KtraceControlActionNameCase(name) \
  case name:                              \
    printer << #name;                     \
    return

void KtraceControlActionName(uint32_t action, fidl_codec::PrettyPrinter& printer) {
  constexpr uint32_t KTRACE_ACTION_START = 1;
  constexpr uint32_t KTRACE_ACTION_STOP = 2;
  constexpr uint32_t KTRACE_ACTION_REWIND = 3;
  constexpr uint32_t KTRACE_ACTION_NEW_PROBE = 4;
  switch (action) {
    KtraceControlActionNameCase(KTRACE_ACTION_START);
    KtraceControlActionNameCase(KTRACE_ACTION_STOP);
    KtraceControlActionNameCase(KTRACE_ACTION_REWIND);
    KtraceControlActionNameCase(KTRACE_ACTION_NEW_PROBE);
    default:
      printer << action;
      return;
  }
}

#define PolicyNameCase(name) \
  case name:                 \
    printer << #name;        \
    return

void PolicyActionName(uint32_t action, fidl_codec::PrettyPrinter& printer) {
  switch (action) {
    PolicyNameCase(ZX_POL_ACTION_ALLOW);
    PolicyNameCase(ZX_POL_ACTION_DENY);
    PolicyNameCase(ZX_POL_ACTION_ALLOW_EXCEPTION);
    PolicyNameCase(ZX_POL_ACTION_DENY_EXCEPTION);
    PolicyNameCase(ZX_POL_ACTION_KILL);
    default:
      printer << action;
      return;
  }
}

void PolicyConditionName(uint32_t condition, fidl_codec::PrettyPrinter& printer) {
  switch (condition) {
    PolicyNameCase(ZX_POL_BAD_HANDLE);
    PolicyNameCase(ZX_POL_WRONG_OBJECT);
    PolicyNameCase(ZX_POL_VMAR_WX);
    PolicyNameCase(ZX_POL_NEW_ANY);
    PolicyNameCase(ZX_POL_NEW_VMO);
    PolicyNameCase(ZX_POL_NEW_CHANNEL);
    PolicyNameCase(ZX_POL_NEW_EVENT);
    PolicyNameCase(ZX_POL_NEW_EVENTPAIR);
    PolicyNameCase(ZX_POL_NEW_PORT);
    PolicyNameCase(ZX_POL_NEW_SOCKET);
    PolicyNameCase(ZX_POL_NEW_FIFO);
    PolicyNameCase(ZX_POL_NEW_TIMER);
    PolicyNameCase(ZX_POL_NEW_PROCESS);
    PolicyNameCase(ZX_POL_NEW_PROFILE);
    PolicyNameCase(ZX_POL_AMBIENT_MARK_VMO_EXEC);
    default:
      printer << condition;
      return;
  }
}

void PolicyTopicName(uint32_t topic, fidl_codec::PrettyPrinter& printer) {
  switch (topic) {
    PolicyNameCase(ZX_JOB_POL_BASIC);
    PolicyNameCase(ZX_JOB_POL_TIMER_SLACK);
    default:
      printer << topic;
      return;
  }
}

#define RsrcKindNameCase(name) \
  case name:                   \
    printer << #name;          \
    return

void RsrcKindName(zx_rsrc_kind_t kind, fidl_codec::PrettyPrinter& printer) {
  switch (kind) {
    RsrcKindNameCase(ZX_RSRC_KIND_MMIO);
    RsrcKindNameCase(ZX_RSRC_KIND_IRQ);
    RsrcKindNameCase(ZX_RSRC_KIND_IOPORT);
    RsrcKindNameCase(ZX_RSRC_KIND_ROOT);
    RsrcKindNameCase(ZX_RSRC_KIND_SMC);
    RsrcKindNameCase(ZX_RSRC_KIND_SYSTEM);
    RsrcKindNameCase(ZX_RSRC_KIND_COUNT);
    default:
      printer << kind;
      return;
  }
}

#define SocketCreateOptionsNameCase(name) \
  case name:                              \
    printer << #name;                     \
    return

void SocketCreateOptionsName(uint32_t options, fidl_codec::PrettyPrinter& printer) {
  switch (options) {
    SocketCreateOptionsNameCase(ZX_SOCKET_STREAM);
    SocketCreateOptionsNameCase(ZX_SOCKET_DATAGRAM);
    default:
      printer << static_cast<uint32_t>(options);
      return;
  }
}

#define SocketReadOptionsNameCase(name) \
  case name:                            \
    printer << #name;                   \
    return

void SocketReadOptionsName(uint32_t options, fidl_codec::PrettyPrinter& printer) {
  switch (options) {
    SocketReadOptionsNameCase(ZX_SOCKET_PEEK);
    default:
      printer << static_cast<uint32_t>(options);
      return;
  }
}

#define SocketShutdownOptionsNameCase(name) \
  if ((options & (name)) == (name)) {       \
    printer << separator << #name;          \
    separator = " | ";                      \
  }

void SocketShutdownOptionsName(uint32_t options, fidl_codec::PrettyPrinter& printer) {
  if (options == 0) {
    printer << "0";
    return;
  }
  const char* separator = "";
  SocketShutdownOptionsNameCase(ZX_SOCKET_SHUTDOWN_WRITE);
  SocketShutdownOptionsNameCase(ZX_SOCKET_SHUTDOWN_READ);
}

#define SystemEventTypeNameCase(name) \
  case name:                          \
    printer << #name;                 \
    return

void SystemEventTypeName(zx_system_event_type_t type, fidl_codec::PrettyPrinter& printer) {
  switch (type) {
    SystemEventTypeNameCase(ZX_SYSTEM_EVENT_OUT_OF_MEMORY);
    default:
      printer << type;
      return;
  }
}

#define SystemPowerctlNameCase(name) \
  case name:                         \
    printer << #name;                \
    return

void SystemPowerctlName(uint32_t powerctl, fidl_codec::PrettyPrinter& printer) {
  switch (powerctl) {
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_ENABLE_ALL_CPUS);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_DISABLE_ALL_CPUS_BUT_PRIMARY);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_ACPI_TRANSITION_S_STATE);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_REBOOT);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_REBOOT_BOOTLOADER);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_REBOOT_RECOVERY);
    SystemPowerctlNameCase(ZX_SYSTEM_POWERCTL_SHUTDOWN);
    default:
      printer << powerctl;
      return;
  }
}

#define ThreadStateNameCase(name) \
  case name:                      \
    printer << #name;             \
    return

void ThreadStateName(uint32_t state, fidl_codec::PrettyPrinter& printer) {
  switch (state) {
    ThreadStateNameCase(ZX_THREAD_STATE_NEW);
    ThreadStateNameCase(ZX_THREAD_STATE_RUNNING);
    ThreadStateNameCase(ZX_THREAD_STATE_SUSPENDED);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED);
    ThreadStateNameCase(ZX_THREAD_STATE_DYING);
    ThreadStateNameCase(ZX_THREAD_STATE_DEAD);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_EXCEPTION);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_SLEEPING);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_FUTEX);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_PORT);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_CHANNEL);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_WAIT_ONE);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_WAIT_MANY);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_INTERRUPT);
    ThreadStateNameCase(ZX_THREAD_STATE_BLOCKED_PAGER);
    default:
      printer << static_cast<uint32_t>(state);
      return;
  }
}

#define ThreadStateTopicNameCase(name) \
  case name:                           \
    printer << #name;                  \
    return

void ThreadStateTopicName(zx_thread_state_topic_t topic, fidl_codec::PrettyPrinter& printer) {
  switch (topic) {
    ThreadStateTopicNameCase(ZX_THREAD_STATE_GENERAL_REGS);
    ThreadStateTopicNameCase(ZX_THREAD_STATE_FP_REGS);
    ThreadStateTopicNameCase(ZX_THREAD_STATE_VECTOR_REGS);
    ThreadStateTopicNameCase(ZX_THREAD_STATE_DEBUG_REGS);
    ThreadStateTopicNameCase(ZX_THREAD_STATE_SINGLE_STEP);
    default:
      printer << static_cast<uint32_t>(topic);
      return;
  }
}

#define TimerOptionNameCase(name) \
  case name:                      \
    printer << #name;             \
    return

void TimerOptionName(uint32_t option, fidl_codec::PrettyPrinter& printer) {
  switch (option) {
    TimerOptionNameCase(ZX_TIMER_SLACK_CENTER);
    TimerOptionNameCase(ZX_TIMER_SLACK_EARLY);
    TimerOptionNameCase(ZX_TIMER_SLACK_LATE);
    default:
      printer << option;
      return;
  }
}

#define VcpuNameCase(name) \
  case name:               \
    printer << #name;      \
    return

void VcpuName(uint32_t type, fidl_codec::PrettyPrinter& printer) {
  switch (type) {
    VcpuNameCase(ZX_VCPU_STATE);
    VcpuNameCase(ZX_VCPU_IO);
    default:
      printer << type;
      return;
  }
}

#define VmOptionAlign(name) \
  case name:                \
    printer << #name;       \
    separator = " | ";      \
    break;

#define VmOptionCase(name)           \
  if ((option & (name)) == (name)) { \
    printer << separator << #name;   \
    separator = " | ";               \
  }

void VmOptionName(zx_vm_option_t option, fidl_codec::PrettyPrinter& printer) {
  if (option == 0) {
    printer << "0";
    return;
  }
  const char* separator = "";
  switch (option & ~((1 << ZX_VM_ALIGN_BASE) - 1)) {
    VmOptionAlign(ZX_VM_ALIGN_1KB);
    VmOptionAlign(ZX_VM_ALIGN_2KB);
    VmOptionAlign(ZX_VM_ALIGN_4KB);
    VmOptionAlign(ZX_VM_ALIGN_8KB);
    VmOptionAlign(ZX_VM_ALIGN_16KB);
    VmOptionAlign(ZX_VM_ALIGN_32KB);
    VmOptionAlign(ZX_VM_ALIGN_64KB);
    VmOptionAlign(ZX_VM_ALIGN_128KB);
    VmOptionAlign(ZX_VM_ALIGN_256KB);
    VmOptionAlign(ZX_VM_ALIGN_512KB);
    VmOptionAlign(ZX_VM_ALIGN_1MB);
    VmOptionAlign(ZX_VM_ALIGN_2MB);
    VmOptionAlign(ZX_VM_ALIGN_4MB);
    VmOptionAlign(ZX_VM_ALIGN_8MB);
    VmOptionAlign(ZX_VM_ALIGN_16MB);
    VmOptionAlign(ZX_VM_ALIGN_32MB);
    VmOptionAlign(ZX_VM_ALIGN_64MB);
    VmOptionAlign(ZX_VM_ALIGN_128MB);
    VmOptionAlign(ZX_VM_ALIGN_256MB);
    VmOptionAlign(ZX_VM_ALIGN_512MB);
    VmOptionAlign(ZX_VM_ALIGN_1GB);
    VmOptionAlign(ZX_VM_ALIGN_2GB);
    VmOptionAlign(ZX_VM_ALIGN_4GB);
    default:
      if ((option >> ZX_VM_ALIGN_BASE) != 0) {
        printer << (option >> ZX_VM_ALIGN_BASE);
      }
      break;
  }
  VmOptionCase(ZX_VM_PERM_READ);
  VmOptionCase(ZX_VM_PERM_WRITE);
  VmOptionCase(ZX_VM_PERM_EXECUTE);
  VmOptionCase(ZX_VM_COMPACT);
  VmOptionCase(ZX_VM_SPECIFIC);
  VmOptionCase(ZX_VM_SPECIFIC_OVERWRITE);
  VmOptionCase(ZX_VM_CAN_MAP_SPECIFIC);
  VmOptionCase(ZX_VM_CAN_MAP_READ);
  VmOptionCase(ZX_VM_CAN_MAP_WRITE);
  VmOptionCase(ZX_VM_CAN_MAP_EXECUTE);
  VmOptionCase(ZX_VM_MAP_RANGE);
  VmOptionCase(ZX_VM_REQUIRE_NON_RESIZABLE);
  VmOptionCase(ZX_VM_ALLOW_FAULTS);
}

#define VmoCreationOptionNameCase(name) \
  if ((options & (name)) == (name)) {   \
    printer << separator << #name;      \
    separator = " | ";                  \
  }

void VmoCreationOptionName(uint32_t options, fidl_codec::PrettyPrinter& printer) {
  if (options == 0) {
    printer << "0";
    return;
  }
  const char* separator = "";
  VmoCreationOptionNameCase(ZX_VMO_RESIZABLE);
}

#define VmoOpNameCase(name) \
  case name:                \
    printer << #name;       \
    return

void VmoOpName(uint32_t op, fidl_codec::PrettyPrinter& printer) {
  switch (op) {
    VmoOpNameCase(ZX_VMO_OP_COMMIT);
    VmoOpNameCase(ZX_VMO_OP_DECOMMIT);
    VmoOpNameCase(ZX_VMO_OP_LOCK);
    VmoOpNameCase(ZX_VMO_OP_UNLOCK);
    VmoOpNameCase(ZX_VMO_OP_CACHE_SYNC);
    VmoOpNameCase(ZX_VMO_OP_CACHE_INVALIDATE);
    VmoOpNameCase(ZX_VMO_OP_CACHE_CLEAN);
    VmoOpNameCase(ZX_VMO_OP_CACHE_CLEAN_INVALIDATE);
    default:
      printer << op;
      return;
  }
}

#define VmoOptionNameCase(name)       \
  if ((options & (name)) == (name)) { \
    printer << separator << #name;    \
    separator = " | ";                \
  }

void VmoOptionName(uint32_t options, fidl_codec::PrettyPrinter& printer) {
  if (options == 0) {
    printer << "0";
    return;
  }
  const char* separator = "";
  VmoOptionNameCase(ZX_VMO_CHILD_SNAPSHOT);
  VmoOptionNameCase(ZX_VMO_CHILD_RESIZABLE);
  VmoOptionNameCase(ZX_VMO_CHILD_SLICE);
  VmoOptionNameCase(ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE);
}

#define VmoTypeNameCase(name)      \
  if ((type & (name)) == (name)) { \
    printer << " | " << #name;     \
  }

void VmoTypeName(uint32_t type, fidl_codec::PrettyPrinter& printer) {
  if ((type & 1) == ZX_INFO_VMO_TYPE_PHYSICAL) {
    printer << "ZX_INFO_VMO_TYPE_PHYSICAL";
  } else {
    printer << "ZX_INFO_VMO_TYPE_PAGED";
  }
  VmoTypeNameCase(ZX_INFO_VMO_RESIZABLE);
  VmoTypeNameCase(ZX_INFO_VMO_IS_COW_CLONE);
  VmoTypeNameCase(ZX_INFO_VMO_VIA_HANDLE);
  VmoTypeNameCase(ZX_INFO_VMO_VIA_MAPPING);
  VmoTypeNameCase(ZX_INFO_VMO_PAGER_BACKED);
  VmoTypeNameCase(ZX_INFO_VMO_CONTIGUOUS);
}

std::string_view TypeName(SyscallType type) {
  switch (type) {
    case SyscallType::kBool:
      return "bool";
    case SyscallType::kChar:
      return "char";
    case SyscallType::kInt32:
      return "int32";
    case SyscallType::kInt64:
      return "int64";
    case SyscallType::kUint8:
    case SyscallType::kUint8Hexa:
      return "uint8";
    case SyscallType::kUint16:
    case SyscallType::kUint16Hexa:
      return "uint16";
    case SyscallType::kUint32:
    case SyscallType::kUint32Hexa:
      return "uint32";
    case SyscallType::kUint64:
    case SyscallType::kUint64Hexa:
      return "uint64";
    case SyscallType::kUint128Hexa:
      return "uint128";
    case SyscallType::kBtiPerm:
      return "zx_bti_perm_t";
    case SyscallType::kCachePolicy:
      return "zx_cache_policy_t";
    case SyscallType::kClock:
      return "clock";
    case SyscallType::kDuration:
      return "duration";
    case SyscallType::kExceptionChannelType:
      return "zx_info_thread_t::wait_exception_channel_type";
    case SyscallType::kExceptionState:
      return "zx_exception_state_t";
    case SyscallType::kFeatureKind:
      return "zx_feature_kind_t";
    case SyscallType::kFutex:
      return "zx_futex_t";
    case SyscallType::kGpAddr:
      return "zx_gpaddr_t";
    case SyscallType::kGuestTrap:
      return "zx_guest_trap_t";
    case SyscallType::kHandle:
      return "handle";
    case SyscallType::kInfoMapsType:
      return "zx_info_maps_type_t";
    case SyscallType::kInterruptFlags:
      return "zx_interrupt_flags_t";
    case SyscallType::kIommuType:
      return "zx_iommu_type_t";
    case SyscallType::kKoid:
      return "zx_koid_t";
    case SyscallType::kKtraceControlAction:
      return "zx_ktrace_control_action_t";
    case SyscallType::kMonotonicTime:
      return "zx_time_t";
    case SyscallType::kObjectInfoTopic:
      return "zx_object_info_topic_t";
    case SyscallType::kObjType:
      return "zx_obj_type_t";
    case SyscallType::kPacketGuestVcpuType:
      return "zx_packet_guest_vcpu_t::type";
    case SyscallType::kPacketPageRequestCommand:
      return "zx_packet_page_request_t::command";
    case SyscallType::kPaddr:
      return "zx_paddr_t";
    case SyscallType::kPciBarType:
      return "zx_pci_bar_type_t";
    case SyscallType::kPolicyAction:
      return "zx_policy_action_t";
    case SyscallType::kPolicyCondition:
      return "zx_policy_condition_t";
    case SyscallType::kPolicyTopic:
      return "zx_policy_topic_t";
    case SyscallType::kPortPacketType:
      return "zx_port_packet_t::type";
    case SyscallType::kProfileInfoFlags:
      return "zx_profile_info_flags_t";
    case SyscallType::kPropType:
      return "zx_prop_type_t";
    case SyscallType::kRights:
      return "zx_rights_t";
    case SyscallType::kRsrcKind:
      return "zx_rsrc_kind_t";
    case SyscallType::kSignals:
      return "signals";
    case SyscallType::kSize:
      return "size_t";
    case SyscallType::kSocketCreateOptions:
      return "zx_socket_create_options_t";
    case SyscallType::kSocketReadOptions:
      return "zx_socket_read_options_t";
    case SyscallType::kSocketShutdownOptions:
      return "zx_socket_shutdown_options_t";
    case SyscallType::kStatus:
      return "status_t";
    case SyscallType::kSystemEventType:
      return "zx_system_event_type_t";
    case SyscallType::kSystemPowerctl:
      return "zx_system_powerctl_t";
    case SyscallType::kThreadState:
      return "zx_info_thread_t::state";
    case SyscallType::kThreadStateTopic:
      return "zx_thread_state_topic_t";
    case SyscallType::kTime:
      return "time";
    case SyscallType::kTimerOption:
      return "zx_timer_option_t";
    case SyscallType::kUintptr:
      return "uintptr_t";
    case SyscallType::kVaddr:
      return "zx_vaddr_t";
    case SyscallType::kVcpu:
      return "zx_vcpu_t";
    case SyscallType::kVmOption:
      return "zx_vm_option_t";
    case SyscallType::kVmoCreationOption:
      return "zx_vmo_creation_option_t";
    case SyscallType::kVmoOp:
      return "zx_vmo_op_t";
    case SyscallType::kVmoOption:
      return "zx_vmo_option_t";
    case SyscallType::kVmoType:
      return "zx_info_vmo_type_t";
    case SyscallType::kStruct:
      return "";
  }
}

void DisplayType(SyscallType type, fidl_codec::PrettyPrinter& printer) {
  printer << ": " << fidl_codec::Green << TypeName(type) << fidl_codec::ResetColor << " = ";
}

}  // namespace fidlcat