/* -*-C-*- $Id: nttop.c,v 1.30 2000/12/05 21:23:45 cph Exp $ Copyright (c) 1993-2000 Massachusetts Institute of Technology This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define SCM_NTTOP_C #include "nt.h" #include "nttop.h" #include "osctty.h" #include "prims.h" #include "errors.h" #include "option.h" #include "outf.h" #include "ntscmlib.h" extern void execute_reload_cleanups (void); extern void NT_gui_init (void); extern void NT_initialize_channels (void); extern void NT_initialize_directory_reader (void); extern void NT_initialize_processes (void); extern void NT_initialize_signals (void); extern void NT_initialize_sockets (void); extern void NT_initialize_traps (void); extern void NT_initialize_tty (void); extern void NT_reset_channels (void); extern void NT_restore_channels (void); extern void NT_restore_signals (void); extern void NT_restore_traps (void); /* reset_interruptable_extent */ extern CONST char * OS_Name; extern CONST char * OS_Variant; static const char * w32_error_message (DWORD); static int syserr_to_unix_error_code (enum syserr_names); static void initialize_locks (void); static DWORD syserr_to_win32_error_code (enum syserr_names); static enum syserr_names win32_error_code_to_syserr (DWORD); BOOL win32_under_win32s_p () { OSVERSIONINFO info; (info.dwOSVersionInfoSize) = (sizeof (info)); (void) GetVersionEx (&info); return ((info.dwPlatformId) == VER_PLATFORM_WIN32s); } WIN32_SYSTEM_UTILITIES win32_system_utilities; HINSTANCE win32_system_utilities_dll = 0; void NT_initialize_win32_system_utilities () { #ifdef USE_SCHEME_DLL char * dll_name = win32_under_win32s_p() ? "SCHEME31.DLL" : "SCHEME32.DLL"; char * entry_name = "install_win32_system_utilities"; FARPROC install; win32_system_utilities_dll = LoadLibrary (dll_name); if (win32_system_utilities_dll == NULL) { outf_fatal ("MIT Scheme is unable to find or load %s\n" "This essential MIT Scheme file should be in the\n" "same directory as SCHEME.EXE", dll_name); outf_flush_fatal(); abort (); } install = GetProcAddress (win32_system_utilities_dll, entry_name); if (install==NULL) { outf_fatal ("Something is wrong with %s\n" "It does not have an entry called \"%s\".", dll_name, entry_name); outf_flush_fatal (); abort (); } install (&win32_system_utilities); #else extern void FAR WINAPI install_win32_system_utilities (WIN32_SYSTEM_UTILITIES *); install_win32_system_utilities (&win32_system_utilities); #endif } static int interactive; int OS_under_emacs_p (void) { return (option_emacs_subprocess); } enum windows_type NT_windows_type; static int empty_string_p (const char * s) { const char * p = s; while (1) switch (*p++) { case '\0': return (1); case ' ': case '\t': break; default: return (0); } } void OS_initialize (void) { interactive = 1; initialize_locks (); NT_gui_init (); NT_initialize_channels (); NT_initialize_tty (); NT_initialize_signals (); NT_initialize_traps (); NT_initialize_directory_reader (); NT_initialize_processes (); NT_initialize_sockets (); OS_Name = "NT"; { OSVERSIONINFO info; char * p = (malloc (250)); (info.dwOSVersionInfoSize) = (sizeof (info)); (void) GetVersionEx (&info); if ((info.dwPlatformId) == VER_PLATFORM_WIN32_NT) { sprintf (p, "Microsoft Windows NT %u.%u (Build %u", (info.dwMajorVersion), (info.dwMinorVersion), (info.dwBuildNumber)); if (!empty_string_p (info.szCSDVersion)) { strcat (p, "; "); strcat (p, (info.szCSDVersion)); } strcat (p, ")"); NT_windows_type = wintype_nt; } else if ((info.dwPlatformId) == VER_PLATFORM_WIN32_WINDOWS) { sprintf (p, "Microsoft Windows %s (Build %u", (((info.dwMinorVersion) == 0) ? "95" : ((info.dwMinorVersion) == 10) ? "98" : "9?"), (LOWORD (info.dwBuildNumber))); if (!empty_string_p (info.szCSDVersion)) { strcat (p, "; "); strcat (p, (info.szCSDVersion)); } strcat (p, ")"); NT_windows_type = wintype_95; } else { sprintf (p, "Microsoft Windows %u.%u", (info.dwMajorVersion), (info.dwMinorVersion)); NT_windows_type = wintype_31; } strcat (p, " IA-32\n"); OS_Variant = p; } } void OS_announcement (void) { #if 0 /* To make our compiler vendors happy. */ outf_console ("Copyright (c) 1993-1995 Massachusetts Institute of Technology\n"); outf_console ("\n"); #endif } void OS_reset (void) { /* There should really be a reset for each initialize above, but the rest seem innocuous. */ NT_reset_channels (); execute_reload_cleanups (); return; } void OS_quit (int code, int abnormal_p) { outf_console ("\nScheme has terminated abnormally!\n"); OS_restore_external_state (); return; } /* Memory Allocation */ static LPVOID NT_heap_base; static DWORD NT_heap_size; static DWORD NT_heap_error; #define SCHEME_ADDR_LIMIT 0x04000000 void NT_preallocate_heap (void) { MEMORY_BASIC_INFORMATION largest; DWORD scan = 0; (largest.RegionSize) = 0; while (scan < SCHEME_ADDR_LIMIT) { MEMORY_BASIC_INFORMATION info; (void) VirtualQuery (((LPCVOID) scan), (&info), (sizeof (info))); if ((info.State) == MEM_FREE) { DWORD end = (scan + (info.RegionSize)); if (end > SCHEME_ADDR_LIMIT) (info.RegionSize) -= (end - SCHEME_ADDR_LIMIT); if ((info.RegionSize) > (largest.RegionSize)) largest = info; } scan += (info.RegionSize); } NT_heap_size = (largest.RegionSize); NT_heap_base = (VirtualAlloc ((largest.BaseAddress), NT_heap_size, MEM_RESERVE, PAGE_READWRITE)); if (NT_heap_base == 0) NT_heap_error = (GetLastError ()); } char * NT_allocate_heap (unsigned long size, unsigned long * handle) { if (NT_heap_base == 0) { SYSTEM_INFO info; LPVOID start = 0; LPVOID base; GetSystemInfo (&info); while (1) { start = (((char *) start) + (info . dwPageSize)); base = (VirtualAlloc (start, size, (MEM_RESERVE | MEM_COMMIT), PAGE_READWRITE)); if (base != 0) break; } (* handle) = size; return ((char *) base); } else { DWORD size2 = ((size <= NT_heap_size) ? size : NT_heap_size); LPVOID base = (VirtualAlloc (NT_heap_base, size2, MEM_COMMIT, PAGE_READWRITE)); (* handle) = size2; return ((char *) base); } } void NT_release_heap (char * area, unsigned long handle) { VirtualFree (((LPVOID) area), ((DWORD) handle), ((DWORD) MEM_DECOMMIT)); if (NT_heap_base == 0) VirtualFree (((LPVOID) area), ((DWORD) 0), ((DWORD) MEM_RELEASE)); else VirtualFree (NT_heap_base, ((DWORD) 0), ((DWORD) MEM_RELEASE)); } #ifndef EAGAIN #define EAGAIN ERRNO_NONBLOCK #endif enum syserr_names OS_error_code_to_syserr (int code) { switch (code) { case E2BIG: return (syserr_arg_list_too_long); case EACCES: return (syserr_permission_denied); case EAGAIN: return (syserr_resource_temporarily_unavailable); case EBADF: return (syserr_bad_file_descriptor); case EDEADLOCK: return (syserr_resource_deadlock_avoided); case EDOM: return (syserr_domain_error); case EEXIST: return (syserr_unix_file_exists); case EINTR: return (syserr_interrupted_function_call); case EINVAL: return (syserr_invalid_argument); case EMFILE: return (syserr_unix_too_many_open_files); case ENOENT: return (syserr_no_such_file_or_directory); case ENOEXEC: return (syserr_exec_format_error); case ENOMEM: return (syserr_not_enough_space); case ENOTDIR: return (syserr_not_a_directory); case ERANGE: return (syserr_result_too_large); default: return (syserr_unknown); } } const char * OS_error_code_to_message (unsigned int syserr) { static const char * last_message = 0; if (last_message != 0) { OS_free ((void *) last_message); last_message = 0; } if (syserr < FIRST_UNIX_ERROR_CODE) { last_message = (w32_error_message (syserr_to_win32_error_code ((enum syserr_names) syserr))); /* The runtime system is assuming that the messages have no period, and adding its own. */ if (last_message != 0) { unsigned int length = (strlen (last_message)); if ((length > 0) && ((last_message [length - 1]) == '.')) (((char *) last_message) [length - 1]) = '\0'; } return (last_message); } else { #ifdef CL386 extern char * sys_errlist []; extern int sys_nerr; #endif int code = (syserr_to_unix_error_code ((enum syserr_names) syserr)); return (((code > 0) && (code <= sys_nerr)) ? (sys_errlist [code]) : 0); } } void NT_error_api_call (DWORD code, enum syscall_names name) { error_in_system_call ((win32_error_code_to_syserr (code)), name); } void NT_error_unix_call (int code, enum syscall_names name) { error_in_system_call ((OS_error_code_to_syserr (code)), name); } static const char * w32_error_message (DWORD rc) { char * buffer; char * result; DWORD length = (FormatMessage ((FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM), 0, rc, (MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT)), ((LPTSTR) (&buffer)), 0, 0)); if (length == 0) return (0); /* Assumes that we're using ANSI rather than Unicode characters. */ result = (OS_malloc ((strlen (buffer)) + 1)); { char * from = buffer; char * to = result; while (1) { char c = (*from++); (*to++) = c; if (c == '\0') break; } if (((to - 3) >= result) && ((to[-3]) == '\r') && ((to[-2]) == '\n')) (to[-3]) = '\0'; } (void) LocalFree (buffer); return (result); } static int syserr_to_unix_error_code (enum syserr_names syserr) { switch (syserr) { case syserr_arg_list_too_long: return (E2BIG); case syserr_bad_file_descriptor: return (EBADF); case syserr_domain_error: return (EDOM); case syserr_exec_format_error: return (ENOEXEC); case syserr_unix_file_exists: return (EEXIST); case syserr_interrupted_function_call: return (EINTR); case syserr_invalid_argument: return (EINVAL); case syserr_no_such_file_or_directory: return (ENOENT); case syserr_not_a_directory: return (ENOTDIR); case syserr_not_enough_space: return (ENOMEM); case syserr_permission_denied: return (EACCES); case syserr_resource_deadlock_avoided: return (EDEADLOCK); case syserr_resource_temporarily_unavailable: return (EAGAIN); case syserr_result_too_large: return (ERANGE); case syserr_unix_too_many_open_files: return (EMFILE); default: return (0); } } void NT_prim_check_errno (enum syscall_names name) { if (errno != EINTR) NT_error_unix_call (errno, name); deliver_pending_interrupts (); return; } void OS_restore_external_state (void) { NT_restore_traps (); NT_restore_signals (); NT_restore_channels (); return; } void bcopy (const char * s1, char * s2, int n) { while (n-- > 0) *s2++ = *s1++; return; } void * OS_malloc (unsigned int size) { void * result = (malloc (size)); if (result == 0) NT_error_unix_call (ENOMEM, syscall_malloc); return (result); } void * OS_realloc (void * ptr, unsigned int size) { void * result = (realloc (ptr, size)); if (result == 0) NT_error_unix_call (ENOMEM, syscall_realloc); return (result); } void OS_free (void * ptr) { free (ptr); } void OS_syscall_names (unsigned int * length, unsigned char *** names) { (*length) = ((sizeof (syscall_names_table)) / (sizeof (char *))); (*names) = ((unsigned char **) syscall_names_table); } void OS_syserr_names (unsigned int * length, unsigned char *** names) { (*length) = ((sizeof (syserr_names_table)) / (sizeof (char *))); (*names) = ((unsigned char **) syserr_names_table); } static CRITICAL_SECTION interrupt_registers_lock; static void initialize_locks (void) { InitializeCriticalSection (&interrupt_registers_lock); } void OS_grab_interrupt_registers (void) { EnterCriticalSection (&interrupt_registers_lock); } void OS_release_interrupt_registers (void) { LeaveCriticalSection (&interrupt_registers_lock); } /* Machine-generated procedure, do not edit: */ static DWORD syserr_to_win32_error_code (enum syserr_names syserr) { switch (syserr) { case syserr_invalid_function: return (ERROR_INVALID_FUNCTION); case syserr_file_not_found: return (ERROR_FILE_NOT_FOUND); case syserr_path_not_found: return (ERROR_PATH_NOT_FOUND); case syserr_too_many_open_files: return (ERROR_TOO_MANY_OPEN_FILES); case syserr_access_denied: return (ERROR_ACCESS_DENIED); case syserr_invalid_handle: return (ERROR_INVALID_HANDLE); case syserr_arena_trashed: return (ERROR_ARENA_TRASHED); case syserr_not_enough_memory: return (ERROR_NOT_ENOUGH_MEMORY); case syserr_invalid_block: return (ERROR_INVALID_BLOCK); case syserr_bad_environment: return (ERROR_BAD_ENVIRONMENT); case syserr_bad_format: return (ERROR_BAD_FORMAT); case syserr_invalid_access: return (ERROR_INVALID_ACCESS); case syserr_invalid_data: return (ERROR_INVALID_DATA); case syserr_outofmemory: return (ERROR_OUTOFMEMORY); case syserr_invalid_drive: return (ERROR_INVALID_DRIVE); case syserr_current_directory: return (ERROR_CURRENT_DIRECTORY); case syserr_not_same_device: return (ERROR_NOT_SAME_DEVICE); case syserr_no_more_files: return (ERROR_NO_MORE_FILES); case syserr_write_protect: return (ERROR_WRITE_PROTECT); case syserr_bad_unit: return (ERROR_BAD_UNIT); case syserr_not_ready: return (ERROR_NOT_READY); case syserr_bad_command: return (ERROR_BAD_COMMAND); case syserr_crc: return (ERROR_CRC); case syserr_bad_length: return (ERROR_BAD_LENGTH); case syserr_seek: return (ERROR_SEEK); case syserr_not_dos_disk: return (ERROR_NOT_DOS_DISK); case syserr_sector_not_found: return (ERROR_SECTOR_NOT_FOUND); case syserr_out_of_paper: return (ERROR_OUT_OF_PAPER); case syserr_write_fault: return (ERROR_WRITE_FAULT); case syserr_read_fault: return (ERROR_READ_FAULT); case syserr_gen_failure: return (ERROR_GEN_FAILURE); case syserr_sharing_violation: return (ERROR_SHARING_VIOLATION); case syserr_lock_violation: return (ERROR_LOCK_VIOLATION); case syserr_wrong_disk: return (ERROR_WRONG_DISK); case syserr_sharing_buffer_exceeded: return (ERROR_SHARING_BUFFER_EXCEEDED); case syserr_handle_eof: return (ERROR_HANDLE_EOF); case syserr_handle_disk_full: return (ERROR_HANDLE_DISK_FULL); case syserr_not_supported: return (ERROR_NOT_SUPPORTED); case syserr_rem_not_list: return (ERROR_REM_NOT_LIST); case syserr_dup_name: return (ERROR_DUP_NAME); case syserr_bad_netpath: return (ERROR_BAD_NETPATH); case syserr_network_busy: return (ERROR_NETWORK_BUSY); case syserr_dev_not_exist: return (ERROR_DEV_NOT_EXIST); case syserr_too_many_cmds: return (ERROR_TOO_MANY_CMDS); case syserr_adap_hdw_err: return (ERROR_ADAP_HDW_ERR); case syserr_bad_net_resp: return (ERROR_BAD_NET_RESP); case syserr_unexp_net_err: return (ERROR_UNEXP_NET_ERR); case syserr_bad_rem_adap: return (ERROR_BAD_REM_ADAP); case syserr_printq_full: return (ERROR_PRINTQ_FULL); case syserr_no_spool_space: return (ERROR_NO_SPOOL_SPACE); case syserr_print_cancelled: return (ERROR_PRINT_CANCELLED); case syserr_netname_deleted: return (ERROR_NETNAME_DELETED); case syserr_network_access_denied: return (ERROR_NETWORK_ACCESS_DENIED); case syserr_bad_dev_type: return (ERROR_BAD_DEV_TYPE); case syserr_bad_net_name: return (ERROR_BAD_NET_NAME); case syserr_too_many_names: return (ERROR_TOO_MANY_NAMES); case syserr_too_many_sess: return (ERROR_TOO_MANY_SESS); case syserr_sharing_paused: return (ERROR_SHARING_PAUSED); case syserr_req_not_accep: return (ERROR_REQ_NOT_ACCEP); case syserr_redir_paused: return (ERROR_REDIR_PAUSED); case syserr_file_exists: return (ERROR_FILE_EXISTS); case syserr_cannot_make: return (ERROR_CANNOT_MAKE); case syserr_fail_i24: return (ERROR_FAIL_I24); case syserr_out_of_structures: return (ERROR_OUT_OF_STRUCTURES); case syserr_already_assigned: return (ERROR_ALREADY_ASSIGNED); case syserr_invalid_password: return (ERROR_INVALID_PASSWORD); case syserr_invalid_parameter: return (ERROR_INVALID_PARAMETER); case syserr_net_write_fault: return (ERROR_NET_WRITE_FAULT); case syserr_no_proc_slots: return (ERROR_NO_PROC_SLOTS); case syserr_too_many_semaphores: return (ERROR_TOO_MANY_SEMAPHORES); case syserr_excl_sem_already_owned: return (ERROR_EXCL_SEM_ALREADY_OWNED); case syserr_sem_is_set: return (ERROR_SEM_IS_SET); case syserr_too_many_sem_requests: return (ERROR_TOO_MANY_SEM_REQUESTS); case syserr_invalid_at_interrupt_time: return (ERROR_INVALID_AT_INTERRUPT_TIME); case syserr_sem_owner_died: return (ERROR_SEM_OWNER_DIED); case syserr_sem_user_limit: return (ERROR_SEM_USER_LIMIT); case syserr_disk_change: return (ERROR_DISK_CHANGE); case syserr_drive_locked: return (ERROR_DRIVE_LOCKED); case syserr_broken_pipe: return (ERROR_BROKEN_PIPE); case syserr_open_failed: return (ERROR_OPEN_FAILED); case syserr_buffer_overflow: return (ERROR_BUFFER_OVERFLOW); case syserr_disk_full: return (ERROR_DISK_FULL); case syserr_no_more_search_handles: return (ERROR_NO_MORE_SEARCH_HANDLES); case syserr_invalid_target_handle: return (ERROR_INVALID_TARGET_HANDLE); case syserr_invalid_category: return (ERROR_INVALID_CATEGORY); case syserr_invalid_verify_switch: return (ERROR_INVALID_VERIFY_SWITCH); case syserr_bad_driver_level: return (ERROR_BAD_DRIVER_LEVEL); case syserr_call_not_implemented: return (ERROR_CALL_NOT_IMPLEMENTED); case syserr_sem_timeout: return (ERROR_SEM_TIMEOUT); case syserr_insufficient_buffer: return (ERROR_INSUFFICIENT_BUFFER); case syserr_invalid_name: return (ERROR_INVALID_NAME); case syserr_invalid_level: return (ERROR_INVALID_LEVEL); case syserr_no_volume_label: return (ERROR_NO_VOLUME_LABEL); case syserr_mod_not_found: return (ERROR_MOD_NOT_FOUND); case syserr_proc_not_found: return (ERROR_PROC_NOT_FOUND); case syserr_wait_no_children: return (ERROR_WAIT_NO_CHILDREN); case syserr_child_not_complete: return (ERROR_CHILD_NOT_COMPLETE); case syserr_direct_access_handle: return (ERROR_DIRECT_ACCESS_HANDLE); case syserr_negative_seek: return (ERROR_NEGATIVE_SEEK); case syserr_seek_on_device: return (ERROR_SEEK_ON_DEVICE); case syserr_is_join_target: return (ERROR_IS_JOIN_TARGET); case syserr_is_joined: return (ERROR_IS_JOINED); case syserr_is_substed: return (ERROR_IS_SUBSTED); case syserr_not_joined: return (ERROR_NOT_JOINED); case syserr_not_substed: return (ERROR_NOT_SUBSTED); case syserr_join_to_join: return (ERROR_JOIN_TO_JOIN); case syserr_subst_to_subst: return (ERROR_SUBST_TO_SUBST); case syserr_join_to_subst: return (ERROR_JOIN_TO_SUBST); case syserr_subst_to_join: return (ERROR_SUBST_TO_JOIN); case syserr_busy_drive: return (ERROR_BUSY_DRIVE); case syserr_same_drive: return (ERROR_SAME_DRIVE); case syserr_dir_not_root: return (ERROR_DIR_NOT_ROOT); case syserr_dir_not_empty: return (ERROR_DIR_NOT_EMPTY); case syserr_is_subst_path: return (ERROR_IS_SUBST_PATH); case syserr_is_join_path: return (ERROR_IS_JOIN_PATH); case syserr_path_busy: return (ERROR_PATH_BUSY); case syserr_is_subst_target: return (ERROR_IS_SUBST_TARGET); case syserr_system_trace: return (ERROR_SYSTEM_TRACE); case syserr_invalid_event_count: return (ERROR_INVALID_EVENT_COUNT); case syserr_too_many_muxwaiters: return (ERROR_TOO_MANY_MUXWAITERS); case syserr_invalid_list_format: return (ERROR_INVALID_LIST_FORMAT); case syserr_label_too_long: return (ERROR_LABEL_TOO_LONG); case syserr_too_many_tcbs: return (ERROR_TOO_MANY_TCBS); case syserr_signal_refused: return (ERROR_SIGNAL_REFUSED); case syserr_discarded: return (ERROR_DISCARDED); case syserr_not_locked: return (ERROR_NOT_LOCKED); case syserr_bad_threadid_addr: return (ERROR_BAD_THREADID_ADDR); case syserr_bad_arguments: return (ERROR_BAD_ARGUMENTS); case syserr_bad_pathname: return (ERROR_BAD_PATHNAME); case syserr_signal_pending: return (ERROR_SIGNAL_PENDING); case syserr_max_thrds_reached: return (ERROR_MAX_THRDS_REACHED); case syserr_lock_failed: return (ERROR_LOCK_FAILED); case syserr_busy: return (ERROR_BUSY); case syserr_cancel_violation: return (ERROR_CANCEL_VIOLATION); case syserr_atomic_locks_not_supported: return (ERROR_ATOMIC_LOCKS_NOT_SUPPORTED); case syserr_invalid_segment_number: return (ERROR_INVALID_SEGMENT_NUMBER); case syserr_invalid_ordinal: return (ERROR_INVALID_ORDINAL); case syserr_already_exists: return (ERROR_ALREADY_EXISTS); case syserr_invalid_flag_number: return (ERROR_INVALID_FLAG_NUMBER); case syserr_sem_not_found: return (ERROR_SEM_NOT_FOUND); case syserr_invalid_starting_codeseg: return (ERROR_INVALID_STARTING_CODESEG); case syserr_invalid_stackseg: return (ERROR_INVALID_STACKSEG); case syserr_invalid_moduletype: return (ERROR_INVALID_MODULETYPE); case syserr_invalid_exe_signature: return (ERROR_INVALID_EXE_SIGNATURE); case syserr_exe_marked_invalid: return (ERROR_EXE_MARKED_INVALID); case syserr_bad_exe_format: return (ERROR_BAD_EXE_FORMAT); case syserr_iterated_data_exceeds_64k: return (ERROR_ITERATED_DATA_EXCEEDS_64k); case syserr_invalid_minallocsize: return (ERROR_INVALID_MINALLOCSIZE); case syserr_dynlink_from_invalid_ring: return (ERROR_DYNLINK_FROM_INVALID_RING); case syserr_iopl_not_enabled: return (ERROR_IOPL_NOT_ENABLED); case syserr_invalid_segdpl: return (ERROR_INVALID_SEGDPL); case syserr_autodataseg_exceeds_64k: return (ERROR_AUTODATASEG_EXCEEDS_64k); case syserr_ring2seg_must_be_movable: return (ERROR_RING2SEG_MUST_BE_MOVABLE); case syserr_reloc_chain_xeeds_seglim: return (ERROR_RELOC_CHAIN_XEEDS_SEGLIM); case syserr_infloop_in_reloc_chain: return (ERROR_INFLOOP_IN_RELOC_CHAIN); case syserr_envvar_not_found: return (ERROR_ENVVAR_NOT_FOUND); case syserr_no_signal_sent: return (ERROR_NO_SIGNAL_SENT); case syserr_filename_exced_range: return (ERROR_FILENAME_EXCED_RANGE); case syserr_ring2_stack_in_use: return (ERROR_RING2_STACK_IN_USE); case syserr_meta_expansion_too_long: return (ERROR_META_EXPANSION_TOO_LONG); case syserr_invalid_signal_number: return (ERROR_INVALID_SIGNAL_NUMBER); case syserr_thread_1_inactive: return (ERROR_THREAD_1_INACTIVE); case syserr_locked: return (ERROR_LOCKED); case syserr_too_many_modules: return (ERROR_TOO_MANY_MODULES); case syserr_nesting_not_allowed: return (ERROR_NESTING_NOT_ALLOWED); case syserr_bad_pipe: return (ERROR_BAD_PIPE); case syserr_pipe_busy: return (ERROR_PIPE_BUSY); case syserr_no_data: return (ERROR_NO_DATA); case syserr_pipe_not_connected: return (ERROR_PIPE_NOT_CONNECTED); case syserr_more_data: return (ERROR_MORE_DATA); case syserr_vc_disconnected: return (ERROR_VC_DISCONNECTED); case syserr_invalid_ea_name: return (ERROR_INVALID_EA_NAME); case syserr_ea_list_inconsistent: return (ERROR_EA_LIST_INCONSISTENT); case syserr_no_more_items: return (ERROR_NO_MORE_ITEMS); case syserr_cannot_copy: return (ERROR_CANNOT_COPY); case syserr_directory: return (ERROR_DIRECTORY); case syserr_eas_didnt_fit: return (ERROR_EAS_DIDNT_FIT); case syserr_ea_file_corrupt: return (ERROR_EA_FILE_CORRUPT); case syserr_ea_table_full: return (ERROR_EA_TABLE_FULL); case syserr_invalid_ea_handle: return (ERROR_INVALID_EA_HANDLE); case syserr_eas_not_supported: return (ERROR_EAS_NOT_SUPPORTED); case syserr_not_owner: return (ERROR_NOT_OWNER); case syserr_too_many_posts: return (ERROR_TOO_MANY_POSTS); case syserr_partial_copy: return (ERROR_PARTIAL_COPY); case syserr_mr_mid_not_found: return (ERROR_MR_MID_NOT_FOUND); case syserr_invalid_address: return (ERROR_INVALID_ADDRESS); case syserr_arithmetic_overflow: return (ERROR_ARITHMETIC_OVERFLOW); case syserr_pipe_connected: return (ERROR_PIPE_CONNECTED); case syserr_pipe_listening: return (ERROR_PIPE_LISTENING); case syserr_ea_access_denied: return (ERROR_EA_ACCESS_DENIED); case syserr_operation_aborted: return (ERROR_OPERATION_ABORTED); case syserr_io_incomplete: return (ERROR_IO_INCOMPLETE); case syserr_io_pending: return (ERROR_IO_PENDING); case syserr_noaccess: return (ERROR_NOACCESS); case syserr_swaperror: return (ERROR_SWAPERROR); case syserr_stack_overflow: return (ERROR_STACK_OVERFLOW); case syserr_invalid_message: return (ERROR_INVALID_MESSAGE); case syserr_can_not_complete: return (ERROR_CAN_NOT_COMPLETE); case syserr_invalid_flags: return (ERROR_INVALID_FLAGS); case syserr_unrecognized_volume: return (ERROR_UNRECOGNIZED_VOLUME); case syserr_file_invalid: return (ERROR_FILE_INVALID); case syserr_fullscreen_mode: return (ERROR_FULLSCREEN_MODE); case syserr_no_token: return (ERROR_NO_TOKEN); case syserr_baddb: return (ERROR_BADDB); case syserr_badkey: return (ERROR_BADKEY); case syserr_cantopen: return (ERROR_CANTOPEN); case syserr_cantread: return (ERROR_CANTREAD); case syserr_cantwrite: return (ERROR_CANTWRITE); case syserr_registry_recovered: return (ERROR_REGISTRY_RECOVERED); case syserr_registry_corrupt: return (ERROR_REGISTRY_CORRUPT); case syserr_registry_io_failed: return (ERROR_REGISTRY_IO_FAILED); case syserr_not_registry_file: return (ERROR_NOT_REGISTRY_FILE); case syserr_key_deleted: return (ERROR_KEY_DELETED); case syserr_no_log_space: return (ERROR_NO_LOG_SPACE); case syserr_key_has_children: return (ERROR_KEY_HAS_CHILDREN); case syserr_child_must_be_volatile: return (ERROR_CHILD_MUST_BE_VOLATILE); case syserr_notify_enum_dir: return (ERROR_NOTIFY_ENUM_DIR); case syserr_dependent_services_running: return (ERROR_DEPENDENT_SERVICES_RUNNING); case syserr_invalid_service_control: return (ERROR_INVALID_SERVICE_CONTROL); case syserr_service_request_timeout: return (ERROR_SERVICE_REQUEST_TIMEOUT); case syserr_service_no_thread: return (ERROR_SERVICE_NO_THREAD); case syserr_service_database_locked: return (ERROR_SERVICE_DATABASE_LOCKED); case syserr_service_already_running: return (ERROR_SERVICE_ALREADY_RUNNING); case syserr_invalid_service_account: return (ERROR_INVALID_SERVICE_ACCOUNT); case syserr_service_disabled: return (ERROR_SERVICE_DISABLED); case syserr_circular_dependency: return (ERROR_CIRCULAR_DEPENDENCY); case syserr_service_does_not_exist: return (ERROR_SERVICE_DOES_NOT_EXIST); case syserr_service_cannot_accept_ctrl: return (ERROR_SERVICE_CANNOT_ACCEPT_CTRL); case syserr_service_not_active: return (ERROR_SERVICE_NOT_ACTIVE); case syserr_failed_service_controller_connect: return (ERROR_FAILED_SERVICE_CONTROLLER_CONNECT); case syserr_exception_in_service: return (ERROR_EXCEPTION_IN_SERVICE); case syserr_database_does_not_exist: return (ERROR_DATABASE_DOES_NOT_EXIST); case syserr_service_specific_error: return (ERROR_SERVICE_SPECIFIC_ERROR); case syserr_process_aborted: return (ERROR_PROCESS_ABORTED); case syserr_service_dependency_fail: return (ERROR_SERVICE_DEPENDENCY_FAIL); case syserr_service_logon_failed: return (ERROR_SERVICE_LOGON_FAILED); case syserr_service_start_hang: return (ERROR_SERVICE_START_HANG); case syserr_invalid_service_lock: return (ERROR_INVALID_SERVICE_LOCK); case syserr_service_marked_for_delete: return (ERROR_SERVICE_MARKED_FOR_DELETE); case syserr_service_exists: return (ERROR_SERVICE_EXISTS); case syserr_already_running_lkg: return (ERROR_ALREADY_RUNNING_LKG); case syserr_service_dependency_deleted: return (ERROR_SERVICE_DEPENDENCY_DELETED); case syserr_boot_already_accepted: return (ERROR_BOOT_ALREADY_ACCEPTED); case syserr_service_never_started: return (ERROR_SERVICE_NEVER_STARTED); case syserr_duplicate_service_name: return (ERROR_DUPLICATE_SERVICE_NAME); case syserr_end_of_media: return (ERROR_END_OF_MEDIA); case syserr_filemark_detected: return (ERROR_FILEMARK_DETECTED); case syserr_beginning_of_media: return (ERROR_BEGINNING_OF_MEDIA); case syserr_setmark_detected: return (ERROR_SETMARK_DETECTED); case syserr_no_data_detected: return (ERROR_NO_DATA_DETECTED); case syserr_partition_failure: return (ERROR_PARTITION_FAILURE); case syserr_invalid_block_length: return (ERROR_INVALID_BLOCK_LENGTH); case syserr_device_not_partitioned: return (ERROR_DEVICE_NOT_PARTITIONED); case syserr_unable_to_lock_media: return (ERROR_UNABLE_TO_LOCK_MEDIA); case syserr_unable_to_unload_media: return (ERROR_UNABLE_TO_UNLOAD_MEDIA); case syserr_media_changed: return (ERROR_MEDIA_CHANGED); case syserr_bus_reset: return (ERROR_BUS_RESET); case syserr_no_media_in_drive: return (ERROR_NO_MEDIA_IN_DRIVE); case syserr_no_unicode_translation: return (ERROR_NO_UNICODE_TRANSLATION); case syserr_dll_init_failed: return (ERROR_DLL_INIT_FAILED); case syserr_shutdown_in_progress: return (ERROR_SHUTDOWN_IN_PROGRESS); case syserr_no_shutdown_in_progress: return (ERROR_NO_SHUTDOWN_IN_PROGRESS); case syserr_io_device: return (ERROR_IO_DEVICE); case syserr_serial_no_device: return (ERROR_SERIAL_NO_DEVICE); case syserr_irq_busy: return (ERROR_IRQ_BUSY); case syserr_more_writes: return (ERROR_MORE_WRITES); case syserr_counter_timeout: return (ERROR_COUNTER_TIMEOUT); case syserr_floppy_id_mark_not_found: return (ERROR_FLOPPY_ID_MARK_NOT_FOUND); case syserr_floppy_wrong_cylinder: return (ERROR_FLOPPY_WRONG_CYLINDER); case syserr_floppy_unknown_error: return (ERROR_FLOPPY_UNKNOWN_ERROR); case syserr_floppy_bad_registers: return (ERROR_FLOPPY_BAD_REGISTERS); case syserr_disk_recalibrate_failed: return (ERROR_DISK_RECALIBRATE_FAILED); case syserr_disk_operation_failed: return (ERROR_DISK_OPERATION_FAILED); case syserr_disk_reset_failed: return (ERROR_DISK_RESET_FAILED); case syserr_eom_overflow: return (ERROR_EOM_OVERFLOW); case syserr_not_enough_server_memory: return (ERROR_NOT_ENOUGH_SERVER_MEMORY); case syserr_possible_deadlock: return (ERROR_POSSIBLE_DEADLOCK); case syserr_mapped_alignment: return (ERROR_MAPPED_ALIGNMENT); case syserr_set_power_state_vetoed: return (ERROR_SET_POWER_STATE_VETOED); case syserr_set_power_state_failed: return (ERROR_SET_POWER_STATE_FAILED); case syserr_old_win_version: return (ERROR_OLD_WIN_VERSION); case syserr_app_wrong_os: return (ERROR_APP_WRONG_OS); case syserr_single_instance_app: return (ERROR_SINGLE_INSTANCE_APP); case syserr_rmode_app: return (ERROR_RMODE_APP); case syserr_invalid_dll: return (ERROR_INVALID_DLL); case syserr_no_association: return (ERROR_NO_ASSOCIATION); case syserr_dde_fail: return (ERROR_DDE_FAIL); case syserr_dll_not_found: return (ERROR_DLL_NOT_FOUND); case syserr_bad_username: return (ERROR_BAD_USERNAME); case syserr_not_connected: return (ERROR_NOT_CONNECTED); case syserr_open_files: return (ERROR_OPEN_FILES); case syserr_active_connections: return (ERROR_ACTIVE_CONNECTIONS); case syserr_device_in_use: return (ERROR_DEVICE_IN_USE); case syserr_bad_device: return (ERROR_BAD_DEVICE); case syserr_connection_unavail: return (ERROR_CONNECTION_UNAVAIL); case syserr_device_already_remembered: return (ERROR_DEVICE_ALREADY_REMEMBERED); case syserr_no_net_or_bad_path: return (ERROR_NO_NET_OR_BAD_PATH); case syserr_bad_provider: return (ERROR_BAD_PROVIDER); case syserr_cannot_open_profile: return (ERROR_CANNOT_OPEN_PROFILE); case syserr_bad_profile: return (ERROR_BAD_PROFILE); case syserr_not_container: return (ERROR_NOT_CONTAINER); case syserr_extended_error: return (ERROR_EXTENDED_ERROR); case syserr_invalid_groupname: return (ERROR_INVALID_GROUPNAME); case syserr_invalid_computername: return (ERROR_INVALID_COMPUTERNAME); case syserr_invalid_eventname: return (ERROR_INVALID_EVENTNAME); case syserr_invalid_domainname: return (ERROR_INVALID_DOMAINNAME); case syserr_invalid_servicename: return (ERROR_INVALID_SERVICENAME); case syserr_invalid_netname: return (ERROR_INVALID_NETNAME); case syserr_invalid_sharename: return (ERROR_INVALID_SHARENAME); case syserr_invalid_passwordname: return (ERROR_INVALID_PASSWORDNAME); case syserr_invalid_messagename: return (ERROR_INVALID_MESSAGENAME); case syserr_invalid_messagedest: return (ERROR_INVALID_MESSAGEDEST); case syserr_session_credential_conflict: return (ERROR_SESSION_CREDENTIAL_CONFLICT); case syserr_remote_session_limit_exceeded: return (ERROR_REMOTE_SESSION_LIMIT_EXCEEDED); case syserr_dup_domainname: return (ERROR_DUP_DOMAINNAME); case syserr_no_network: return (ERROR_NO_NETWORK); case syserr_cancelled: return (ERROR_CANCELLED); case syserr_user_mapped_file: return (ERROR_USER_MAPPED_FILE); case syserr_connection_refused: return (ERROR_CONNECTION_REFUSED); case syserr_graceful_disconnect: return (ERROR_GRACEFUL_DISCONNECT); case syserr_address_already_associated: return (ERROR_ADDRESS_ALREADY_ASSOCIATED); case syserr_address_not_associated: return (ERROR_ADDRESS_NOT_ASSOCIATED); case syserr_connection_invalid: return (ERROR_CONNECTION_INVALID); case syserr_connection_active: return (ERROR_CONNECTION_ACTIVE); case syserr_network_unreachable: return (ERROR_NETWORK_UNREACHABLE); case syserr_host_unreachable: return (ERROR_HOST_UNREACHABLE); case syserr_protocol_unreachable: return (ERROR_PROTOCOL_UNREACHABLE); case syserr_port_unreachable: return (ERROR_PORT_UNREACHABLE); case syserr_request_aborted: return (ERROR_REQUEST_ABORTED); case syserr_connection_aborted: return (ERROR_CONNECTION_ABORTED); case syserr_retry: return (ERROR_RETRY); case syserr_connection_count_limit: return (ERROR_CONNECTION_COUNT_LIMIT); case syserr_login_time_restriction: return (ERROR_LOGIN_TIME_RESTRICTION); case syserr_login_wksta_restriction: return (ERROR_LOGIN_WKSTA_RESTRICTION); case syserr_incorrect_address: return (ERROR_INCORRECT_ADDRESS); case syserr_already_registered: return (ERROR_ALREADY_REGISTERED); case syserr_service_not_found: return (ERROR_SERVICE_NOT_FOUND); case syserr_not_authenticated: return (ERROR_NOT_AUTHENTICATED); case syserr_not_logged_on: return (ERROR_NOT_LOGGED_ON); case syserr_continue: return (ERROR_CONTINUE); case syserr_already_initialized: return (ERROR_ALREADY_INITIALIZED); case syserr_no_more_devices: return (ERROR_NO_MORE_DEVICES); case syserr_not_all_assigned: return (ERROR_NOT_ALL_ASSIGNED); case syserr_some_not_mapped: return (ERROR_SOME_NOT_MAPPED); case syserr_no_quotas_for_account: return (ERROR_NO_QUOTAS_FOR_ACCOUNT); case syserr_local_user_session_key: return (ERROR_LOCAL_USER_SESSION_KEY); case syserr_null_lm_password: return (ERROR_NULL_LM_PASSWORD); case syserr_unknown_revision: return (ERROR_UNKNOWN_REVISION); case syserr_revision_mismatch: return (ERROR_REVISION_MISMATCH); case syserr_invalid_owner: return (ERROR_INVALID_OWNER); case syserr_invalid_primary_group: return (ERROR_INVALID_PRIMARY_GROUP); case syserr_no_impersonation_token: return (ERROR_NO_IMPERSONATION_TOKEN); case syserr_cant_disable_mandatory: return (ERROR_CANT_DISABLE_MANDATORY); case syserr_no_logon_servers: return (ERROR_NO_LOGON_SERVERS); case syserr_no_such_logon_session: return (ERROR_NO_SUCH_LOGON_SESSION); case syserr_no_such_privilege: return (ERROR_NO_SUCH_PRIVILEGE); case syserr_privilege_not_held: return (ERROR_PRIVILEGE_NOT_HELD); case syserr_invalid_account_name: return (ERROR_INVALID_ACCOUNT_NAME); case syserr_user_exists: return (ERROR_USER_EXISTS); case syserr_no_such_user: return (ERROR_NO_SUCH_USER); case syserr_group_exists: return (ERROR_GROUP_EXISTS); case syserr_no_such_group: return (ERROR_NO_SUCH_GROUP); case syserr_member_in_group: return (ERROR_MEMBER_IN_GROUP); case syserr_member_not_in_group: return (ERROR_MEMBER_NOT_IN_GROUP); case syserr_last_admin: return (ERROR_LAST_ADMIN); case syserr_wrong_password: return (ERROR_WRONG_PASSWORD); case syserr_ill_formed_password: return (ERROR_ILL_FORMED_PASSWORD); case syserr_password_restriction: return (ERROR_PASSWORD_RESTRICTION); case syserr_logon_failure: return (ERROR_LOGON_FAILURE); case syserr_account_restriction: return (ERROR_ACCOUNT_RESTRICTION); case syserr_invalid_logon_hours: return (ERROR_INVALID_LOGON_HOURS); case syserr_invalid_workstation: return (ERROR_INVALID_WORKSTATION); case syserr_password_expired: return (ERROR_PASSWORD_EXPIRED); case syserr_account_disabled: return (ERROR_ACCOUNT_DISABLED); case syserr_none_mapped: return (ERROR_NONE_MAPPED); case syserr_too_many_luids_requested: return (ERROR_TOO_MANY_LUIDS_REQUESTED); case syserr_luids_exhausted: return (ERROR_LUIDS_EXHAUSTED); case syserr_invalid_sub_authority: return (ERROR_INVALID_SUB_AUTHORITY); case syserr_invalid_acl: return (ERROR_INVALID_ACL); case syserr_invalid_sid: return (ERROR_INVALID_SID); case syserr_invalid_security_descr: return (ERROR_INVALID_SECURITY_DESCR); case syserr_bad_inheritance_acl: return (ERROR_BAD_INHERITANCE_ACL); case syserr_server_disabled: return (ERROR_SERVER_DISABLED); case syserr_server_not_disabled: return (ERROR_SERVER_NOT_DISABLED); case syserr_invalid_id_authority: return (ERROR_INVALID_ID_AUTHORITY); case syserr_allotted_space_exceeded: return (ERROR_ALLOTTED_SPACE_EXCEEDED); case syserr_invalid_group_attributes: return (ERROR_INVALID_GROUP_ATTRIBUTES); case syserr_bad_impersonation_level: return (ERROR_BAD_IMPERSONATION_LEVEL); case syserr_cant_open_anonymous: return (ERROR_CANT_OPEN_ANONYMOUS); case syserr_bad_validation_class: return (ERROR_BAD_VALIDATION_CLASS); case syserr_bad_token_type: return (ERROR_BAD_TOKEN_TYPE); case syserr_no_security_on_object: return (ERROR_NO_SECURITY_ON_OBJECT); case syserr_cant_access_domain_info: return (ERROR_CANT_ACCESS_DOMAIN_INFO); case syserr_invalid_server_state: return (ERROR_INVALID_SERVER_STATE); case syserr_invalid_domain_state: return (ERROR_INVALID_DOMAIN_STATE); case syserr_invalid_domain_role: return (ERROR_INVALID_DOMAIN_ROLE); case syserr_no_such_domain: return (ERROR_NO_SUCH_DOMAIN); case syserr_domain_exists: return (ERROR_DOMAIN_EXISTS); case syserr_domain_limit_exceeded: return (ERROR_DOMAIN_LIMIT_EXCEEDED); case syserr_internal_db_corruption: return (ERROR_INTERNAL_DB_CORRUPTION); case syserr_internal_error: return (ERROR_INTERNAL_ERROR); case syserr_generic_not_mapped: return (ERROR_GENERIC_NOT_MAPPED); case syserr_bad_descriptor_format: return (ERROR_BAD_DESCRIPTOR_FORMAT); case syserr_not_logon_process: return (ERROR_NOT_LOGON_PROCESS); case syserr_logon_session_exists: return (ERROR_LOGON_SESSION_EXISTS); case syserr_no_such_package: return (ERROR_NO_SUCH_PACKAGE); case syserr_bad_logon_session_state: return (ERROR_BAD_LOGON_SESSION_STATE); case syserr_logon_session_collision: return (ERROR_LOGON_SESSION_COLLISION); case syserr_invalid_logon_type: return (ERROR_INVALID_LOGON_TYPE); case syserr_cannot_impersonate: return (ERROR_CANNOT_IMPERSONATE); case syserr_rxact_invalid_state: return (ERROR_RXACT_INVALID_STATE); case syserr_rxact_commit_failure: return (ERROR_RXACT_COMMIT_FAILURE); case syserr_special_account: return (ERROR_SPECIAL_ACCOUNT); case syserr_special_group: return (ERROR_SPECIAL_GROUP); case syserr_special_user: return (ERROR_SPECIAL_USER); case syserr_members_primary_group: return (ERROR_MEMBERS_PRIMARY_GROUP); case syserr_token_already_in_use: return (ERROR_TOKEN_ALREADY_IN_USE); case syserr_no_such_alias: return (ERROR_NO_SUCH_ALIAS); case syserr_member_not_in_alias: return (ERROR_MEMBER_NOT_IN_ALIAS); case syserr_member_in_alias: return (ERROR_MEMBER_IN_ALIAS); case syserr_alias_exists: return (ERROR_ALIAS_EXISTS); case syserr_logon_not_granted: return (ERROR_LOGON_NOT_GRANTED); case syserr_too_many_secrets: return (ERROR_TOO_MANY_SECRETS); case syserr_secret_too_long: return (ERROR_SECRET_TOO_LONG); case syserr_internal_db_error: return (ERROR_INTERNAL_DB_ERROR); case syserr_too_many_context_ids: return (ERROR_TOO_MANY_CONTEXT_IDS); case syserr_logon_type_not_granted: return (ERROR_LOGON_TYPE_NOT_GRANTED); case syserr_nt_cross_encryption_required: return (ERROR_NT_CROSS_ENCRYPTION_REQUIRED); case syserr_no_such_member: return (ERROR_NO_SUCH_MEMBER); case syserr_invalid_member: return (ERROR_INVALID_MEMBER); case syserr_too_many_sids: return (ERROR_TOO_MANY_SIDS); case syserr_lm_cross_encryption_required: return (ERROR_LM_CROSS_ENCRYPTION_REQUIRED); case syserr_no_inheritance: return (ERROR_NO_INHERITANCE); case syserr_file_corrupt: return (ERROR_FILE_CORRUPT); case syserr_disk_corrupt: return (ERROR_DISK_CORRUPT); case syserr_no_user_session_key: return (ERROR_NO_USER_SESSION_KEY); case syserr_license_quota_exceeded: return (ERROR_LICENSE_QUOTA_EXCEEDED); case syserr_invalid_window_handle: return (ERROR_INVALID_WINDOW_HANDLE); case syserr_invalid_menu_handle: return (ERROR_INVALID_MENU_HANDLE); case syserr_invalid_cursor_handle: return (ERROR_INVALID_CURSOR_HANDLE); case syserr_invalid_accel_handle: return (ERROR_INVALID_ACCEL_HANDLE); case syserr_invalid_hook_handle: return (ERROR_INVALID_HOOK_HANDLE); case syserr_invalid_dwp_handle: return (ERROR_INVALID_DWP_HANDLE); case syserr_tlw_with_wschild: return (ERROR_TLW_WITH_WSCHILD); case syserr_cannot_find_wnd_class: return (ERROR_CANNOT_FIND_WND_CLASS); case syserr_window_of_other_thread: return (ERROR_WINDOW_OF_OTHER_THREAD); case syserr_hotkey_already_registered: return (ERROR_HOTKEY_ALREADY_REGISTERED); case syserr_class_already_exists: return (ERROR_CLASS_ALREADY_EXISTS); case syserr_class_does_not_exist: return (ERROR_CLASS_DOES_NOT_EXIST); case syserr_class_has_windows: return (ERROR_CLASS_HAS_WINDOWS); case syserr_invalid_index: return (ERROR_INVALID_INDEX); case syserr_invalid_icon_handle: return (ERROR_INVALID_ICON_HANDLE); case syserr_private_dialog_index: return (ERROR_PRIVATE_DIALOG_INDEX); case syserr_listbox_id_not_found: return (ERROR_LISTBOX_ID_NOT_FOUND); case syserr_no_wildcard_characters: return (ERROR_NO_WILDCARD_CHARACTERS); case syserr_clipboard_not_open: return (ERROR_CLIPBOARD_NOT_OPEN); case syserr_hotkey_not_registered: return (ERROR_HOTKEY_NOT_REGISTERED); case syserr_window_not_dialog: return (ERROR_WINDOW_NOT_DIALOG); case syserr_control_id_not_found: return (ERROR_CONTROL_ID_NOT_FOUND); case syserr_invalid_combobox_message: return (ERROR_INVALID_COMBOBOX_MESSAGE); case syserr_window_not_combobox: return (ERROR_WINDOW_NOT_COMBOBOX); case syserr_invalid_edit_height: return (ERROR_INVALID_EDIT_HEIGHT); case syserr_dc_not_found: return (ERROR_DC_NOT_FOUND); case syserr_invalid_hook_filter: return (ERROR_INVALID_HOOK_FILTER); case syserr_invalid_filter_proc: return (ERROR_INVALID_FILTER_PROC); case syserr_hook_needs_hmod: return (ERROR_HOOK_NEEDS_HMOD); case syserr_global_only_hook: return (ERROR_GLOBAL_ONLY_HOOK); case syserr_journal_hook_set: return (ERROR_JOURNAL_HOOK_SET); case syserr_hook_not_installed: return (ERROR_HOOK_NOT_INSTALLED); case syserr_invalid_lb_message: return (ERROR_INVALID_LB_MESSAGE); case syserr_setcount_on_bad_lb: return (ERROR_SETCOUNT_ON_BAD_LB); case syserr_lb_without_tabstops: return (ERROR_LB_WITHOUT_TABSTOPS); case syserr_destroy_object_of_other_thread: return (ERROR_DESTROY_OBJECT_OF_OTHER_THREAD); case syserr_child_window_menu: return (ERROR_CHILD_WINDOW_MENU); case syserr_no_system_menu: return (ERROR_NO_SYSTEM_MENU); case syserr_invalid_msgbox_style: return (ERROR_INVALID_MSGBOX_STYLE); case syserr_invalid_spi_value: return (ERROR_INVALID_SPI_VALUE); case syserr_screen_already_locked: return (ERROR_SCREEN_ALREADY_LOCKED); case syserr_hwnds_have_diff_parent: return (ERROR_HWNDS_HAVE_DIFF_PARENT); case syserr_not_child_window: return (ERROR_NOT_CHILD_WINDOW); case syserr_invalid_gw_command: return (ERROR_INVALID_GW_COMMAND); case syserr_invalid_thread_id: return (ERROR_INVALID_THREAD_ID); case syserr_non_mdichild_window: return (ERROR_NON_MDICHILD_WINDOW); case syserr_popup_already_active: return (ERROR_POPUP_ALREADY_ACTIVE); case syserr_no_scrollbars: return (ERROR_NO_SCROLLBARS); case syserr_invalid_scrollbar_range: return (ERROR_INVALID_SCROLLBAR_RANGE); case syserr_invalid_showwin_command: return (ERROR_INVALID_SHOWWIN_COMMAND); case syserr_no_system_resources: return (ERROR_NO_SYSTEM_RESOURCES); case syserr_nonpaged_system_resources: return (ERROR_NONPAGED_SYSTEM_RESOURCES); case syserr_paged_system_resources: return (ERROR_PAGED_SYSTEM_RESOURCES); case syserr_working_set_quota: return (ERROR_WORKING_SET_QUOTA); case syserr_pagefile_quota: return (ERROR_PAGEFILE_QUOTA); case syserr_commitment_limit: return (ERROR_COMMITMENT_LIMIT); case syserr_menu_item_not_found: return (ERROR_MENU_ITEM_NOT_FOUND); case syserr_eventlog_file_corrupt: return (ERROR_EVENTLOG_FILE_CORRUPT); case syserr_eventlog_cant_start: return (ERROR_EVENTLOG_CANT_START); case syserr_log_file_full: return (ERROR_LOG_FILE_FULL); case syserr_eventlog_file_changed: return (ERROR_EVENTLOG_FILE_CHANGED); case syserr_rpc_s_invalid_string_binding: return (RPC_S_INVALID_STRING_BINDING); case syserr_rpc_s_wrong_kind_of_binding: return (RPC_S_WRONG_KIND_OF_BINDING); case syserr_rpc_s_invalid_binding: return (RPC_S_INVALID_BINDING); case syserr_rpc_s_protseq_not_supported: return (RPC_S_PROTSEQ_NOT_SUPPORTED); case syserr_rpc_s_invalid_rpc_protseq: return (RPC_S_INVALID_RPC_PROTSEQ); case syserr_rpc_s_invalid_string_uuid: return (RPC_S_INVALID_STRING_UUID); case syserr_rpc_s_invalid_endpoint_format: return (RPC_S_INVALID_ENDPOINT_FORMAT); case syserr_rpc_s_invalid_net_addr: return (RPC_S_INVALID_NET_ADDR); case syserr_rpc_s_no_endpoint_found: return (RPC_S_NO_ENDPOINT_FOUND); case syserr_rpc_s_invalid_timeout: return (RPC_S_INVALID_TIMEOUT); case syserr_rpc_s_object_not_found: return (RPC_S_OBJECT_NOT_FOUND); case syserr_rpc_s_already_registered: return (RPC_S_ALREADY_REGISTERED); case syserr_rpc_s_type_already_registered: return (RPC_S_TYPE_ALREADY_REGISTERED); case syserr_rpc_s_already_listening: return (RPC_S_ALREADY_LISTENING); case syserr_rpc_s_no_protseqs_registered: return (RPC_S_NO_PROTSEQS_REGISTERED); case syserr_rpc_s_not_listening: return (RPC_S_NOT_LISTENING); case syserr_rpc_s_unknown_mgr_type: return (RPC_S_UNKNOWN_MGR_TYPE); case syserr_rpc_s_unknown_if: return (RPC_S_UNKNOWN_IF); case syserr_rpc_s_no_bindings: return (RPC_S_NO_BINDINGS); case syserr_rpc_s_no_protseqs: return (RPC_S_NO_PROTSEQS); case syserr_rpc_s_cant_create_endpoint: return (RPC_S_CANT_CREATE_ENDPOINT); case syserr_rpc_s_out_of_resources: return (RPC_S_OUT_OF_RESOURCES); case syserr_rpc_s_server_unavailable: return (RPC_S_SERVER_UNAVAILABLE); case syserr_rpc_s_server_too_busy: return (RPC_S_SERVER_TOO_BUSY); case syserr_rpc_s_invalid_network_options: return (RPC_S_INVALID_NETWORK_OPTIONS); case syserr_rpc_s_no_call_active: return (RPC_S_NO_CALL_ACTIVE); case syserr_rpc_s_call_failed: return (RPC_S_CALL_FAILED); case syserr_rpc_s_call_failed_dne: return (RPC_S_CALL_FAILED_DNE); case syserr_rpc_s_protocol_error: return (RPC_S_PROTOCOL_ERROR); case syserr_rpc_s_unsupported_trans_syn: return (RPC_S_UNSUPPORTED_TRANS_SYN); case syserr_rpc_s_unsupported_type: return (RPC_S_UNSUPPORTED_TYPE); case syserr_rpc_s_invalid_tag: return (RPC_S_INVALID_TAG); case syserr_rpc_s_invalid_bound: return (RPC_S_INVALID_BOUND); case syserr_rpc_s_no_entry_name: return (RPC_S_NO_ENTRY_NAME); case syserr_rpc_s_invalid_name_syntax: return (RPC_S_INVALID_NAME_SYNTAX); case syserr_rpc_s_unsupported_name_syntax: return (RPC_S_UNSUPPORTED_NAME_SYNTAX); case syserr_rpc_s_uuid_no_address: return (RPC_S_UUID_NO_ADDRESS); case syserr_rpc_s_duplicate_endpoint: return (RPC_S_DUPLICATE_ENDPOINT); case syserr_rpc_s_unknown_authn_type: return (RPC_S_UNKNOWN_AUTHN_TYPE); case syserr_rpc_s_max_calls_too_small: return (RPC_S_MAX_CALLS_TOO_SMALL); case syserr_rpc_s_string_too_long: return (RPC_S_STRING_TOO_LONG); case syserr_rpc_s_protseq_not_found: return (RPC_S_PROTSEQ_NOT_FOUND); case syserr_rpc_s_procnum_out_of_range: return (RPC_S_PROCNUM_OUT_OF_RANGE); case syserr_rpc_s_binding_has_no_auth: return (RPC_S_BINDING_HAS_NO_AUTH); case syserr_rpc_s_unknown_authn_service: return (RPC_S_UNKNOWN_AUTHN_SERVICE); case syserr_rpc_s_unknown_authn_level: return (RPC_S_UNKNOWN_AUTHN_LEVEL); case syserr_rpc_s_invalid_auth_identity: return (RPC_S_INVALID_AUTH_IDENTITY); case syserr_rpc_s_unknown_authz_service: return (RPC_S_UNKNOWN_AUTHZ_SERVICE); case syserr_ept_s_invalid_entry: return (EPT_S_INVALID_ENTRY); case syserr_ept_s_cant_perform_op: return (EPT_S_CANT_PERFORM_OP); case syserr_ept_s_not_registered: return (EPT_S_NOT_REGISTERED); case syserr_rpc_s_nothing_to_export: return (RPC_S_NOTHING_TO_EXPORT); case syserr_rpc_s_incomplete_name: return (RPC_S_INCOMPLETE_NAME); case syserr_rpc_s_invalid_vers_option: return (RPC_S_INVALID_VERS_OPTION); case syserr_rpc_s_no_more_members: return (RPC_S_NO_MORE_MEMBERS); case syserr_rpc_s_not_all_objs_unexported: return (RPC_S_NOT_ALL_OBJS_UNEXPORTED); case syserr_rpc_s_interface_not_found: return (RPC_S_INTERFACE_NOT_FOUND); case syserr_rpc_s_entry_already_exists: return (RPC_S_ENTRY_ALREADY_EXISTS); case syserr_rpc_s_entry_not_found: return (RPC_S_ENTRY_NOT_FOUND); case syserr_rpc_s_name_service_unavailable: return (RPC_S_NAME_SERVICE_UNAVAILABLE); case syserr_rpc_s_invalid_naf_id: return (RPC_S_INVALID_NAF_ID); case syserr_rpc_s_cannot_support: return (RPC_S_CANNOT_SUPPORT); case syserr_rpc_s_no_context_available: return (RPC_S_NO_CONTEXT_AVAILABLE); case syserr_rpc_s_internal_error: return (RPC_S_INTERNAL_ERROR); case syserr_rpc_s_zero_divide: return (RPC_S_ZERO_DIVIDE); case syserr_rpc_s_address_error: return (RPC_S_ADDRESS_ERROR); case syserr_rpc_s_fp_div_zero: return (RPC_S_FP_DIV_ZERO); case syserr_rpc_s_fp_underflow: return (RPC_S_FP_UNDERFLOW); case syserr_rpc_s_fp_overflow: return (RPC_S_FP_OVERFLOW); case syserr_rpc_x_no_more_entries: return (RPC_X_NO_MORE_ENTRIES); case syserr_rpc_x_ss_char_trans_open_fail: return (RPC_X_SS_CHAR_TRANS_OPEN_FAIL); case syserr_rpc_x_ss_char_trans_short_file: return (RPC_X_SS_CHAR_TRANS_SHORT_FILE); case syserr_rpc_x_ss_in_null_context: return (RPC_X_SS_IN_NULL_CONTEXT); case syserr_rpc_x_ss_context_damaged: return (RPC_X_SS_CONTEXT_DAMAGED); case syserr_rpc_x_ss_handles_mismatch: return (RPC_X_SS_HANDLES_MISMATCH); case syserr_rpc_x_ss_cannot_get_call_handle: return (RPC_X_SS_CANNOT_GET_CALL_HANDLE); case syserr_rpc_x_null_ref_pointer: return (RPC_X_NULL_REF_POINTER); case syserr_rpc_x_enum_value_out_of_range: return (RPC_X_ENUM_VALUE_OUT_OF_RANGE); case syserr_rpc_x_byte_count_too_small: return (RPC_X_BYTE_COUNT_TOO_SMALL); case syserr_rpc_x_bad_stub_data: return (RPC_X_BAD_STUB_DATA); case syserr_invalid_user_buffer: return (ERROR_INVALID_USER_BUFFER); case syserr_unrecognized_media: return (ERROR_UNRECOGNIZED_MEDIA); case syserr_no_trust_lsa_secret: return (ERROR_NO_TRUST_LSA_SECRET); case syserr_no_trust_sam_account: return (ERROR_NO_TRUST_SAM_ACCOUNT); case syserr_trusted_domain_failure: return (ERROR_TRUSTED_DOMAIN_FAILURE); case syserr_trusted_relationship_failure: return (ERROR_TRUSTED_RELATIONSHIP_FAILURE); case syserr_trust_failure: return (ERROR_TRUST_FAILURE); case syserr_rpc_s_call_in_progress: return (RPC_S_CALL_IN_PROGRESS); case syserr_netlogon_not_started: return (ERROR_NETLOGON_NOT_STARTED); case syserr_account_expired: return (ERROR_ACCOUNT_EXPIRED); case syserr_redirector_has_open_handles: return (ERROR_REDIRECTOR_HAS_OPEN_HANDLES); case syserr_printer_driver_already_installed: return (ERROR_PRINTER_DRIVER_ALREADY_INSTALLED); case syserr_unknown_port: return (ERROR_UNKNOWN_PORT); case syserr_unknown_printer_driver: return (ERROR_UNKNOWN_PRINTER_DRIVER); case syserr_unknown_printprocessor: return (ERROR_UNKNOWN_PRINTPROCESSOR); case syserr_invalid_separator_file: return (ERROR_INVALID_SEPARATOR_FILE); case syserr_invalid_priority: return (ERROR_INVALID_PRIORITY); case syserr_invalid_printer_name: return (ERROR_INVALID_PRINTER_NAME); case syserr_printer_already_exists: return (ERROR_PRINTER_ALREADY_EXISTS); case syserr_invalid_printer_command: return (ERROR_INVALID_PRINTER_COMMAND); case syserr_invalid_datatype: return (ERROR_INVALID_DATATYPE); case syserr_invalid_environment: return (ERROR_INVALID_ENVIRONMENT); case syserr_rpc_s_no_more_bindings: return (RPC_S_NO_MORE_BINDINGS); case syserr_nologon_interdomain_trust_account: return (ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT); case syserr_nologon_workstation_trust_account: return (ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT); case syserr_nologon_server_trust_account: return (ERROR_NOLOGON_SERVER_TRUST_ACCOUNT); case syserr_domain_trust_inconsistent: return (ERROR_DOMAIN_TRUST_INCONSISTENT); case syserr_server_has_open_handles: return (ERROR_SERVER_HAS_OPEN_HANDLES); case syserr_resource_data_not_found: return (ERROR_RESOURCE_DATA_NOT_FOUND); case syserr_resource_type_not_found: return (ERROR_RESOURCE_TYPE_NOT_FOUND); case syserr_resource_name_not_found: return (ERROR_RESOURCE_NAME_NOT_FOUND); case syserr_resource_lang_not_found: return (ERROR_RESOURCE_LANG_NOT_FOUND); case syserr_not_enough_quota: return (ERROR_NOT_ENOUGH_QUOTA); case syserr_rpc_s_no_interfaces: return (RPC_S_NO_INTERFACES); case syserr_rpc_s_call_cancelled: return (RPC_S_CALL_CANCELLED); case syserr_rpc_s_binding_incomplete: return (RPC_S_BINDING_INCOMPLETE); case syserr_rpc_s_comm_failure: return (RPC_S_COMM_FAILURE); case syserr_rpc_s_unsupported_authn_level: return (RPC_S_UNSUPPORTED_AUTHN_LEVEL); case syserr_rpc_s_no_princ_name: return (RPC_S_NO_PRINC_NAME); case syserr_rpc_s_not_rpc_error: return (RPC_S_NOT_RPC_ERROR); case syserr_rpc_s_uuid_local_only: return (RPC_S_UUID_LOCAL_ONLY); case syserr_rpc_s_sec_pkg_error: return (RPC_S_SEC_PKG_ERROR); case syserr_rpc_s_not_cancelled: return (RPC_S_NOT_CANCELLED); case syserr_rpc_x_invalid_es_action: return (RPC_X_INVALID_ES_ACTION); case syserr_rpc_x_wrong_es_version: return (RPC_X_WRONG_ES_VERSION); case syserr_rpc_x_wrong_stub_version: return (RPC_X_WRONG_STUB_VERSION); case syserr_rpc_s_group_member_not_found: return (RPC_S_GROUP_MEMBER_NOT_FOUND); case syserr_ept_s_cant_create: return (EPT_S_CANT_CREATE); case syserr_rpc_s_invalid_object: return (RPC_S_INVALID_OBJECT); case syserr_invalid_time: return (ERROR_INVALID_TIME); case syserr_invalid_form_name: return (ERROR_INVALID_FORM_NAME); case syserr_invalid_form_size: return (ERROR_INVALID_FORM_SIZE); case syserr_already_waiting: return (ERROR_ALREADY_WAITING); case syserr_printer_deleted: return (ERROR_PRINTER_DELETED); case syserr_invalid_printer_state: return (ERROR_INVALID_PRINTER_STATE); case syserr_password_must_change: return (ERROR_PASSWORD_MUST_CHANGE); case syserr_domain_controller_not_found: return (ERROR_DOMAIN_CONTROLLER_NOT_FOUND); case syserr_account_locked_out: return (ERROR_ACCOUNT_LOCKED_OUT); case syserr_no_browser_servers_found: return (ERROR_NO_BROWSER_SERVERS_FOUND); case syserr_invalid_pixel_format: return (ERROR_INVALID_PIXEL_FORMAT); case syserr_bad_driver: return (ERROR_BAD_DRIVER); case syserr_invalid_window_style: return (ERROR_INVALID_WINDOW_STYLE); case syserr_metafile_not_supported: return (ERROR_METAFILE_NOT_SUPPORTED); case syserr_transform_not_supported: return (ERROR_TRANSFORM_NOT_SUPPORTED); case syserr_clipping_not_supported: return (ERROR_CLIPPING_NOT_SUPPORTED); case syserr_unknown_print_monitor: return (ERROR_UNKNOWN_PRINT_MONITOR); case syserr_printer_driver_in_use: return (ERROR_PRINTER_DRIVER_IN_USE); case syserr_spool_file_not_found: return (ERROR_SPOOL_FILE_NOT_FOUND); case syserr_spl_no_startdoc: return (ERROR_SPL_NO_STARTDOC); case syserr_spl_no_addjob: return (ERROR_SPL_NO_ADDJOB); case syserr_print_processor_already_installed: return (ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED); case syserr_print_monitor_already_installed: return (ERROR_PRINT_MONITOR_ALREADY_INSTALLED); case syserr_wins_internal: return (ERROR_WINS_INTERNAL); case syserr_can_not_del_local_wins: return (ERROR_CAN_NOT_DEL_LOCAL_WINS); case syserr_static_init: return (ERROR_STATIC_INIT); case syserr_inc_backup: return (ERROR_INC_BACKUP); case syserr_full_backup: return (ERROR_FULL_BACKUP); case syserr_rec_non_existent: return (ERROR_REC_NON_EXISTENT); case syserr_rpl_not_allowed: return (ERROR_RPL_NOT_ALLOWED); /* Winsock error codes: */ case syserr_wsaeintr: return (WSAEINTR); case syserr_wsaebadf: return (WSAEBADF); case syserr_wsaeacces: return (WSAEACCES); case syserr_wsaefault: return (WSAEFAULT); case syserr_wsaeinval: return (WSAEINVAL); case syserr_wsaemfile: return (WSAEMFILE); case syserr_wsaewouldblock: return (WSAEWOULDBLOCK); case syserr_wsaeinprogress: return (WSAEINPROGRESS); case syserr_wsaealready: return (WSAEALREADY); case syserr_wsaenotsock: return (WSAENOTSOCK); case syserr_wsaedestaddrreq: return (WSAEDESTADDRREQ); case syserr_wsaemsgsize: return (WSAEMSGSIZE); case syserr_wsaeprototype: return (WSAEPROTOTYPE); case syserr_wsaenoprotoopt: return (WSAENOPROTOOPT); case syserr_wsaeprotonosupport: return (WSAEPROTONOSUPPORT); case syserr_wsaesocktnosupport: return (WSAESOCKTNOSUPPORT); case syserr_wsaeopnotsupp: return (WSAEOPNOTSUPP); case syserr_wsaepfnosupport: return (WSAEPFNOSUPPORT); case syserr_wsaeafnosupport: return (WSAEAFNOSUPPORT); case syserr_wsaeaddrinuse: return (WSAEADDRINUSE); case syserr_wsaeaddrnotavail: return (WSAEADDRNOTAVAIL); case syserr_wsaenetdown: return (WSAENETDOWN); case syserr_wsaenetunreach: return (WSAENETUNREACH); case syserr_wsaenetreset: return (WSAENETRESET); case syserr_wsaeconnaborted: return (WSAECONNABORTED); case syserr_wsaeconnreset: return (WSAECONNRESET); case syserr_wsaenobufs: return (WSAENOBUFS); case syserr_wsaeisconn: return (WSAEISCONN); case syserr_wsaenotconn: return (WSAENOTCONN); case syserr_wsaeshutdown: return (WSAESHUTDOWN); case syserr_wsaetoomanyrefs: return (WSAETOOMANYREFS); case syserr_wsaetimedout: return (WSAETIMEDOUT); case syserr_wsaeconnrefused: return (WSAECONNREFUSED); case syserr_wsaeloop: return (WSAELOOP); case syserr_wsaenametoolong: return (WSAENAMETOOLONG); case syserr_wsaehostdown: return (WSAEHOSTDOWN); case syserr_wsaehostunreach: return (WSAEHOSTUNREACH); case syserr_wsaenotempty: return (WSAENOTEMPTY); case syserr_wsaeproclim: return (WSAEPROCLIM); case syserr_wsaeusers: return (WSAEUSERS); case syserr_wsaedquot: return (WSAEDQUOT); case syserr_wsaestale: return (WSAESTALE); case syserr_wsaeremote: return (WSAEREMOTE); case syserr_wsaediscon: return (WSAEDISCON); case syserr_wsasysnotready: return (WSASYSNOTREADY); case syserr_wsavernotsupported: return (WSAVERNOTSUPPORTED); case syserr_wsanotinitialised: return (WSANOTINITIALISED); case syserr_wsahost_not_found: return (WSAHOST_NOT_FOUND); case syserr_wsatry_again: return (WSATRY_AGAIN); case syserr_wsano_recovery: return (WSANO_RECOVERY); case syserr_wsano_data: return (WSANO_DATA); default: return (ERROR_SUCCESS); } } /* Machine-generated procedure, do not edit: */ static enum syserr_names win32_error_code_to_syserr (DWORD code) { switch (code) { case ERROR_SUCCESS: return (syserr_success); case ERROR_INVALID_FUNCTION: return (syserr_invalid_function); case ERROR_FILE_NOT_FOUND: return (syserr_file_not_found); case ERROR_PATH_NOT_FOUND: return (syserr_path_not_found); case ERROR_TOO_MANY_OPEN_FILES: return (syserr_too_many_open_files); case ERROR_ACCESS_DENIED: return (syserr_access_denied); case ERROR_INVALID_HANDLE: return (syserr_invalid_handle); case ERROR_ARENA_TRASHED: return (syserr_arena_trashed); case ERROR_NOT_ENOUGH_MEMORY: return (syserr_not_enough_memory); case ERROR_INVALID_BLOCK: return (syserr_invalid_block); case ERROR_BAD_ENVIRONMENT: return (syserr_bad_environment); case ERROR_BAD_FORMAT: return (syserr_bad_format); case ERROR_INVALID_ACCESS: return (syserr_invalid_access); case ERROR_INVALID_DATA: return (syserr_invalid_data); case ERROR_OUTOFMEMORY: return (syserr_outofmemory); case ERROR_INVALID_DRIVE: return (syserr_invalid_drive); case ERROR_CURRENT_DIRECTORY: return (syserr_current_directory); case ERROR_NOT_SAME_DEVICE: return (syserr_not_same_device); case ERROR_NO_MORE_FILES: return (syserr_no_more_files); case ERROR_WRITE_PROTECT: return (syserr_write_protect); case ERROR_BAD_UNIT: return (syserr_bad_unit); case ERROR_NOT_READY: return (syserr_not_ready); case ERROR_BAD_COMMAND: return (syserr_bad_command); case ERROR_CRC: return (syserr_crc); case ERROR_BAD_LENGTH: return (syserr_bad_length); case ERROR_SEEK: return (syserr_seek); case ERROR_NOT_DOS_DISK: return (syserr_not_dos_disk); case ERROR_SECTOR_NOT_FOUND: return (syserr_sector_not_found); case ERROR_OUT_OF_PAPER: return (syserr_out_of_paper); case ERROR_WRITE_FAULT: return (syserr_write_fault); case ERROR_READ_FAULT: return (syserr_read_fault); case ERROR_GEN_FAILURE: return (syserr_gen_failure); case ERROR_SHARING_VIOLATION: return (syserr_sharing_violation); case ERROR_LOCK_VIOLATION: return (syserr_lock_violation); case ERROR_WRONG_DISK: return (syserr_wrong_disk); case ERROR_SHARING_BUFFER_EXCEEDED: return (syserr_sharing_buffer_exceeded); case ERROR_HANDLE_EOF: return (syserr_handle_eof); case ERROR_HANDLE_DISK_FULL: return (syserr_handle_disk_full); case ERROR_NOT_SUPPORTED: return (syserr_not_supported); case ERROR_REM_NOT_LIST: return (syserr_rem_not_list); case ERROR_DUP_NAME: return (syserr_dup_name); case ERROR_BAD_NETPATH: return (syserr_bad_netpath); case ERROR_NETWORK_BUSY: return (syserr_network_busy); case ERROR_DEV_NOT_EXIST: return (syserr_dev_not_exist); case ERROR_TOO_MANY_CMDS: return (syserr_too_many_cmds); case ERROR_ADAP_HDW_ERR: return (syserr_adap_hdw_err); case ERROR_BAD_NET_RESP: return (syserr_bad_net_resp); case ERROR_UNEXP_NET_ERR: return (syserr_unexp_net_err); case ERROR_BAD_REM_ADAP: return (syserr_bad_rem_adap); case ERROR_PRINTQ_FULL: return (syserr_printq_full); case ERROR_NO_SPOOL_SPACE: return (syserr_no_spool_space); case ERROR_PRINT_CANCELLED: return (syserr_print_cancelled); case ERROR_NETNAME_DELETED: return (syserr_netname_deleted); case ERROR_NETWORK_ACCESS_DENIED: return (syserr_network_access_denied); case ERROR_BAD_DEV_TYPE: return (syserr_bad_dev_type); case ERROR_BAD_NET_NAME: return (syserr_bad_net_name); case ERROR_TOO_MANY_NAMES: return (syserr_too_many_names); case ERROR_TOO_MANY_SESS: return (syserr_too_many_sess); case ERROR_SHARING_PAUSED: return (syserr_sharing_paused); case ERROR_REQ_NOT_ACCEP: return (syserr_req_not_accep); case ERROR_REDIR_PAUSED: return (syserr_redir_paused); case ERROR_FILE_EXISTS: return (syserr_file_exists); case ERROR_CANNOT_MAKE: return (syserr_cannot_make); case ERROR_FAIL_I24: return (syserr_fail_i24); case ERROR_OUT_OF_STRUCTURES: return (syserr_out_of_structures); case ERROR_ALREADY_ASSIGNED: return (syserr_already_assigned); case ERROR_INVALID_PASSWORD: return (syserr_invalid_password); case ERROR_INVALID_PARAMETER: return (syserr_invalid_parameter); case ERROR_NET_WRITE_FAULT: return (syserr_net_write_fault); case ERROR_NO_PROC_SLOTS: return (syserr_no_proc_slots); case ERROR_TOO_MANY_SEMAPHORES: return (syserr_too_many_semaphores); case ERROR_EXCL_SEM_ALREADY_OWNED: return (syserr_excl_sem_already_owned); case ERROR_SEM_IS_SET: return (syserr_sem_is_set); case ERROR_TOO_MANY_SEM_REQUESTS: return (syserr_too_many_sem_requests); case ERROR_INVALID_AT_INTERRUPT_TIME: return (syserr_invalid_at_interrupt_time); case ERROR_SEM_OWNER_DIED: return (syserr_sem_owner_died); case ERROR_SEM_USER_LIMIT: return (syserr_sem_user_limit); case ERROR_DISK_CHANGE: return (syserr_disk_change); case ERROR_DRIVE_LOCKED: return (syserr_drive_locked); case ERROR_BROKEN_PIPE: return (syserr_broken_pipe); case ERROR_OPEN_FAILED: return (syserr_open_failed); case ERROR_BUFFER_OVERFLOW: return (syserr_buffer_overflow); case ERROR_DISK_FULL: return (syserr_disk_full); case ERROR_NO_MORE_SEARCH_HANDLES: return (syserr_no_more_search_handles); case ERROR_INVALID_TARGET_HANDLE: return (syserr_invalid_target_handle); case ERROR_INVALID_CATEGORY: return (syserr_invalid_category); case ERROR_INVALID_VERIFY_SWITCH: return (syserr_invalid_verify_switch); case ERROR_BAD_DRIVER_LEVEL: return (syserr_bad_driver_level); case ERROR_CALL_NOT_IMPLEMENTED: return (syserr_call_not_implemented); case ERROR_SEM_TIMEOUT: return (syserr_sem_timeout); case ERROR_INSUFFICIENT_BUFFER: return (syserr_insufficient_buffer); case ERROR_INVALID_NAME: return (syserr_invalid_name); case ERROR_INVALID_LEVEL: return (syserr_invalid_level); case ERROR_NO_VOLUME_LABEL: return (syserr_no_volume_label); case ERROR_MOD_NOT_FOUND: return (syserr_mod_not_found); case ERROR_PROC_NOT_FOUND: return (syserr_proc_not_found); case ERROR_WAIT_NO_CHILDREN: return (syserr_wait_no_children); case ERROR_CHILD_NOT_COMPLETE: return (syserr_child_not_complete); case ERROR_DIRECT_ACCESS_HANDLE: return (syserr_direct_access_handle); case ERROR_NEGATIVE_SEEK: return (syserr_negative_seek); case ERROR_SEEK_ON_DEVICE: return (syserr_seek_on_device); case ERROR_IS_JOIN_TARGET: return (syserr_is_join_target); case ERROR_IS_JOINED: return (syserr_is_joined); case ERROR_IS_SUBSTED: return (syserr_is_substed); case ERROR_NOT_JOINED: return (syserr_not_joined); case ERROR_NOT_SUBSTED: return (syserr_not_substed); case ERROR_JOIN_TO_JOIN: return (syserr_join_to_join); case ERROR_SUBST_TO_SUBST: return (syserr_subst_to_subst); case ERROR_JOIN_TO_SUBST: return (syserr_join_to_subst); case ERROR_SUBST_TO_JOIN: return (syserr_subst_to_join); case ERROR_BUSY_DRIVE: return (syserr_busy_drive); case ERROR_SAME_DRIVE: return (syserr_same_drive); case ERROR_DIR_NOT_ROOT: return (syserr_dir_not_root); case ERROR_DIR_NOT_EMPTY: return (syserr_dir_not_empty); case ERROR_IS_SUBST_PATH: return (syserr_is_subst_path); case ERROR_IS_JOIN_PATH: return (syserr_is_join_path); case ERROR_PATH_BUSY: return (syserr_path_busy); case ERROR_IS_SUBST_TARGET: return (syserr_is_subst_target); case ERROR_SYSTEM_TRACE: return (syserr_system_trace); case ERROR_INVALID_EVENT_COUNT: return (syserr_invalid_event_count); case ERROR_TOO_MANY_MUXWAITERS: return (syserr_too_many_muxwaiters); case ERROR_INVALID_LIST_FORMAT: return (syserr_invalid_list_format); case ERROR_LABEL_TOO_LONG: return (syserr_label_too_long); case ERROR_TOO_MANY_TCBS: return (syserr_too_many_tcbs); case ERROR_SIGNAL_REFUSED: return (syserr_signal_refused); case ERROR_DISCARDED: return (syserr_discarded); case ERROR_NOT_LOCKED: return (syserr_not_locked); case ERROR_BAD_THREADID_ADDR: return (syserr_bad_threadid_addr); case ERROR_BAD_ARGUMENTS: return (syserr_bad_arguments); case ERROR_BAD_PATHNAME: return (syserr_bad_pathname); case ERROR_SIGNAL_PENDING: return (syserr_signal_pending); case ERROR_MAX_THRDS_REACHED: return (syserr_max_thrds_reached); case ERROR_LOCK_FAILED: return (syserr_lock_failed); case ERROR_BUSY: return (syserr_busy); case ERROR_CANCEL_VIOLATION: return (syserr_cancel_violation); case ERROR_ATOMIC_LOCKS_NOT_SUPPORTED: return (syserr_atomic_locks_not_supported); case ERROR_INVALID_SEGMENT_NUMBER: return (syserr_invalid_segment_number); case ERROR_INVALID_ORDINAL: return (syserr_invalid_ordinal); case ERROR_ALREADY_EXISTS: return (syserr_already_exists); case ERROR_INVALID_FLAG_NUMBER: return (syserr_invalid_flag_number); case ERROR_SEM_NOT_FOUND: return (syserr_sem_not_found); case ERROR_INVALID_STARTING_CODESEG: return (syserr_invalid_starting_codeseg); case ERROR_INVALID_STACKSEG: return (syserr_invalid_stackseg); case ERROR_INVALID_MODULETYPE: return (syserr_invalid_moduletype); case ERROR_INVALID_EXE_SIGNATURE: return (syserr_invalid_exe_signature); case ERROR_EXE_MARKED_INVALID: return (syserr_exe_marked_invalid); case ERROR_BAD_EXE_FORMAT: return (syserr_bad_exe_format); case ERROR_ITERATED_DATA_EXCEEDS_64k: return (syserr_iterated_data_exceeds_64k); case ERROR_INVALID_MINALLOCSIZE: return (syserr_invalid_minallocsize); case ERROR_DYNLINK_FROM_INVALID_RING: return (syserr_dynlink_from_invalid_ring); case ERROR_IOPL_NOT_ENABLED: return (syserr_iopl_not_enabled); case ERROR_INVALID_SEGDPL: return (syserr_invalid_segdpl); case ERROR_AUTODATASEG_EXCEEDS_64k: return (syserr_autodataseg_exceeds_64k); case ERROR_RING2SEG_MUST_BE_MOVABLE: return (syserr_ring2seg_must_be_movable); case ERROR_RELOC_CHAIN_XEEDS_SEGLIM: return (syserr_reloc_chain_xeeds_seglim); case ERROR_INFLOOP_IN_RELOC_CHAIN: return (syserr_infloop_in_reloc_chain); case ERROR_ENVVAR_NOT_FOUND: return (syserr_envvar_not_found); case ERROR_NO_SIGNAL_SENT: return (syserr_no_signal_sent); case ERROR_FILENAME_EXCED_RANGE: return (syserr_filename_exced_range); case ERROR_RING2_STACK_IN_USE: return (syserr_ring2_stack_in_use); case ERROR_META_EXPANSION_TOO_LONG: return (syserr_meta_expansion_too_long); case ERROR_INVALID_SIGNAL_NUMBER: return (syserr_invalid_signal_number); case ERROR_THREAD_1_INACTIVE: return (syserr_thread_1_inactive); case ERROR_LOCKED: return (syserr_locked); case ERROR_TOO_MANY_MODULES: return (syserr_too_many_modules); case ERROR_NESTING_NOT_ALLOWED: return (syserr_nesting_not_allowed); case ERROR_BAD_PIPE: return (syserr_bad_pipe); case ERROR_PIPE_BUSY: return (syserr_pipe_busy); case ERROR_NO_DATA: return (syserr_no_data); case ERROR_PIPE_NOT_CONNECTED: return (syserr_pipe_not_connected); case ERROR_MORE_DATA: return (syserr_more_data); case ERROR_VC_DISCONNECTED: return (syserr_vc_disconnected); case ERROR_INVALID_EA_NAME: return (syserr_invalid_ea_name); case ERROR_EA_LIST_INCONSISTENT: return (syserr_ea_list_inconsistent); case ERROR_NO_MORE_ITEMS: return (syserr_no_more_items); case ERROR_CANNOT_COPY: return (syserr_cannot_copy); case ERROR_DIRECTORY: return (syserr_directory); case ERROR_EAS_DIDNT_FIT: return (syserr_eas_didnt_fit); case ERROR_EA_FILE_CORRUPT: return (syserr_ea_file_corrupt); case ERROR_EA_TABLE_FULL: return (syserr_ea_table_full); case ERROR_INVALID_EA_HANDLE: return (syserr_invalid_ea_handle); case ERROR_EAS_NOT_SUPPORTED: return (syserr_eas_not_supported); case ERROR_NOT_OWNER: return (syserr_not_owner); case ERROR_TOO_MANY_POSTS: return (syserr_too_many_posts); case ERROR_PARTIAL_COPY: return (syserr_partial_copy); case ERROR_MR_MID_NOT_FOUND: return (syserr_mr_mid_not_found); case ERROR_INVALID_ADDRESS: return (syserr_invalid_address); case ERROR_ARITHMETIC_OVERFLOW: return (syserr_arithmetic_overflow); case ERROR_PIPE_CONNECTED: return (syserr_pipe_connected); case ERROR_PIPE_LISTENING: return (syserr_pipe_listening); case ERROR_EA_ACCESS_DENIED: return (syserr_ea_access_denied); case ERROR_OPERATION_ABORTED: return (syserr_operation_aborted); case ERROR_IO_INCOMPLETE: return (syserr_io_incomplete); case ERROR_IO_PENDING: return (syserr_io_pending); case ERROR_NOACCESS: return (syserr_noaccess); case ERROR_SWAPERROR: return (syserr_swaperror); case ERROR_STACK_OVERFLOW: return (syserr_stack_overflow); case ERROR_INVALID_MESSAGE: return (syserr_invalid_message); case ERROR_CAN_NOT_COMPLETE: return (syserr_can_not_complete); case ERROR_INVALID_FLAGS: return (syserr_invalid_flags); case ERROR_UNRECOGNIZED_VOLUME: return (syserr_unrecognized_volume); case ERROR_FILE_INVALID: return (syserr_file_invalid); case ERROR_FULLSCREEN_MODE: return (syserr_fullscreen_mode); case ERROR_NO_TOKEN: return (syserr_no_token); case ERROR_BADDB: return (syserr_baddb); case ERROR_BADKEY: return (syserr_badkey); case ERROR_CANTOPEN: return (syserr_cantopen); case ERROR_CANTREAD: return (syserr_cantread); case ERROR_CANTWRITE: return (syserr_cantwrite); case ERROR_REGISTRY_RECOVERED: return (syserr_registry_recovered); case ERROR_REGISTRY_CORRUPT: return (syserr_registry_corrupt); case ERROR_REGISTRY_IO_FAILED: return (syserr_registry_io_failed); case ERROR_NOT_REGISTRY_FILE: return (syserr_not_registry_file); case ERROR_KEY_DELETED: return (syserr_key_deleted); case ERROR_NO_LOG_SPACE: return (syserr_no_log_space); case ERROR_KEY_HAS_CHILDREN: return (syserr_key_has_children); case ERROR_CHILD_MUST_BE_VOLATILE: return (syserr_child_must_be_volatile); case ERROR_NOTIFY_ENUM_DIR: return (syserr_notify_enum_dir); case ERROR_DEPENDENT_SERVICES_RUNNING: return (syserr_dependent_services_running); case ERROR_INVALID_SERVICE_CONTROL: return (syserr_invalid_service_control); case ERROR_SERVICE_REQUEST_TIMEOUT: return (syserr_service_request_timeout); case ERROR_SERVICE_NO_THREAD: return (syserr_service_no_thread); case ERROR_SERVICE_DATABASE_LOCKED: return (syserr_service_database_locked); case ERROR_SERVICE_ALREADY_RUNNING: return (syserr_service_already_running); case ERROR_INVALID_SERVICE_ACCOUNT: return (syserr_invalid_service_account); case ERROR_SERVICE_DISABLED: return (syserr_service_disabled); case ERROR_CIRCULAR_DEPENDENCY: return (syserr_circular_dependency); case ERROR_SERVICE_DOES_NOT_EXIST: return (syserr_service_does_not_exist); case ERROR_SERVICE_CANNOT_ACCEPT_CTRL: return (syserr_service_cannot_accept_ctrl); case ERROR_SERVICE_NOT_ACTIVE: return (syserr_service_not_active); case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT: return (syserr_failed_service_controller_connect); case ERROR_EXCEPTION_IN_SERVICE: return (syserr_exception_in_service); case ERROR_DATABASE_DOES_NOT_EXIST: return (syserr_database_does_not_exist); case ERROR_SERVICE_SPECIFIC_ERROR: return (syserr_service_specific_error); case ERROR_PROCESS_ABORTED: return (syserr_process_aborted); case ERROR_SERVICE_DEPENDENCY_FAIL: return (syserr_service_dependency_fail); case ERROR_SERVICE_LOGON_FAILED: return (syserr_service_logon_failed); case ERROR_SERVICE_START_HANG: return (syserr_service_start_hang); case ERROR_INVALID_SERVICE_LOCK: return (syserr_invalid_service_lock); case ERROR_SERVICE_MARKED_FOR_DELETE: return (syserr_service_marked_for_delete); case ERROR_SERVICE_EXISTS: return (syserr_service_exists); case ERROR_ALREADY_RUNNING_LKG: return (syserr_already_running_lkg); case ERROR_SERVICE_DEPENDENCY_DELETED: return (syserr_service_dependency_deleted); case ERROR_BOOT_ALREADY_ACCEPTED: return (syserr_boot_already_accepted); case ERROR_SERVICE_NEVER_STARTED: return (syserr_service_never_started); case ERROR_DUPLICATE_SERVICE_NAME: return (syserr_duplicate_service_name); case ERROR_END_OF_MEDIA: return (syserr_end_of_media); case ERROR_FILEMARK_DETECTED: return (syserr_filemark_detected); case ERROR_BEGINNING_OF_MEDIA: return (syserr_beginning_of_media); case ERROR_SETMARK_DETECTED: return (syserr_setmark_detected); case ERROR_NO_DATA_DETECTED: return (syserr_no_data_detected); case ERROR_PARTITION_FAILURE: return (syserr_partition_failure); case ERROR_INVALID_BLOCK_LENGTH: return (syserr_invalid_block_length); case ERROR_DEVICE_NOT_PARTITIONED: return (syserr_device_not_partitioned); case ERROR_UNABLE_TO_LOCK_MEDIA: return (syserr_unable_to_lock_media); case ERROR_UNABLE_TO_UNLOAD_MEDIA: return (syserr_unable_to_unload_media); case ERROR_MEDIA_CHANGED: return (syserr_media_changed); case ERROR_BUS_RESET: return (syserr_bus_reset); case ERROR_NO_MEDIA_IN_DRIVE: return (syserr_no_media_in_drive); case ERROR_NO_UNICODE_TRANSLATION: return (syserr_no_unicode_translation); case ERROR_DLL_INIT_FAILED: return (syserr_dll_init_failed); case ERROR_SHUTDOWN_IN_PROGRESS: return (syserr_shutdown_in_progress); case ERROR_NO_SHUTDOWN_IN_PROGRESS: return (syserr_no_shutdown_in_progress); case ERROR_IO_DEVICE: return (syserr_io_device); case ERROR_SERIAL_NO_DEVICE: return (syserr_serial_no_device); case ERROR_IRQ_BUSY: return (syserr_irq_busy); case ERROR_MORE_WRITES: return (syserr_more_writes); case ERROR_COUNTER_TIMEOUT: return (syserr_counter_timeout); case ERROR_FLOPPY_ID_MARK_NOT_FOUND: return (syserr_floppy_id_mark_not_found); case ERROR_FLOPPY_WRONG_CYLINDER: return (syserr_floppy_wrong_cylinder); case ERROR_FLOPPY_UNKNOWN_ERROR: return (syserr_floppy_unknown_error); case ERROR_FLOPPY_BAD_REGISTERS: return (syserr_floppy_bad_registers); case ERROR_DISK_RECALIBRATE_FAILED: return (syserr_disk_recalibrate_failed); case ERROR_DISK_OPERATION_FAILED: return (syserr_disk_operation_failed); case ERROR_DISK_RESET_FAILED: return (syserr_disk_reset_failed); case ERROR_EOM_OVERFLOW: return (syserr_eom_overflow); case ERROR_NOT_ENOUGH_SERVER_MEMORY: return (syserr_not_enough_server_memory); case ERROR_POSSIBLE_DEADLOCK: return (syserr_possible_deadlock); case ERROR_MAPPED_ALIGNMENT: return (syserr_mapped_alignment); case ERROR_SET_POWER_STATE_VETOED: return (syserr_set_power_state_vetoed); case ERROR_SET_POWER_STATE_FAILED: return (syserr_set_power_state_failed); case ERROR_OLD_WIN_VERSION: return (syserr_old_win_version); case ERROR_APP_WRONG_OS: return (syserr_app_wrong_os); case ERROR_SINGLE_INSTANCE_APP: return (syserr_single_instance_app); case ERROR_RMODE_APP: return (syserr_rmode_app); case ERROR_INVALID_DLL: return (syserr_invalid_dll); case ERROR_NO_ASSOCIATION: return (syserr_no_association); case ERROR_DDE_FAIL: return (syserr_dde_fail); case ERROR_DLL_NOT_FOUND: return (syserr_dll_not_found); case ERROR_BAD_USERNAME: return (syserr_bad_username); case ERROR_NOT_CONNECTED: return (syserr_not_connected); case ERROR_OPEN_FILES: return (syserr_open_files); case ERROR_ACTIVE_CONNECTIONS: return (syserr_active_connections); case ERROR_DEVICE_IN_USE: return (syserr_device_in_use); case ERROR_BAD_DEVICE: return (syserr_bad_device); case ERROR_CONNECTION_UNAVAIL: return (syserr_connection_unavail); case ERROR_DEVICE_ALREADY_REMEMBERED: return (syserr_device_already_remembered); case ERROR_NO_NET_OR_BAD_PATH: return (syserr_no_net_or_bad_path); case ERROR_BAD_PROVIDER: return (syserr_bad_provider); case ERROR_CANNOT_OPEN_PROFILE: return (syserr_cannot_open_profile); case ERROR_BAD_PROFILE: return (syserr_bad_profile); case ERROR_NOT_CONTAINER: return (syserr_not_container); case ERROR_EXTENDED_ERROR: return (syserr_extended_error); case ERROR_INVALID_GROUPNAME: return (syserr_invalid_groupname); case ERROR_INVALID_COMPUTERNAME: return (syserr_invalid_computername); case ERROR_INVALID_EVENTNAME: return (syserr_invalid_eventname); case ERROR_INVALID_DOMAINNAME: return (syserr_invalid_domainname); case ERROR_INVALID_SERVICENAME: return (syserr_invalid_servicename); case ERROR_INVALID_NETNAME: return (syserr_invalid_netname); case ERROR_INVALID_SHARENAME: return (syserr_invalid_sharename); case ERROR_INVALID_PASSWORDNAME: return (syserr_invalid_passwordname); case ERROR_INVALID_MESSAGENAME: return (syserr_invalid_messagename); case ERROR_INVALID_MESSAGEDEST: return (syserr_invalid_messagedest); case ERROR_SESSION_CREDENTIAL_CONFLICT: return (syserr_session_credential_conflict); case ERROR_REMOTE_SESSION_LIMIT_EXCEEDED: return (syserr_remote_session_limit_exceeded); case ERROR_DUP_DOMAINNAME: return (syserr_dup_domainname); case ERROR_NO_NETWORK: return (syserr_no_network); case ERROR_CANCELLED: return (syserr_cancelled); case ERROR_USER_MAPPED_FILE: return (syserr_user_mapped_file); case ERROR_CONNECTION_REFUSED: return (syserr_connection_refused); case ERROR_GRACEFUL_DISCONNECT: return (syserr_graceful_disconnect); case ERROR_ADDRESS_ALREADY_ASSOCIATED: return (syserr_address_already_associated); case ERROR_ADDRESS_NOT_ASSOCIATED: return (syserr_address_not_associated); case ERROR_CONNECTION_INVALID: return (syserr_connection_invalid); case ERROR_CONNECTION_ACTIVE: return (syserr_connection_active); case ERROR_NETWORK_UNREACHABLE: return (syserr_network_unreachable); case ERROR_HOST_UNREACHABLE: return (syserr_host_unreachable); case ERROR_PROTOCOL_UNREACHABLE: return (syserr_protocol_unreachable); case ERROR_PORT_UNREACHABLE: return (syserr_port_unreachable); case ERROR_REQUEST_ABORTED: return (syserr_request_aborted); case ERROR_CONNECTION_ABORTED: return (syserr_connection_aborted); case ERROR_RETRY: return (syserr_retry); case ERROR_CONNECTION_COUNT_LIMIT: return (syserr_connection_count_limit); case ERROR_LOGIN_TIME_RESTRICTION: return (syserr_login_time_restriction); case ERROR_LOGIN_WKSTA_RESTRICTION: return (syserr_login_wksta_restriction); case ERROR_INCORRECT_ADDRESS: return (syserr_incorrect_address); case ERROR_ALREADY_REGISTERED: return (syserr_already_registered); case ERROR_SERVICE_NOT_FOUND: return (syserr_service_not_found); case ERROR_NOT_AUTHENTICATED: return (syserr_not_authenticated); case ERROR_NOT_LOGGED_ON: return (syserr_not_logged_on); case ERROR_CONTINUE: return (syserr_continue); case ERROR_ALREADY_INITIALIZED: return (syserr_already_initialized); case ERROR_NO_MORE_DEVICES: return (syserr_no_more_devices); case ERROR_NOT_ALL_ASSIGNED: return (syserr_not_all_assigned); case ERROR_SOME_NOT_MAPPED: return (syserr_some_not_mapped); case ERROR_NO_QUOTAS_FOR_ACCOUNT: return (syserr_no_quotas_for_account); case ERROR_LOCAL_USER_SESSION_KEY: return (syserr_local_user_session_key); case ERROR_NULL_LM_PASSWORD: return (syserr_null_lm_password); case ERROR_UNKNOWN_REVISION: return (syserr_unknown_revision); case ERROR_REVISION_MISMATCH: return (syserr_revision_mismatch); case ERROR_INVALID_OWNER: return (syserr_invalid_owner); case ERROR_INVALID_PRIMARY_GROUP: return (syserr_invalid_primary_group); case ERROR_NO_IMPERSONATION_TOKEN: return (syserr_no_impersonation_token); case ERROR_CANT_DISABLE_MANDATORY: return (syserr_cant_disable_mandatory); case ERROR_NO_LOGON_SERVERS: return (syserr_no_logon_servers); case ERROR_NO_SUCH_LOGON_SESSION: return (syserr_no_such_logon_session); case ERROR_NO_SUCH_PRIVILEGE: return (syserr_no_such_privilege); case ERROR_PRIVILEGE_NOT_HELD: return (syserr_privilege_not_held); case ERROR_INVALID_ACCOUNT_NAME: return (syserr_invalid_account_name); case ERROR_USER_EXISTS: return (syserr_user_exists); case ERROR_NO_SUCH_USER: return (syserr_no_such_user); case ERROR_GROUP_EXISTS: return (syserr_group_exists); case ERROR_NO_SUCH_GROUP: return (syserr_no_such_group); case ERROR_MEMBER_IN_GROUP: return (syserr_member_in_group); case ERROR_MEMBER_NOT_IN_GROUP: return (syserr_member_not_in_group); case ERROR_LAST_ADMIN: return (syserr_last_admin); case ERROR_WRONG_PASSWORD: return (syserr_wrong_password); case ERROR_ILL_FORMED_PASSWORD: return (syserr_ill_formed_password); case ERROR_PASSWORD_RESTRICTION: return (syserr_password_restriction); case ERROR_LOGON_FAILURE: return (syserr_logon_failure); case ERROR_ACCOUNT_RESTRICTION: return (syserr_account_restriction); case ERROR_INVALID_LOGON_HOURS: return (syserr_invalid_logon_hours); case ERROR_INVALID_WORKSTATION: return (syserr_invalid_workstation); case ERROR_PASSWORD_EXPIRED: return (syserr_password_expired); case ERROR_ACCOUNT_DISABLED: return (syserr_account_disabled); case ERROR_NONE_MAPPED: return (syserr_none_mapped); case ERROR_TOO_MANY_LUIDS_REQUESTED: return (syserr_too_many_luids_requested); case ERROR_LUIDS_EXHAUSTED: return (syserr_luids_exhausted); case ERROR_INVALID_SUB_AUTHORITY: return (syserr_invalid_sub_authority); case ERROR_INVALID_ACL: return (syserr_invalid_acl); case ERROR_INVALID_SID: return (syserr_invalid_sid); case ERROR_INVALID_SECURITY_DESCR: return (syserr_invalid_security_descr); case ERROR_BAD_INHERITANCE_ACL: return (syserr_bad_inheritance_acl); case ERROR_SERVER_DISABLED: return (syserr_server_disabled); case ERROR_SERVER_NOT_DISABLED: return (syserr_server_not_disabled); case ERROR_INVALID_ID_AUTHORITY: return (syserr_invalid_id_authority); case ERROR_ALLOTTED_SPACE_EXCEEDED: return (syserr_allotted_space_exceeded); case ERROR_INVALID_GROUP_ATTRIBUTES: return (syserr_invalid_group_attributes); case ERROR_BAD_IMPERSONATION_LEVEL: return (syserr_bad_impersonation_level); case ERROR_CANT_OPEN_ANONYMOUS: return (syserr_cant_open_anonymous); case ERROR_BAD_VALIDATION_CLASS: return (syserr_bad_validation_class); case ERROR_BAD_TOKEN_TYPE: return (syserr_bad_token_type); case ERROR_NO_SECURITY_ON_OBJECT: return (syserr_no_security_on_object); case ERROR_CANT_ACCESS_DOMAIN_INFO: return (syserr_cant_access_domain_info); case ERROR_INVALID_SERVER_STATE: return (syserr_invalid_server_state); case ERROR_INVALID_DOMAIN_STATE: return (syserr_invalid_domain_state); case ERROR_INVALID_DOMAIN_ROLE: return (syserr_invalid_domain_role); case ERROR_NO_SUCH_DOMAIN: return (syserr_no_such_domain); case ERROR_DOMAIN_EXISTS: return (syserr_domain_exists); case ERROR_DOMAIN_LIMIT_EXCEEDED: return (syserr_domain_limit_exceeded); case ERROR_INTERNAL_DB_CORRUPTION: return (syserr_internal_db_corruption); case ERROR_INTERNAL_ERROR: return (syserr_internal_error); case ERROR_GENERIC_NOT_MAPPED: return (syserr_generic_not_mapped); case ERROR_BAD_DESCRIPTOR_FORMAT: return (syserr_bad_descriptor_format); case ERROR_NOT_LOGON_PROCESS: return (syserr_not_logon_process); case ERROR_LOGON_SESSION_EXISTS: return (syserr_logon_session_exists); case ERROR_NO_SUCH_PACKAGE: return (syserr_no_such_package); case ERROR_BAD_LOGON_SESSION_STATE: return (syserr_bad_logon_session_state); case ERROR_LOGON_SESSION_COLLISION: return (syserr_logon_session_collision); case ERROR_INVALID_LOGON_TYPE: return (syserr_invalid_logon_type); case ERROR_CANNOT_IMPERSONATE: return (syserr_cannot_impersonate); case ERROR_RXACT_INVALID_STATE: return (syserr_rxact_invalid_state); case ERROR_RXACT_COMMIT_FAILURE: return (syserr_rxact_commit_failure); case ERROR_SPECIAL_ACCOUNT: return (syserr_special_account); case ERROR_SPECIAL_GROUP: return (syserr_special_group); case ERROR_SPECIAL_USER: return (syserr_special_user); case ERROR_MEMBERS_PRIMARY_GROUP: return (syserr_members_primary_group); case ERROR_TOKEN_ALREADY_IN_USE: return (syserr_token_already_in_use); case ERROR_NO_SUCH_ALIAS: return (syserr_no_such_alias); case ERROR_MEMBER_NOT_IN_ALIAS: return (syserr_member_not_in_alias); case ERROR_MEMBER_IN_ALIAS: return (syserr_member_in_alias); case ERROR_ALIAS_EXISTS: return (syserr_alias_exists); case ERROR_LOGON_NOT_GRANTED: return (syserr_logon_not_granted); case ERROR_TOO_MANY_SECRETS: return (syserr_too_many_secrets); case ERROR_SECRET_TOO_LONG: return (syserr_secret_too_long); case ERROR_INTERNAL_DB_ERROR: return (syserr_internal_db_error); case ERROR_TOO_MANY_CONTEXT_IDS: return (syserr_too_many_context_ids); case ERROR_LOGON_TYPE_NOT_GRANTED: return (syserr_logon_type_not_granted); case ERROR_NT_CROSS_ENCRYPTION_REQUIRED: return (syserr_nt_cross_encryption_required); case ERROR_NO_SUCH_MEMBER: return (syserr_no_such_member); case ERROR_INVALID_MEMBER: return (syserr_invalid_member); case ERROR_TOO_MANY_SIDS: return (syserr_too_many_sids); case ERROR_LM_CROSS_ENCRYPTION_REQUIRED: return (syserr_lm_cross_encryption_required); case ERROR_NO_INHERITANCE: return (syserr_no_inheritance); case ERROR_FILE_CORRUPT: return (syserr_file_corrupt); case ERROR_DISK_CORRUPT: return (syserr_disk_corrupt); case ERROR_NO_USER_SESSION_KEY: return (syserr_no_user_session_key); case ERROR_LICENSE_QUOTA_EXCEEDED: return (syserr_license_quota_exceeded); case ERROR_INVALID_WINDOW_HANDLE: return (syserr_invalid_window_handle); case ERROR_INVALID_MENU_HANDLE: return (syserr_invalid_menu_handle); case ERROR_INVALID_CURSOR_HANDLE: return (syserr_invalid_cursor_handle); case ERROR_INVALID_ACCEL_HANDLE: return (syserr_invalid_accel_handle); case ERROR_INVALID_HOOK_HANDLE: return (syserr_invalid_hook_handle); case ERROR_INVALID_DWP_HANDLE: return (syserr_invalid_dwp_handle); case ERROR_TLW_WITH_WSCHILD: return (syserr_tlw_with_wschild); case ERROR_CANNOT_FIND_WND_CLASS: return (syserr_cannot_find_wnd_class); case ERROR_WINDOW_OF_OTHER_THREAD: return (syserr_window_of_other_thread); case ERROR_HOTKEY_ALREADY_REGISTERED: return (syserr_hotkey_already_registered); case ERROR_CLASS_ALREADY_EXISTS: return (syserr_class_already_exists); case ERROR_CLASS_DOES_NOT_EXIST: return (syserr_class_does_not_exist); case ERROR_CLASS_HAS_WINDOWS: return (syserr_class_has_windows); case ERROR_INVALID_INDEX: return (syserr_invalid_index); case ERROR_INVALID_ICON_HANDLE: return (syserr_invalid_icon_handle); case ERROR_PRIVATE_DIALOG_INDEX: return (syserr_private_dialog_index); case ERROR_LISTBOX_ID_NOT_FOUND: return (syserr_listbox_id_not_found); case ERROR_NO_WILDCARD_CHARACTERS: return (syserr_no_wildcard_characters); case ERROR_CLIPBOARD_NOT_OPEN: return (syserr_clipboard_not_open); case ERROR_HOTKEY_NOT_REGISTERED: return (syserr_hotkey_not_registered); case ERROR_WINDOW_NOT_DIALOG: return (syserr_window_not_dialog); case ERROR_CONTROL_ID_NOT_FOUND: return (syserr_control_id_not_found); case ERROR_INVALID_COMBOBOX_MESSAGE: return (syserr_invalid_combobox_message); case ERROR_WINDOW_NOT_COMBOBOX: return (syserr_window_not_combobox); case ERROR_INVALID_EDIT_HEIGHT: return (syserr_invalid_edit_height); case ERROR_DC_NOT_FOUND: return (syserr_dc_not_found); case ERROR_INVALID_HOOK_FILTER: return (syserr_invalid_hook_filter); case ERROR_INVALID_FILTER_PROC: return (syserr_invalid_filter_proc); case ERROR_HOOK_NEEDS_HMOD: return (syserr_hook_needs_hmod); case ERROR_GLOBAL_ONLY_HOOK: return (syserr_global_only_hook); case ERROR_JOURNAL_HOOK_SET: return (syserr_journal_hook_set); case ERROR_HOOK_NOT_INSTALLED: return (syserr_hook_not_installed); case ERROR_INVALID_LB_MESSAGE: return (syserr_invalid_lb_message); case ERROR_SETCOUNT_ON_BAD_LB: return (syserr_setcount_on_bad_lb); case ERROR_LB_WITHOUT_TABSTOPS: return (syserr_lb_without_tabstops); case ERROR_DESTROY_OBJECT_OF_OTHER_THREAD: return (syserr_destroy_object_of_other_thread); case ERROR_CHILD_WINDOW_MENU: return (syserr_child_window_menu); case ERROR_NO_SYSTEM_MENU: return (syserr_no_system_menu); case ERROR_INVALID_MSGBOX_STYLE: return (syserr_invalid_msgbox_style); case ERROR_INVALID_SPI_VALUE: return (syserr_invalid_spi_value); case ERROR_SCREEN_ALREADY_LOCKED: return (syserr_screen_already_locked); case ERROR_HWNDS_HAVE_DIFF_PARENT: return (syserr_hwnds_have_diff_parent); case ERROR_NOT_CHILD_WINDOW: return (syserr_not_child_window); case ERROR_INVALID_GW_COMMAND: return (syserr_invalid_gw_command); case ERROR_INVALID_THREAD_ID: return (syserr_invalid_thread_id); case ERROR_NON_MDICHILD_WINDOW: return (syserr_non_mdichild_window); case ERROR_POPUP_ALREADY_ACTIVE: return (syserr_popup_already_active); case ERROR_NO_SCROLLBARS: return (syserr_no_scrollbars); case ERROR_INVALID_SCROLLBAR_RANGE: return (syserr_invalid_scrollbar_range); case ERROR_INVALID_SHOWWIN_COMMAND: return (syserr_invalid_showwin_command); case ERROR_NO_SYSTEM_RESOURCES: return (syserr_no_system_resources); case ERROR_NONPAGED_SYSTEM_RESOURCES: return (syserr_nonpaged_system_resources); case ERROR_PAGED_SYSTEM_RESOURCES: return (syserr_paged_system_resources); case ERROR_WORKING_SET_QUOTA: return (syserr_working_set_quota); case ERROR_PAGEFILE_QUOTA: return (syserr_pagefile_quota); case ERROR_COMMITMENT_LIMIT: return (syserr_commitment_limit); case ERROR_MENU_ITEM_NOT_FOUND: return (syserr_menu_item_not_found); case ERROR_EVENTLOG_FILE_CORRUPT: return (syserr_eventlog_file_corrupt); case ERROR_EVENTLOG_CANT_START: return (syserr_eventlog_cant_start); case ERROR_LOG_FILE_FULL: return (syserr_log_file_full); case ERROR_EVENTLOG_FILE_CHANGED: return (syserr_eventlog_file_changed); case RPC_S_INVALID_STRING_BINDING: return (syserr_rpc_s_invalid_string_binding); case RPC_S_WRONG_KIND_OF_BINDING: return (syserr_rpc_s_wrong_kind_of_binding); case RPC_S_INVALID_BINDING: return (syserr_rpc_s_invalid_binding); case RPC_S_PROTSEQ_NOT_SUPPORTED: return (syserr_rpc_s_protseq_not_supported); case RPC_S_INVALID_RPC_PROTSEQ: return (syserr_rpc_s_invalid_rpc_protseq); case RPC_S_INVALID_STRING_UUID: return (syserr_rpc_s_invalid_string_uuid); case RPC_S_INVALID_ENDPOINT_FORMAT: return (syserr_rpc_s_invalid_endpoint_format); case RPC_S_INVALID_NET_ADDR: return (syserr_rpc_s_invalid_net_addr); case RPC_S_NO_ENDPOINT_FOUND: return (syserr_rpc_s_no_endpoint_found); case RPC_S_INVALID_TIMEOUT: return (syserr_rpc_s_invalid_timeout); case RPC_S_OBJECT_NOT_FOUND: return (syserr_rpc_s_object_not_found); case RPC_S_ALREADY_REGISTERED: return (syserr_rpc_s_already_registered); case RPC_S_TYPE_ALREADY_REGISTERED: return (syserr_rpc_s_type_already_registered); case RPC_S_ALREADY_LISTENING: return (syserr_rpc_s_already_listening); case RPC_S_NO_PROTSEQS_REGISTERED: return (syserr_rpc_s_no_protseqs_registered); case RPC_S_NOT_LISTENING: return (syserr_rpc_s_not_listening); case RPC_S_UNKNOWN_MGR_TYPE: return (syserr_rpc_s_unknown_mgr_type); case RPC_S_UNKNOWN_IF: return (syserr_rpc_s_unknown_if); case RPC_S_NO_BINDINGS: return (syserr_rpc_s_no_bindings); case RPC_S_NO_PROTSEQS: return (syserr_rpc_s_no_protseqs); case RPC_S_CANT_CREATE_ENDPOINT: return (syserr_rpc_s_cant_create_endpoint); case RPC_S_OUT_OF_RESOURCES: return (syserr_rpc_s_out_of_resources); case RPC_S_SERVER_UNAVAILABLE: return (syserr_rpc_s_server_unavailable); case RPC_S_SERVER_TOO_BUSY: return (syserr_rpc_s_server_too_busy); case RPC_S_INVALID_NETWORK_OPTIONS: return (syserr_rpc_s_invalid_network_options); case RPC_S_NO_CALL_ACTIVE: return (syserr_rpc_s_no_call_active); case RPC_S_CALL_FAILED: return (syserr_rpc_s_call_failed); case RPC_S_CALL_FAILED_DNE: return (syserr_rpc_s_call_failed_dne); case RPC_S_PROTOCOL_ERROR: return (syserr_rpc_s_protocol_error); case RPC_S_UNSUPPORTED_TRANS_SYN: return (syserr_rpc_s_unsupported_trans_syn); case RPC_S_UNSUPPORTED_TYPE: return (syserr_rpc_s_unsupported_type); case RPC_S_INVALID_TAG: return (syserr_rpc_s_invalid_tag); case RPC_S_INVALID_BOUND: return (syserr_rpc_s_invalid_bound); case RPC_S_NO_ENTRY_NAME: return (syserr_rpc_s_no_entry_name); case RPC_S_INVALID_NAME_SYNTAX: return (syserr_rpc_s_invalid_name_syntax); case RPC_S_UNSUPPORTED_NAME_SYNTAX: return (syserr_rpc_s_unsupported_name_syntax); case RPC_S_UUID_NO_ADDRESS: return (syserr_rpc_s_uuid_no_address); case RPC_S_DUPLICATE_ENDPOINT: return (syserr_rpc_s_duplicate_endpoint); case RPC_S_UNKNOWN_AUTHN_TYPE: return (syserr_rpc_s_unknown_authn_type); case RPC_S_MAX_CALLS_TOO_SMALL: return (syserr_rpc_s_max_calls_too_small); case RPC_S_STRING_TOO_LONG: return (syserr_rpc_s_string_too_long); case RPC_S_PROTSEQ_NOT_FOUND: return (syserr_rpc_s_protseq_not_found); case RPC_S_PROCNUM_OUT_OF_RANGE: return (syserr_rpc_s_procnum_out_of_range); case RPC_S_BINDING_HAS_NO_AUTH: return (syserr_rpc_s_binding_has_no_auth); case RPC_S_UNKNOWN_AUTHN_SERVICE: return (syserr_rpc_s_unknown_authn_service); case RPC_S_UNKNOWN_AUTHN_LEVEL: return (syserr_rpc_s_unknown_authn_level); case RPC_S_INVALID_AUTH_IDENTITY: return (syserr_rpc_s_invalid_auth_identity); case RPC_S_UNKNOWN_AUTHZ_SERVICE: return (syserr_rpc_s_unknown_authz_service); case EPT_S_INVALID_ENTRY: return (syserr_ept_s_invalid_entry); case EPT_S_CANT_PERFORM_OP: return (syserr_ept_s_cant_perform_op); case EPT_S_NOT_REGISTERED: return (syserr_ept_s_not_registered); case RPC_S_NOTHING_TO_EXPORT: return (syserr_rpc_s_nothing_to_export); case RPC_S_INCOMPLETE_NAME: return (syserr_rpc_s_incomplete_name); case RPC_S_INVALID_VERS_OPTION: return (syserr_rpc_s_invalid_vers_option); case RPC_S_NO_MORE_MEMBERS: return (syserr_rpc_s_no_more_members); case RPC_S_NOT_ALL_OBJS_UNEXPORTED: return (syserr_rpc_s_not_all_objs_unexported); case RPC_S_INTERFACE_NOT_FOUND: return (syserr_rpc_s_interface_not_found); case RPC_S_ENTRY_ALREADY_EXISTS: return (syserr_rpc_s_entry_already_exists); case RPC_S_ENTRY_NOT_FOUND: return (syserr_rpc_s_entry_not_found); case RPC_S_NAME_SERVICE_UNAVAILABLE: return (syserr_rpc_s_name_service_unavailable); case RPC_S_INVALID_NAF_ID: return (syserr_rpc_s_invalid_naf_id); case RPC_S_CANNOT_SUPPORT: return (syserr_rpc_s_cannot_support); case RPC_S_NO_CONTEXT_AVAILABLE: return (syserr_rpc_s_no_context_available); case RPC_S_INTERNAL_ERROR: return (syserr_rpc_s_internal_error); case RPC_S_ZERO_DIVIDE: return (syserr_rpc_s_zero_divide); case RPC_S_ADDRESS_ERROR: return (syserr_rpc_s_address_error); case RPC_S_FP_DIV_ZERO: return (syserr_rpc_s_fp_div_zero); case RPC_S_FP_UNDERFLOW: return (syserr_rpc_s_fp_underflow); case RPC_S_FP_OVERFLOW: return (syserr_rpc_s_fp_overflow); case RPC_X_NO_MORE_ENTRIES: return (syserr_rpc_x_no_more_entries); case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: return (syserr_rpc_x_ss_char_trans_open_fail); case RPC_X_SS_CHAR_TRANS_SHORT_FILE: return (syserr_rpc_x_ss_char_trans_short_file); case RPC_X_SS_IN_NULL_CONTEXT: return (syserr_rpc_x_ss_in_null_context); case RPC_X_SS_CONTEXT_DAMAGED: return (syserr_rpc_x_ss_context_damaged); case RPC_X_SS_HANDLES_MISMATCH: return (syserr_rpc_x_ss_handles_mismatch); case RPC_X_SS_CANNOT_GET_CALL_HANDLE: return (syserr_rpc_x_ss_cannot_get_call_handle); case RPC_X_NULL_REF_POINTER: return (syserr_rpc_x_null_ref_pointer); case RPC_X_ENUM_VALUE_OUT_OF_RANGE: return (syserr_rpc_x_enum_value_out_of_range); case RPC_X_BYTE_COUNT_TOO_SMALL: return (syserr_rpc_x_byte_count_too_small); case RPC_X_BAD_STUB_DATA: return (syserr_rpc_x_bad_stub_data); case ERROR_INVALID_USER_BUFFER: return (syserr_invalid_user_buffer); case ERROR_UNRECOGNIZED_MEDIA: return (syserr_unrecognized_media); case ERROR_NO_TRUST_LSA_SECRET: return (syserr_no_trust_lsa_secret); case ERROR_NO_TRUST_SAM_ACCOUNT: return (syserr_no_trust_sam_account); case ERROR_TRUSTED_DOMAIN_FAILURE: return (syserr_trusted_domain_failure); case ERROR_TRUSTED_RELATIONSHIP_FAILURE: return (syserr_trusted_relationship_failure); case ERROR_TRUST_FAILURE: return (syserr_trust_failure); case RPC_S_CALL_IN_PROGRESS: return (syserr_rpc_s_call_in_progress); case ERROR_NETLOGON_NOT_STARTED: return (syserr_netlogon_not_started); case ERROR_ACCOUNT_EXPIRED: return (syserr_account_expired); case ERROR_REDIRECTOR_HAS_OPEN_HANDLES: return (syserr_redirector_has_open_handles); case ERROR_PRINTER_DRIVER_ALREADY_INSTALLED: return (syserr_printer_driver_already_installed); case ERROR_UNKNOWN_PORT: return (syserr_unknown_port); case ERROR_UNKNOWN_PRINTER_DRIVER: return (syserr_unknown_printer_driver); case ERROR_UNKNOWN_PRINTPROCESSOR: return (syserr_unknown_printprocessor); case ERROR_INVALID_SEPARATOR_FILE: return (syserr_invalid_separator_file); case ERROR_INVALID_PRIORITY: return (syserr_invalid_priority); case ERROR_INVALID_PRINTER_NAME: return (syserr_invalid_printer_name); case ERROR_PRINTER_ALREADY_EXISTS: return (syserr_printer_already_exists); case ERROR_INVALID_PRINTER_COMMAND: return (syserr_invalid_printer_command); case ERROR_INVALID_DATATYPE: return (syserr_invalid_datatype); case ERROR_INVALID_ENVIRONMENT: return (syserr_invalid_environment); case RPC_S_NO_MORE_BINDINGS: return (syserr_rpc_s_no_more_bindings); case ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: return (syserr_nologon_interdomain_trust_account); case ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT: return (syserr_nologon_workstation_trust_account); case ERROR_NOLOGON_SERVER_TRUST_ACCOUNT: return (syserr_nologon_server_trust_account); case ERROR_DOMAIN_TRUST_INCONSISTENT: return (syserr_domain_trust_inconsistent); case ERROR_SERVER_HAS_OPEN_HANDLES: return (syserr_server_has_open_handles); case ERROR_RESOURCE_DATA_NOT_FOUND: return (syserr_resource_data_not_found); case ERROR_RESOURCE_TYPE_NOT_FOUND: return (syserr_resource_type_not_found); case ERROR_RESOURCE_NAME_NOT_FOUND: return (syserr_resource_name_not_found); case ERROR_RESOURCE_LANG_NOT_FOUND: return (syserr_resource_lang_not_found); case ERROR_NOT_ENOUGH_QUOTA: return (syserr_not_enough_quota); case RPC_S_NO_INTERFACES: return (syserr_rpc_s_no_interfaces); case RPC_S_CALL_CANCELLED: return (syserr_rpc_s_call_cancelled); case RPC_S_BINDING_INCOMPLETE: return (syserr_rpc_s_binding_incomplete); case RPC_S_COMM_FAILURE: return (syserr_rpc_s_comm_failure); case RPC_S_UNSUPPORTED_AUTHN_LEVEL: return (syserr_rpc_s_unsupported_authn_level); case RPC_S_NO_PRINC_NAME: return (syserr_rpc_s_no_princ_name); case RPC_S_NOT_RPC_ERROR: return (syserr_rpc_s_not_rpc_error); case RPC_S_UUID_LOCAL_ONLY: return (syserr_rpc_s_uuid_local_only); case RPC_S_SEC_PKG_ERROR: return (syserr_rpc_s_sec_pkg_error); case RPC_S_NOT_CANCELLED: return (syserr_rpc_s_not_cancelled); case RPC_X_INVALID_ES_ACTION: return (syserr_rpc_x_invalid_es_action); case RPC_X_WRONG_ES_VERSION: return (syserr_rpc_x_wrong_es_version); case RPC_X_WRONG_STUB_VERSION: return (syserr_rpc_x_wrong_stub_version); case RPC_S_GROUP_MEMBER_NOT_FOUND: return (syserr_rpc_s_group_member_not_found); case EPT_S_CANT_CREATE: return (syserr_ept_s_cant_create); case RPC_S_INVALID_OBJECT: return (syserr_rpc_s_invalid_object); case ERROR_INVALID_TIME: return (syserr_invalid_time); case ERROR_INVALID_FORM_NAME: return (syserr_invalid_form_name); case ERROR_INVALID_FORM_SIZE: return (syserr_invalid_form_size); case ERROR_ALREADY_WAITING: return (syserr_already_waiting); case ERROR_PRINTER_DELETED: return (syserr_printer_deleted); case ERROR_INVALID_PRINTER_STATE: return (syserr_invalid_printer_state); case ERROR_PASSWORD_MUST_CHANGE: return (syserr_password_must_change); case ERROR_DOMAIN_CONTROLLER_NOT_FOUND: return (syserr_domain_controller_not_found); case ERROR_ACCOUNT_LOCKED_OUT: return (syserr_account_locked_out); case ERROR_NO_BROWSER_SERVERS_FOUND: return (syserr_no_browser_servers_found); case ERROR_INVALID_PIXEL_FORMAT: return (syserr_invalid_pixel_format); case ERROR_BAD_DRIVER: return (syserr_bad_driver); case ERROR_INVALID_WINDOW_STYLE: return (syserr_invalid_window_style); case ERROR_METAFILE_NOT_SUPPORTED: return (syserr_metafile_not_supported); case ERROR_TRANSFORM_NOT_SUPPORTED: return (syserr_transform_not_supported); case ERROR_CLIPPING_NOT_SUPPORTED: return (syserr_clipping_not_supported); case ERROR_UNKNOWN_PRINT_MONITOR: return (syserr_unknown_print_monitor); case ERROR_PRINTER_DRIVER_IN_USE: return (syserr_printer_driver_in_use); case ERROR_SPOOL_FILE_NOT_FOUND: return (syserr_spool_file_not_found); case ERROR_SPL_NO_STARTDOC: return (syserr_spl_no_startdoc); case ERROR_SPL_NO_ADDJOB: return (syserr_spl_no_addjob); case ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED: return (syserr_print_processor_already_installed); case ERROR_PRINT_MONITOR_ALREADY_INSTALLED: return (syserr_print_monitor_already_installed); case ERROR_WINS_INTERNAL: return (syserr_wins_internal); case ERROR_CAN_NOT_DEL_LOCAL_WINS: return (syserr_can_not_del_local_wins); case ERROR_STATIC_INIT: return (syserr_static_init); case ERROR_INC_BACKUP: return (syserr_inc_backup); case ERROR_FULL_BACKUP: return (syserr_full_backup); case ERROR_REC_NON_EXISTENT: return (syserr_rec_non_existent); case ERROR_RPL_NOT_ALLOWED: return (syserr_rpl_not_allowed); /* Winsock error codes: */ case WSAEINTR: return (syserr_wsaeintr); case WSAEBADF: return (syserr_wsaebadf); case WSAEACCES: return (syserr_wsaeacces); case WSAEFAULT: return (syserr_wsaefault); case WSAEINVAL: return (syserr_wsaeinval); case WSAEMFILE: return (syserr_wsaemfile); case WSAEWOULDBLOCK: return (syserr_wsaewouldblock); case WSAEINPROGRESS: return (syserr_wsaeinprogress); case WSAEALREADY: return (syserr_wsaealready); case WSAENOTSOCK: return (syserr_wsaenotsock); case WSAEDESTADDRREQ: return (syserr_wsaedestaddrreq); case WSAEMSGSIZE: return (syserr_wsaemsgsize); case WSAEPROTOTYPE: return (syserr_wsaeprototype); case WSAENOPROTOOPT: return (syserr_wsaenoprotoopt); case WSAEPROTONOSUPPORT: return (syserr_wsaeprotonosupport); case WSAESOCKTNOSUPPORT: return (syserr_wsaesocktnosupport); case WSAEOPNOTSUPP: return (syserr_wsaeopnotsupp); case WSAEPFNOSUPPORT: return (syserr_wsaepfnosupport); case WSAEAFNOSUPPORT: return (syserr_wsaeafnosupport); case WSAEADDRINUSE: return (syserr_wsaeaddrinuse); case WSAEADDRNOTAVAIL: return (syserr_wsaeaddrnotavail); case WSAENETDOWN: return (syserr_wsaenetdown); case WSAENETUNREACH: return (syserr_wsaenetunreach); case WSAENETRESET: return (syserr_wsaenetreset); case WSAECONNABORTED: return (syserr_wsaeconnaborted); case WSAECONNRESET: return (syserr_wsaeconnreset); case WSAENOBUFS: return (syserr_wsaenobufs); case WSAEISCONN: return (syserr_wsaeisconn); case WSAENOTCONN: return (syserr_wsaenotconn); case WSAESHUTDOWN: return (syserr_wsaeshutdown); case WSAETOOMANYREFS: return (syserr_wsaetoomanyrefs); case WSAETIMEDOUT: return (syserr_wsaetimedout); case WSAECONNREFUSED: return (syserr_wsaeconnrefused); case WSAELOOP: return (syserr_wsaeloop); case WSAENAMETOOLONG: return (syserr_wsaenametoolong); case WSAEHOSTDOWN: return (syserr_wsaehostdown); case WSAEHOSTUNREACH: return (syserr_wsaehostunreach); case WSAENOTEMPTY: return (syserr_wsaenotempty); case WSAEPROCLIM: return (syserr_wsaeproclim); case WSAEUSERS: return (syserr_wsaeusers); case WSAEDQUOT: return (syserr_wsaedquot); case WSAESTALE: return (syserr_wsaestale); case WSAEREMOTE: return (syserr_wsaeremote); case WSAEDISCON: return (syserr_wsaediscon); case WSASYSNOTREADY: return (syserr_wsasysnotready); case WSAVERNOTSUPPORTED: return (syserr_wsavernotsupported); case WSANOTINITIALISED: return (syserr_wsanotinitialised); case WSAHOST_NOT_FOUND: return (syserr_wsahost_not_found); case WSATRY_AGAIN: return (syserr_wsatry_again); case WSANO_RECOVERY: return (syserr_wsano_recovery); case WSANO_DATA: return (syserr_wsano_data); default: return (syserr_unknown); } }