app/error.cpp

   1 #include "error.hpp"
   2
   3 #include <alut.h>
   4 #include <cerrno>
   5 #include <cstring>
   6 #include <SDL.h>
   7 #include <SDL_net.h>
   8 #include <SDL_ttf.h>
   9 #include <GL/glew.h>
  10
  11 using namespace std;
  12
  13
  14 namespace {
  15
  16 string alut_error_append(ALenum num, string msg) {
  17         const char *error = alutGetErrorString(num);
  18         if (error && *error != '\0') {
  19                 msg += ": ";
  20                 msg += error;
  21         }
  22         return msg;
  23 }
  24
  25 string gl_error_append(string msg) {
  26         const GLubyte *error = gluErrorString(glGetError());
  27         if (error && *error != '\0') {
  28                 const GLubyte *errEnd = error;
  29                 while (*errEnd != '\0') {
  30                         ++errEnd;
  31                 }
  32                 msg += ": ";
  33                 msg.append(error, errEnd);
  34         }
  35         return msg;
  36 }
  37
  38 string gl_error_get() {
  39         string msg;
  40         const GLubyte *error = gluErrorString(glGetError());
  41         if (error && *error != '\0') {
  42                 const GLubyte *errEnd = error;
  43                 while (*errEnd != '\0') {
  44                         ++errEnd;
  45                 }
  46                 msg.assign(error, errEnd);
  47         }
  48         return msg;
  49 }
  50
  51 string net_error_append(string msg) {
  52         const char *error = SDLNet_GetError();
  53         if (*error != '\0') {
  54                 msg += ": ";
  55                 msg += error;
  56         }
  57         return msg;
  58 }
  59
  60 string sdl_error_append(string msg) {
  61         const char *error = SDL_GetError();
  62         if (error && *error != '\0') {
  63                 msg += ": ";
  64                 msg += error;
  65                 SDL_ClearError();
  66         }
  67         return msg;
  68 }
  69
  70 string ttf_error_append(string msg) {
  71         const char *error = TTF_GetError();
  72         if (error && *error != '\0') {
  73                 msg += ": ";
  74                 msg += error;
  75         }
  76         return msg;
  77 }
  78
  79 }
  80
  81
  82 namespace blank {
  83
  84 AlutError::AlutError(ALenum num)
  85 : runtime_error(alutGetErrorString(num)) {
  86
  87 }
  88
  89 AlutError::AlutError(ALenum num, const string &msg)
  90 : runtime_error(alut_error_append(num, msg)) {
  91
  92 }
  93
  94
  95 GLError::GLError()
  96 : runtime_error(gl_error_get()) {
  97
  98 }
  99
 100 GLError::GLError(const string &msg)
 101 : runtime_error(gl_error_append(msg)) {
 102
 103 }
 104
 105
 106 NetError::NetError()
 107 : runtime_error(SDLNet_GetError()) {
 108
 109 }
 110
 111 NetError::NetError(const string &msg)
 112 : runtime_error(net_error_append(msg)) {
 113
 114 }
 115
 116
 117 SDLError::SDLError()
 118 : runtime_error(SDL_GetError()) {
 119
 120 }
 121
 122 SDLError::SDLError(const string &msg)
 123 : runtime_error(sdl_error_append(msg)) {
 124
 125 }
 126
 127
 128 SysError::SysError()
 129 : SysError(errno) {
 130
 131 }
 132
 133 SysError::SysError(const string &msg)
 134 : SysError(errno, msg) {
 135
 136 }
 137
 138 SysError::SysError(int err_num)
 139 : runtime_error(strerror(err_num)) {
 140
 141 }
 142
 143 SysError::SysError(int err_num, const string &msg)
 144 : runtime_error(msg + ": " + strerror(err_num)) {
 145
 146 }
 147
 148
 149 TTFError::TTFError()
 150 : runtime_error(TTF_GetError()) {
 151
 152 }
 153
 154 TTFError::TTFError(const string &msg)
 155 : runtime_error(ttf_error_append(msg)) {
 156
 157 }
 158
 159 }