error_codes.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
// Preserve Windows error values and remove conflicting macros before the enum.
#ifdef _WIN32
#include <libplatform/windows_compat.h>
#endif

typedef enum {
  /* Standard codes (0-2) - Unix conventions */
  ASCIICHAT_OK = 0,  
  ERROR_GENERAL = 1, 
  ERROR_USAGE = 2,   
 
  /* Initialization failures (3-19) */
  ERROR_MEMORY = 3,        
  ERROR_CONFIG = 4,        
  ERROR_CRYPTO_INIT = 5,   
  ERROR_LOGGING_INIT = 6,  
  ERROR_PLATFORM_INIT = 7, 
  ERROR_INIT = 8,          
 
  /* Hardware/Device errors (20-39) */
  ERROR_WEBCAM = 20,            
  ERROR_WEBCAM_IN_USE = 21,     
  ERROR_WEBCAM_PERMISSION = 22, 
  ERROR_AUDIO = 23,             
  ERROR_AUDIO_IN_USE = 24,      
  ERROR_TERMINAL = 25,          
  ERROR_MEDIA_INIT = 26,        
  ERROR_MEDIA_OPEN = 27,        
  ERROR_MEDIA_DECODE = 28,      
  ERROR_MEDIA_SEEK = 29,        
  ERROR_NOT_SUPPORTED = 30,     
 
  /* Network errors (40-59) */
  ERROR_NETWORK = 40,          
  ERROR_NETWORK_BIND = 41,     
  ERROR_NETWORK_CONNECT = 42,  
  ERROR_NETWORK_TIMEOUT = 43,  
  ERROR_NETWORK_PROTOCOL = 44, 
  ERROR_NETWORK_SIZE = 45,     
 
  /* Session and protocol errors (46-55) */
  ERROR_RATE_LIMITED = 46,        
  ERROR_SESSION_NOT_FOUND = 47,   
  ERROR_SESSION_FULL = 48,        
  ERROR_INVALID_PASSWORD = 49,    
  ERROR_INVALID_SIGNATURE = 50,   
  ERROR_ACDS_STRING_TAKEN = 51,   
  ERROR_ACDS_STRING_INVALID = 52, 
  ERROR_INTERNAL = 53,            
  ERROR_UNKNOWN_PACKET = 54,      
 
  ERROR_NETWORK_INCOMPLETE = 55, 
 
  /* Security/Crypto errors (60-79) */
  ERROR_CRYPTO = 60,              
  ERROR_CRYPTO_KEY = 61,          
  ERROR_CRYPTO_AUTH = 62,         
  ERROR_CRYPTO_HANDSHAKE = 63,    
  ERROR_CRYPTO_VERIFICATION = 64, 
 
  /* Runtime errors (80-99) */
  ERROR_THREAD = 80,             
  ERROR_BUFFER = 81,             
  ERROR_BUFFER_FULL = 82,        
  ERROR_BUFFER_OVERFLOW = 83,    
  ERROR_DISPLAY = 84,            
  ERROR_INVALID_STATE = 85,      
  ERROR_INVALID_PARAM = 86,      
  ERROR_INVALID_FRAME = 87,      
  ERROR_RESOURCE_EXHAUSTED = 88, 
  ERROR_FORMAT = 89,             
  ERROR_STRING = 90,             
  ERROR_PROMPT_TIMEOUT = 92,     
  ERROR_NOT_FOUND = 91,          
 
  /* Signal/Crash handlers (100-127) */
  ERROR_SIGNAL_INTERRUPT = 100, 
  ERROR_SIGNAL_CRASH = 101,     
  ERROR_ASSERTION_FAILED = 102, 
 
  /* Compression errors (103-104) */
  ERROR_COMPRESSION = 103,   
  ERROR_DECOMPRESSION = 104, 
 
  /* File system errors (105-109) */
  ERROR_FILE_OPERATION = 105, 
  ERROR_FILE_NOT_FOUND = 106, 
 
  /* Process errors (110-119) */
  ERROR_PROCESS_FAILED = 110, 
 
  /* YouTube/URL streaming errors (111-116) */
  ERROR_YOUTUBE_INVALID_URL = 111,    
  ERROR_YOUTUBE_EXTRACT_FAILED = 112, 
  ERROR_YOUTUBE_UNPLAYABLE = 113,     
  ERROR_YOUTUBE_NETWORK = 114,        
  ERROR_YOUTUBE_NOT_SUPPORTED = 115,  
 
  /* Reserved (128-255) - Should not be used */
  /* 128+N typically means "terminated by signal N" on Unix systems */
 
} asciichat_error_t;

static inline const char *asciichat_error_name(asciichat_error_t code) {
  switch (code) {
  case ASCIICHAT_OK:
    return "ASCIICHAT_OK";
  case ERROR_GENERAL:
    return "ERROR_GENERAL";
  case ERROR_USAGE:
    return "ERROR_USAGE";
  case ERROR_MEMORY:
    return "ERROR_MEMORY";
  case ERROR_CONFIG:
    return "ERROR_CONFIG";
  case ERROR_CRYPTO_INIT:
    return "ERROR_CRYPTO_INIT";
  case ERROR_LOGGING_INIT:
    return "ERROR_LOGGING_INIT";
  case ERROR_PLATFORM_INIT:
    return "ERROR_PLATFORM_INIT";
  case ERROR_INIT:
    return "ERROR_INIT";
  case ERROR_WEBCAM:
    return "ERROR_WEBCAM";
  case ERROR_WEBCAM_IN_USE:
    return "ERROR_WEBCAM_IN_USE";
  case ERROR_WEBCAM_PERMISSION:
    return "ERROR_WEBCAM_PERMISSION";
  case ERROR_AUDIO:
    return "ERROR_AUDIO";
  case ERROR_AUDIO_IN_USE:
    return "ERROR_AUDIO_IN_USE";
  case ERROR_TERMINAL:
    return "ERROR_TERMINAL";
  case ERROR_MEDIA_INIT:
    return "ERROR_MEDIA_INIT";
  case ERROR_MEDIA_OPEN:
    return "ERROR_MEDIA_OPEN";
  case ERROR_MEDIA_DECODE:
    return "ERROR_MEDIA_DECODE";
  case ERROR_MEDIA_SEEK:
    return "ERROR_MEDIA_SEEK";
  case ERROR_NOT_SUPPORTED:
    return "ERROR_NOT_SUPPORTED";
  case ERROR_NETWORK:
    return "ERROR_NETWORK";
  case ERROR_NETWORK_BIND:
    return "ERROR_NETWORK_BIND";
  case ERROR_NETWORK_CONNECT:
    return "ERROR_NETWORK_CONNECT";
  case ERROR_NETWORK_TIMEOUT:
    return "ERROR_NETWORK_TIMEOUT";
  case ERROR_NETWORK_PROTOCOL:
    return "ERROR_NETWORK_PROTOCOL";
  case ERROR_NETWORK_SIZE:
    return "ERROR_NETWORK_SIZE";
  case ERROR_RATE_LIMITED:
    return "ERROR_RATE_LIMITED";
  case ERROR_SESSION_NOT_FOUND:
    return "ERROR_SESSION_NOT_FOUND";
  case ERROR_SESSION_FULL:
    return "ERROR_SESSION_FULL";
  case ERROR_INVALID_PASSWORD:
    return "ERROR_INVALID_PASSWORD";
  case ERROR_INVALID_SIGNATURE:
    return "ERROR_INVALID_SIGNATURE";
  case ERROR_ACDS_STRING_TAKEN:
    return "ERROR_ACDS_STRING_TAKEN";
  case ERROR_ACDS_STRING_INVALID:
    return "ERROR_ACDS_STRING_INVALID";
  case ERROR_INTERNAL:
    return "ERROR_INTERNAL";
  case ERROR_UNKNOWN_PACKET:
    return "ERROR_UNKNOWN_PACKET";
  case ERROR_NETWORK_INCOMPLETE:
    return "ERROR_NETWORK_INCOMPLETE";
  case ERROR_CRYPTO:
    return "ERROR_CRYPTO";
  case ERROR_CRYPTO_KEY:
    return "ERROR_CRYPTO_KEY";
  case ERROR_CRYPTO_AUTH:
    return "ERROR_CRYPTO_AUTH";
  case ERROR_CRYPTO_HANDSHAKE:
    return "ERROR_CRYPTO_HANDSHAKE";
  case ERROR_CRYPTO_VERIFICATION:
    return "ERROR_CRYPTO_VERIFICATION";
  case ERROR_THREAD:
    return "ERROR_THREAD";
  case ERROR_BUFFER:
    return "ERROR_BUFFER";
  case ERROR_BUFFER_FULL:
    return "ERROR_BUFFER_FULL";
  case ERROR_BUFFER_OVERFLOW:
    return "ERROR_BUFFER_OVERFLOW";
  case ERROR_DISPLAY:
    return "ERROR_DISPLAY";
  case ERROR_INVALID_STATE:
    return "ERROR_INVALID_STATE";
  case ERROR_INVALID_PARAM:
    return "ERROR_INVALID_PARAM";
  case ERROR_INVALID_FRAME:
    return "ERROR_INVALID_FRAME";
  case ERROR_RESOURCE_EXHAUSTED:
    return "ERROR_RESOURCE_EXHAUSTED";
  case ERROR_FORMAT:
    return "ERROR_FORMAT";
  case ERROR_STRING:
    return "ERROR_STRING";
  case ERROR_PROMPT_TIMEOUT:
    return "ERROR_PROMPT_TIMEOUT";
  case ERROR_NOT_FOUND:
    return "ERROR_NOT_FOUND";
  case ERROR_SIGNAL_INTERRUPT:
    return "ERROR_SIGNAL_INTERRUPT";
  case ERROR_SIGNAL_CRASH:
    return "ERROR_SIGNAL_CRASH";
  case ERROR_ASSERTION_FAILED:
    return "ERROR_ASSERTION_FAILED";
  case ERROR_COMPRESSION:
    return "ERROR_COMPRESSION";
  case ERROR_DECOMPRESSION:
    return "ERROR_DECOMPRESSION";
  case ERROR_FILE_OPERATION:
    return "ERROR_FILE_OPERATION";
  case ERROR_FILE_NOT_FOUND:
    return "ERROR_FILE_NOT_FOUND";
  case ERROR_PROCESS_FAILED:
    return "ERROR_PROCESS_FAILED";
  case ERROR_YOUTUBE_INVALID_URL:
    return "ERROR_YOUTUBE_INVALID_URL";
  case ERROR_YOUTUBE_EXTRACT_FAILED:
    return "ERROR_YOUTUBE_EXTRACT_FAILED";
  case ERROR_YOUTUBE_UNPLAYABLE:
    return "ERROR_YOUTUBE_UNPLAYABLE";
  case ERROR_YOUTUBE_NETWORK:
    return "ERROR_YOUTUBE_NETWORK";
  case ERROR_YOUTUBE_NOT_SUPPORTED:
    return "ERROR_YOUTUBE_NOT_SUPPORTED";
  default:
    return "ERROR_UNKNOWN";
  }
}

static inline const char *asciichat_error_string(asciichat_error_t code) {
  switch (code) {
  case ASCIICHAT_OK:
    return "Success";
  case ERROR_PROMPT_TIMEOUT:
    return "Prompt timed out";
  case ERROR_GENERAL:
    return "General error";
  case ERROR_USAGE:
    return "Invalid command line usage";
  case ERROR_MEMORY:
    return "Memory allocation failed";
  case ERROR_CONFIG:
    return "Configuration error";
  case ERROR_CRYPTO_INIT:
    return "Cryptographic initialization failed";
  case ERROR_LOGGING_INIT:
    return "Logging initialization failed";
  case ERROR_PLATFORM_INIT:
    return "Platform initialization failed";
  case ERROR_INIT:
    return "Initialization failed";
  case ERROR_WEBCAM:
    return "Webcam error";
  case ERROR_WEBCAM_IN_USE:
    return "Webcam in use by another application";
  case ERROR_WEBCAM_PERMISSION:
    return "Webcam permission denied";
  case ERROR_AUDIO:
    return "Audio device error";
  case ERROR_AUDIO_IN_USE:
    return "Audio device in use";
  case ERROR_TERMINAL:
    return "Terminal error";
  case ERROR_MEDIA_INIT:
    return "Media source initialization failed";
  case ERROR_MEDIA_OPEN:
    return "Failed to open media file or stream";
  case ERROR_MEDIA_DECODE:
    return "Media decoding failed";
  case ERROR_MEDIA_SEEK:
    return "Media seek operation failed";
  case ERROR_NOT_SUPPORTED:
    return "Operation not supported";
  case ERROR_NETWORK:
    return "Network error";
  case ERROR_NETWORK_BIND:
    return "Cannot bind to network port";
  case ERROR_NETWORK_CONNECT:
    return "Cannot connect to server";
  case ERROR_NETWORK_INCOMPLETE:
    return "Incomplete network message";
  case ERROR_NETWORK_TIMEOUT:
    return "Network timeout";
  case ERROR_NETWORK_PROTOCOL:
    return "Network protocol error";
  case ERROR_NETWORK_SIZE:
    return "Network packet size error";
  case ERROR_RATE_LIMITED:
    return "Rate limit exceeded";
  case ERROR_SESSION_NOT_FOUND:
    return "Session not found";
  case ERROR_SESSION_FULL:
    return "Session is full";
  case ERROR_INVALID_PASSWORD:
    return "Invalid password";
  case ERROR_INVALID_SIGNATURE:
    return "Invalid signature";
  case ERROR_ACDS_STRING_TAKEN:
    return "Session string already in use";
  case ERROR_ACDS_STRING_INVALID:
    return "Invalid session string";
  case ERROR_INTERNAL:
    return "Internal server error";
  case ERROR_UNKNOWN_PACKET:
    return "Unknown packet type";
  case ERROR_CRYPTO:
    return "Cryptographic error";
  case ERROR_CRYPTO_KEY:
    return "Cryptographic key error";
  case ERROR_CRYPTO_AUTH:
    return "Authentication failed";
  case ERROR_CRYPTO_HANDSHAKE:
    return "Cryptographic handshake failed";
  case ERROR_CRYPTO_VERIFICATION:
    return "Signature verification failed";
  case ERROR_THREAD:
    return "Thread error";
  case ERROR_BUFFER:
    return "Buffer error";
  case ERROR_BUFFER_FULL:
    return "Buffer full";
  case ERROR_BUFFER_OVERFLOW:
    return "Buffer overflow";
  case ERROR_DISPLAY:
    return "Display error";
  case ERROR_INVALID_STATE:
    return "Invalid program state";
  case ERROR_INVALID_PARAM:
    return "Invalid parameter";
  case ERROR_INVALID_FRAME:
    return "Invalid frame data";
  case ERROR_RESOURCE_EXHAUSTED:
    return "System resources exhausted";
  case ERROR_FORMAT:
    return "String formatting operation failed";
  case ERROR_STRING:
    return "String manipulation operation failed";
  case ERROR_NOT_FOUND:
    return "Resource not found";
  case ERROR_SIGNAL_INTERRUPT:
    return "Interrupted by signal";
  case ERROR_SIGNAL_CRASH:
    return "Terminated by fatal signal";
  case ERROR_ASSERTION_FAILED:
    return "Assertion failed";
  case ERROR_COMPRESSION:
    return "Compression operation failed";
  case ERROR_DECOMPRESSION:
    return "Decompression operation failed";
  case ERROR_FILE_OPERATION:
    return "File or directory operation failed";
  case ERROR_FILE_NOT_FOUND:
    return "File or directory not found";
  case ERROR_PROCESS_FAILED:
    return "Process execution or termination failed";
  case ERROR_YOUTUBE_INVALID_URL:
    return "Invalid YouTube URL format";
  case ERROR_YOUTUBE_EXTRACT_FAILED:
    return "YouTube URL extraction failed";
  case ERROR_YOUTUBE_UNPLAYABLE:
    return "Video cannot be played";
  case ERROR_YOUTUBE_NETWORK:
    return "YouTube network error";
  case ERROR_YOUTUBE_NOT_SUPPORTED:
    return "YouTube support not compiled";
  default:
    return "Unknown error";
  }
}